Accelerate documentation

Utilidades de Fully Sharded Data Parallel

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Utilidades de Fully Sharded Data Parallel

enable_fsdp_ram_efficient_loading

accelerate.utils.enable_fsdp_ram_efficient_loading

< >

( )

Permite la carga eficiente en RAM de modelos de Hugging Face para FSDP en el entorno.

disable_fsdp_ram_efficient_loading

accelerate.utils.disable_fsdp_ram_efficient_loading

< >

( )

Desactiva la carga eficiente de RAM de los modelos de Hugging Face para FSDP en el entorno.

merge_fsdp_weights

accelerate.utils.merge_fsdp_weights

< >

( checkpoint_dir: stroutput_path: strsafe_serialization: bool = Trueremove_checkpoint_dir: bool = False )

Parámetros

  • checkpoint_dir (str) — El directorio que contiene los puntos de control de FSDP (puede ser del modelo o del optimizador).
  • output_path (str) — La ruta para guardar el punto de control fusionado.
  • safe_serialization (bool, opcional, valor predeterminado True) — Si se deben guardar los pesos fusionados con safetensors (recomendado).
  • remove_checkpoint_dir (bool, opcional, valor predeterminado False) — Si se debe eliminar el directorio de punto de control después de la fusión.

Fusiona los pesos de los puntos de control de modelos FSDP fragmentados en un único punto de control combinado. Debe usarse si se empleó SHARDED_STATE_DICT para el modelo. Los pesos se guardarán en {output_path}/model.safetensors si safe_serialization, en caso contrario en pytorch_model.bin.

Nota: este es un proceso limitado por la CPU.

FullyShardedDataParallelPlugin

clase accelerate.FullyShardedDataParallelPlugin

< >

( fsdp_version: int = Nonesharding_strategy: str | ForwardRef('torch.distributed.fsdp.ShardingStrategy') = Nonereshard_after_forward: str | ForwardRef('torch.distributed.fsdp.ShardingStrategy') | bool = Nonebackward_prefetch: str | ForwardRef('torch.distributed.fsdp.BackwardPrefetch') | None = Nonemixed_precision_policy: dict | str | ForwardRef('torch.distributed.fsdp.MixedPrecision') | ForwardRef('torch.distributed.fsdp.MixedPrecisionPolicy') | None = Noneauto_wrap_policy: typing.Callable | typing.Literal['transformer_based_wrap', 'size_based_wrap', 'no_wrap'] | None = Nonecpu_offload: bool | ForwardRef('torch.distributed.fsdp.CPUOffload') | ForwardRef('torch.distributed.fsdp.CPUOffloadPolicy') = Noneignored_modules: collections.abc.Iterable[torch.nn.Module] | str | None = Nonestate_dict_type: str | ForwardRef('torch.distributed.fsdp.StateDictType') = Nonestate_dict_config: ForwardRef('torch.distributed.fsdp.FullStateDictConfig') | ForwardRef('torch.distributed.fsdp.ShardedStateDictConfig') | None = Noneoptim_state_dict_config: ForwardRef('torch.distributed.fsdp.FullOptimStateDictConfig') | ForwardRef('torch.distributed.fsdp.ShardedOptimStateDictConfig') | None = Nonelimit_all_gathers: bool = Trueuse_orig_params: bool | None = Noneparam_init_fn: typing.Callable[[torch.nn.Module], NoneType] | None = Nonesync_module_states: bool | None = Noneforward_prefetch: bool = Noneactivation_checkpointing: bool = Noneactivation_checkpointing_offload: bool = Nonecpu_ram_efficient_loading: bool = Nonetransformer_cls_names_to_wrap: list[str] | None = Nonemin_num_params: int | None = None )

