Accelerate documentation

FSDP frente a DeepSpeed

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

and get access to the augmented documentation experience

to get started

FSDP frente a DeepSpeed

Accelerate ofrece flexibilidad en los marcos de trabajo de entrenamiento al integrar dos herramientas extremadamente potentes para el entrenamiento distribuido, a saber, Pytorch FSDP y Microsoft DeepSpeed. El objetivo de este tutorial es establecer paralelismos y, al mismo tiempo, señalar posibles diferencias, para que el usuario pueda cambiar entre estos dos marcos de trabajo de manera fluida.

Para cambiar entre los frameworks, recomendamos ejecutar el código accelerate launch pasando el archivo de configuración correcto con --config_file, o pasando directamente los argumentos respectivos para FSDP y DeepSpeed .

Se pueden encontrar configuraciones de ejemplo de Accelerate aquí para DeepSpeed y FSDP, o en el zoo de ejemplos bajo “Launch Configurations”

Este tutorial es solo para escenarios de un solo nodo con varias GPU.

Configuración de funcionalidades

Los tensores del modelo se dividen en diferentes GPUs en un intento de escalar los tamaños de los modelos; esto se denomina sharding en FSDP y partitioning en DeepSpeed. El sharding de FSDP y las etapas de DeepSpeed ZeRO (partitioning) se configuran mediante --fsdp_sharding_strategy y --zero_stage, respectivamente. En particular, FULL_SHARD de FSDP se corresponde con la etapa 3 de DeepSpeed ZeRO; consulte este mapeo exhaustivo entre la configuración de sharding de FSDP y la de DeepSpeed ZeRO. La siguiente tabla resume y agrupa las configuraciones similares:

GrupoFrameworkConfiguraciónEjemploRestricciones (si las hay)
sharding / particionamientoFSDP
DeepSpeed
--fsdp_sharding_strategy
--zero_stage
1 (FULL_SHARD)
3
offloadFSDP
DeepSpeed
--fsdp_offload_params
--offload_param_device
--offload_optimizer_device
true
cpu
cpu
todo o nada

carga de modelosFSDP
DeepSpeed
--fsdp_cpu_ram_efficient_loading
--zero3_init_flag
true
true

solo ZeRO 3
puntos de control eficientesFSDP
DeepSpeed
--fsdp_state_dict_type
--zero3_save_16bit_model
SHARDED_STATE_DICT
true

solo ZeRO 3
precarga de pesosFSDP

DeepSpeed
--fsdp_forward_prefetch
--fsdp_backward_prefetch
None
true
BACKWARD_PRE


modelFSDP

DeepSpeed
--fsdp_auto_wrap_policy
--fsdp_transformer_layer_cls_to_wrap
None
TRANSFORMER_BASED_WRAP
<Clase de capa>

Normalmente no es necesario
Transparente para el usuario.
parámetros de invocaciónFSDP
DeepSpeed
--fsdp_use_orig_params
Ninguno
truenecesario para torch.compile
Transparente para el usuario
sincronización de parámetrosFSDP
DeepSpeed
--fsdp_sync_module_states
Ninguno
true
entrenamientoFSDP
DeepSpeed
None
--gradient_accumulation_steps
--gradient_clipping

auto
auto
Transparente para el usuario

Para obtener descripciones detalladas de lo anterior, consulte la documentación de lanzamiento de Accelerate.

Para acceder a otras configuraciones de DeepSpeed, como los ajustes de precisión mixta, debe pasar un --deepspeed_config_file, consulte la documentación.

DeepSpeed también se puede configurar mediante DeepSpeedPlugin, por ejemplo, DeepSpeedPlugin.zero_stage es equivalente a --zero_stage, y DeepSpeedPlugin.hf_ds_config se puede usar para pasar --deepeed_config_file.

FSDP también se puede configurar mediante FullyShardedDataParallelPlugin, por ejemplo, FullyShardedDataParallelPlugin.sharding_strategy es equivalente a --fsdp_sharding_strategy.

Checkpointing

Tenga en cuenta que, si bien FSDP puede configurarse mediante --fsdp_state_dict_type para guardar puntos de control completos o fragmentados.

Para DeepSpeed Zero3, se puede pasar --zero3_save_16bit_model true, lo que consolida convenientemente el modelo en un solo rank y lo guarda; esto es el equivalente de FSDP de fsdp_state_dict_type: FULL_STATE_DICT.

Para modelos grandes, consolidar el modelo en un solo rango puede ser muy lento.

Para un guardado de puntos de control más rápido, para FSDP use fsdp_state_dict_type: SHARDED_STATE_DICT, y para DeepSpeed Zero3 use el script zero_to_fp32.py para convertir los puntos de control fragmentados después de su creación.

Descarga

FSDP solo permite el offload all-or-nothing (es decir, o se descargan los parámetros, los gradientes y el optimizador, o se mantienen todos en la GPU), pero DeepSpeed puede descargar los parámetros y el optimizador de manera diferente. Además, DeepSpeed también admite offloading a NVME.

Prefetching

FSDP permite dos configuraciones de prefetching, --fsdp_forward_prefetch y --fsdp_backward_prefetch, para mejorar la superposición de comunicaciones y cómputo a costa de memoria adicional, consulte la documentación de FSDP. En el caso de DeepSpeed, el prefetching se activará cuando sea necesario, y se activa en función de ciertos hiperparámetros como stage3_param_persistence_threshold, stage3_max_reuse_distance, etc., que se pueden configurar para Zero3; accelerate puede establecer estos hiperparámetros automáticamente si no los define explícitamente en el archivo de configuración de deepspeed.

Para FSDP, establece fsdp_backward_prefetch: BACKWARD_PRE para mejorar el rendimiento si la memoria lo permite.

Carga de modelos

Aunque FSDP requiere un --fsdp_cpu_ram_efficient_loading true explícito para activar la carga eficiente del modelo, transformers activará la función similar siempre que se utilice DeepSpeed Zero3.

Para FSDP, cada vez que se establece --fsdp_cpu_ram_efficient_loading true, accelerate configurará automáticamente sync_module_states en true. Para la carga eficiente de RAM, los pesos se cargarán solo en un único rank, por lo que se requiere sync_module_states para difundir los pesos a los demás ranks.

Modelo

FSDP requiere una política explícita --fsdp_auto_wrap_policy para que el algoritmo decida cómo programar las operaciones all-gather y reduce-scatter. Pero en el caso de DeepSpeed, esto es transparente para el usuario.

Para FSDP, simplemente establece fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP. Con las últimas versiones de transformers, intentamos determinar el fsdp_transformer_layer_cls_to_wrap adecuado para los modelos de transformers de HF. Sin embargo, si obtienes un error al respecto, especifica este parámetro.

Parámetros de invocación

FSDP requiere la bandera explícita --fsdp_use_orig_params si se usa torch.compile, consulte la documentación de pytorch. Para DeepSpeed, esto es transparente para el usuario.

Para FSDP, al usar torch.compile establezca fsdp_use_orig_params: True.

Entrenamiento

Deepspeed requiere las banderas explícitas --gradient_accumulation_steps y --gradient_clipping. En el caso de FSDP, esto es transparente para el usuario.

Al usar DeepSpeed, establezca gradient_accumulation_steps: "auto" y gradient_clipping: "auto" para recuperar automáticamente los valores definidos en Accelerator o TrainingArguments (si se usa transformers).

Sobre las diferencias en el manejo de la precisión de los datos

Para discutir cómo se maneja la precisión de los datos en FSDP y DeepSpeed, resulta instructivo ofrecer primero una visión general de cómo se manejan los parámetros del modelo en estos marcos de trabajo. Antes de que los parámetros del modelo / optimizador se distribuyan entre las GPUs, se realiza una preparación de parámetros para “aplanarlos” primero en torch.Tensor de una dimensión. La implementación de FSDP / DeepSpeed varía en cuanto al dtype en el que se almacenan estos parámetros “aplanados”, y esto tiene implicaciones sobre cómo torch.Optimizer asigna sus dtypes. La tabla siguiente detalla los procesos de ambos marcos de trabajo; la columna “Local” indica el proceso que ocurre a nivel de cada GPU, por lo que cualquier sobrecarga de memoria debida a la conversión a un tipo de mayor precisión debe entenderse como amortizada por el número de GPUs utilizadas.

Como regla general, para un entrenamiento estable con precisión mixta automática, todos los parámetros entrenables deben estar en torch.float32.

ProcesoLocalFrameworkDetalles
Carga, es decir, AutoModel.from_pretrained(..., torch_dtype=torch_dtype)
Preparación, es decir, creación de “flat params”✅FSDP
DeepSpeed
creado en torch_dtype.
ignora torch_dtype, creado en float32.
Inicialización del optimizador✅FSDP
DeepSpeed
crea parámetros en torch_dtype
crea parámetros en float32
Paso de entrenamiento, es decir, hacia adelante, hacia atrás, reducciónFSDP
DeepSpeed
sigue MixedPrecision
sigue las configuraciones de precisión mixta de deepspeed_config_file.
Optimizador (Antes del paso)✅FSDP
DeepSpeed
el escalado hacia arriba (si lo hay) a torch_dtype
escalado a float32
Optimizador (Paso actual)✅FSDP
DeepSpeed
ocurre en torch_dtype
ocurre en float32.

Por lo tanto, al usar DeepSpeed con un número pequeño de GPUs, tenga en cuenta los posibles sobrecostos significativos de memoria debido al upcasting durante la preparación.

Con FSDP, en ausencia de precisión mixta, es posible operar el torch.Optimizer en baja precisión torch_dtype, lo cual puede ser útil al usar un número pequeño de GPUs.

Con precisión mixta, FSDP y DeepSpeed realizarán un aumento de precisión en el paso de preparación del modelo (véase la tabla anterior). Sin embargo, tenga en cuenta que FSDP guardará los puntos de control en la precisión aumentada; DeepSpeed aún puede guardar puntos de control de baja precisión si se especifica --zero3_save_16bit_model.

Para aclarar la tabla anterior, considere los ejemplos concretos a continuación; el paso previo y el paso real del optimizador se combinan por brevedad. Con FSDP es posible operar en los dos modos mostrados a continuación, pero DeepSpeed solo puede operar en uno.

FrameworkCarga de modelos (torch_dtype)Precisión mixtaPreparación (local)EntrenamientoOptimizador (local)
FSDPbf16predeterminado (ninguno)bf16bf16bf16
FSDPbf16bf16fp32bf16fp32
DeepSpeedbf16bf16fp32bf16fp32
Update on GitHub