Parámetros

  • fsdp_version (int, por defecto 1) — La versión de FSDP a utilizar. Por defecto es 1. Si se establece en 2, el launcher espera que la configuración esté convertida al formato FSDP2.
  • sharding_strategy (Union[str, torch.distributed.fsdp.ShardingStrategy], por defecto 'FULL_SHARD') — Estrategia de particionamiento a utilizar. Debe ser una str o una instancia de torch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy. Está en desuso a favor de reshard_after_forward.
  • reshard_after_forward (Union[str, torch.distributed.fsdp.ShardingStrategy, bool], por defecto 'FULL_SHARD' para fsdp_version=1 y True para fsdp_version=2) — Estrategia de sharding a utilizar. Debe ser un bool si fsdp_version está establecido en 2, en caso contrario, un str o una instancia de torch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy.
  • backward_prefetch (Union[str, torch.distributed.fsdp.BackwardPrefetch], por defecto 'NO_PREFETCH') — Estrategia de prefetch en la fase de retropropagación a utilizar. Debe ser una str o una instancia de torch.distributed.fsdp.fully_sharded_data_parallel.BackwardPrefetch.
  • mixed_precision_policy (Optional[Union[dict, str, torch.distributed.fsdp.MixedPrecision, torch.distributed.fsdp.MixedPrecisionPolicy]], por defecto None) — Una configuración para habilitar el entrenamiento con precisión mixta mediante FullyShardedDataParallel. Si se pasa un dict, debe tener las siguientes claves: param_dtype, reduce_dtype y buffer_dtype. Puede ser una instancia de torch.distributed.fsdp.MixedPrecisionPolicy si fsdp_version está establecido en 2. Si se pasa un str, debe ser uno de los siguientes valores: fp8, fp16, bf16, fp32, y se utiliza para establecer param_dtype, reduce_dtype y buffer_dtype.
  • auto_wrap_policy (Optional(Union[Callable, Literal["transformer_based_wrap", "size_based_wrap", "no_wrap"]]), defaults to NO_WRAP) -- A callable or string specifying a policy to recursively wrap layers with FSDP. If a string, it must be one of transformer_based_wrap, size_based_wrap, or no_wrap. See torch.distributed.fsdp.wrap.size_based_wrap_policy` for a direction on what it should look like.
  • cpu_offload (Union[bool, torch.distributed.fsdp.CPUOffload, torch.distributed.fsdp.CPUOffloadPolicy], por defecto False) — Si se deben descargar los parámetros a la CPU. Debe ser un bool o una instancia de torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffload o torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffloadPolicy si fsdp_version está establecido en 2.
  • ignored_modules (Optional[Union[Iterable[torch.nn.Module], str]], por defecto None) — Una lista de módulos que se ignorarán al envolver con FSDP. Al pasar una cadena de caracteres, los módulos se coincidirán por nombre usando fullmatch de regex. Si fsdp_version está establecido en 2, los módulos se convierten en parámetros y se utilizan.
  • state_dict_type (Union[str, torch.distributed.fsdp.StateDictType], por defecto 'FULL_STATE_DICT') — Tipo de state dict a utilizar. Si es una cadena, debe ser una de full_state_dict, local_state_dict o sharded_state_dict.
  • state_dict_config (Optional[Union[torch.distributed.fsdp.FullStateDictConfig, torch.distributed.fsdp.ShardedStateDictConfig], por defecto None) — Configuración del state dict a utilizar. Se determina en función de state_dict_type si no se proporciona.
  • optim_state_dict_config (Optional[Union[torch.distributed.fsdp.FullOptimStateDictConfig, torch.distributed.fsdp.ShardedOptimStateDictConfig], por defecto None) — Configuración del estado del optimizador a utilizar. Se determina en función de state_dict_type si no se proporciona.
  • limit_all_gathers (bool, por defecto True) — Si FSDP debe sincronizar explícitamente el hilo de CPU para evitar demasiados all-gathers en curso. Este bool solo afecta a las estrategias fragmentadas que programan all-gathers. Habilitar esto puede ayudar a reducir el número de reintentos de malloc de CUDA.
  • use_orig_params (bool, por defecto False) — Si se deben usar los parámetros originales para el optimizador.
  • param_init_fn (Optional[Callable[[torch.nn.Module], None], por defecto None) — Un Callable[torch.nn.Module] -> None que especifica cómo deben inicializarse en un dispositivo real los módulos que actualmente están en el dispositivo meta. Solo es aplicable cuando sync_module_states es True. Por defecto es un lambda que llama a to_empty en el módulo.
  • sync_module_states (bool, por defecto False) — Si cada unidad FSDP envuelta individualmente debe difundir los parámetros del módulo desde el rank 0 para garantizar que sean los mismos en todos los ranks después de la inicialización. Por defecto es False a menos que cpu_ram_efficient_loading sea True, en cuyo caso se habilitará forzosamente.
  • forward_prefetch (bool, por defecto False) — Si FSDP debe preobtener explícitamente el próximo all-gather mientras se ejecuta en la pasada de adelante. Úsalo solo con grafos estáticos.
  • activation_checkpointing (bool, por defecto False) — Una técnica para reducir el uso de memoria eliminando las activaciones de ciertas capas y recalcándolas durante una paso de retropropagación. En la práctica, esto intercambia tiempo de cálculo adicional por un menor uso de memoria.
  • cpu_ram_efficient_loading (bool, por defecto None) — Si es True, solo el primer proceso carga el checkpoint del modelo preentrenado, mientras que todos los demás procesos tienen pesos vacíos. Solo aplicable para Transformers. Al usar esto, sync_module_states debe ser True.
  • transformer_cls_names_to_wrap (Optional[List[str]], por defecto None) — Una lista de nombres de clases de capas de transformer para envolver. Solo aplicable cuando auto_wrap_policy es transformer_based_wrap.
  • min_num_params (Optional[int], por defecto None) — El número mínimo de parámetros que debe tener un módulo para ser envuelto. Solo aplicable cuando auto_wrap_policy es size_based_wrap.

Este plugin se utiliza para habilitar el paralelismo de datos totalmente fragmentado.

set_auto_wrap_policy

< >

( model )

Dado model, crea una auto_wrap_policy basada en la política pasada y si podemos usar transformer_cls_to_wrap

set_mixed_precision

< >

( mixed_precisionbuffer_autocast = Falseoverride = False )

Establece la política de precisión mixta para FSDP

set_state_dict_type

< >

( state_dict_type = None )

Establece la configuración del state dict en función del StateDictType.

validate_mixed_precision_policy

< >

( )

Valida la política de precisión mixta, abstraída para no importar las dependencias si no son necesarias.

fsdp2_load_full_state_dict

accelerate.utils.fsdp2_load_full_state_dict

< >

( acceleratormodel: Modulefull_sd: dictcpu_offload: bool = False )

Parámetros

  • accelerator (Accelerator) — La instancia del acelerador
  • model (torch.nn.Module) — El modelo en el que se cargará el state dict, que se espera que esté en el dispositivo meta o puede producirse un pico de VRAM
  • full_sd (dict) — El state dict completo a cargar, solo puede estar en el rank 0
  • cpu_offload (bool, por defecto False) — Si es True, mueve los parámetros fragmentados a la CPU después de la distribución. Es obligatorio cuando el descargado de CPU de FSDP está habilitado. Los búferes y los parámetros ignorados permanecen en el dispositivo del acelerador.

Carga el estado completo del diccionario (posiblemente solo en el rank 0) en el modelo fragmentado. Esto se realiza transmitiendo los parámetros desde el rank 0 a todos los demás ranks. Esta función modifica el modelo in situ.

fsdp2_switch_optimizer_parameters

accelerate.utils.fsdp2_switch_optimizer_parameters

< >

( optimizer: Optimizermapping: dict )

Parámetros

  • optimizer (torch.optim.Optimizer) — Instancia del optimizador que contiene los parámetros originales del modelo
  • mapping (dict) — Mapeo desde el puntero de datos del parámetro original (o la identidad para parámetros meta) hasta el parámetro fragmentado.

Lanza

KeyError

  • KeyError — Si un parámetro del optimizador no pudo cambiarse a su versión fragmentada. Esto nunca debería ocurrir e indica un error. Si hubiéramos mantenido los parámetros originales en lugar de lanzar la excepción, el entrenamiento no sería numéricamente correcto y los pesos no se actualizarían.

Cambia los parámetros del optimizador por otros nuevos (parámetros fragmentados en el caso habitual). Esta función modifica el optimizador in-place.

fsdp2_prepare_model

accelerate.utils.fsdp2_prepare_model

< >

( acceleratormodel: Module ) → torch.nn.Module

Parámetros

  • accelerator (Accelerator) — La instancia del acelerador
  • model (torch.nn.Module) — El modelo que se va a preparar

Devuelve

torch.nn.Module

Modelo preparado

Prepara el modelo para FSDP2 in-place. También devuelve el modelo para evitar el uso incorrecto del modelo original.

fsdp2_prepare_auto_wrap_policy

Update on GitHub