Accelerate documentation
Utilidades de Fully Sharded Data Parallel
Utilidades de Fully Sharded Data Parallel
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
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
< source >( 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 predeterminadoTrue) — Si se deben guardar los pesos fusionados con safetensors (recomendado). - remove_checkpoint_dir (
bool, opcional, valor predeterminadoFalse) — 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
< source >( 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 defecto1) — 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 unastro una instancia detorch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy. Está en desuso a favor dereshard_after_forward. - reshard_after_forward (
Union[str, torch.distributed.fsdp.ShardingStrategy, bool], por defecto'FULL_SHARD'parafsdp_version=1yTrueparafsdp_version=2) — Estrategia de sharding a utilizar. Debe ser un bool sifsdp_versionestá establecido en 2, en caso contrario, unstro una instancia detorch.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 unastro una instancia detorch.distributed.fsdp.fully_sharded_data_parallel.BackwardPrefetch. - mixed_precision_policy (
Optional[Union[dict, str, torch.distributed.fsdp.MixedPrecision, torch.distributed.fsdp.MixedPrecisionPolicy]], por defectoNone) — Una configuración para habilitar el entrenamiento con precisión mixta mediante FullyShardedDataParallel. Si se pasa undict, debe tener las siguientes claves:param_dtype,reduce_dtypeybuffer_dtype. Puede ser una instancia detorch.distributed.fsdp.MixedPrecisionPolicysifsdp_versionestá establecido en 2. Si se pasa unstr, debe ser uno de los siguientes valores: fp8, fp16, bf16, fp32, y se utiliza para establecerparam_dtype,reduce_dtypeybuffer_dtype. - auto_wrap_policy (
Optional(Union[Callable, Literal["transformer_based_wrap", "size_based_wrap", "no_wrap"]]), defaults toNO_WRAP) -- A callable or string specifying a policy to recursively wrap layers with FSDP. If a string, it must be one oftransformer_based_wrap,size_based_wrap, orno_wrap. Seetorch.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 defectoFalse) — Si se deben descargar los parámetros a la CPU. Debe ser unboolo una instancia detorch.distributed.fsdp.fully_sharded_data_parallel.CPUOffloadotorch.distributed.fsdp.fully_sharded_data_parallel.CPUOffloadPolicysifsdp_versionestá establecido en 2. - ignored_modules (
Optional[Union[Iterable[torch.nn.Module], str]], por defectoNone) — 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. Sifsdp_versionestá 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 defull_state_dict,local_state_dictosharded_state_dict. - state_dict_config (
Optional[Union[torch.distributed.fsdp.FullStateDictConfig, torch.distributed.fsdp.ShardedStateDictConfig], por defectoNone) — Configuración del state dict a utilizar. Se determina en función destate_dict_typesi no se proporciona. - optim_state_dict_config (
Optional[Union[torch.distributed.fsdp.FullOptimStateDictConfig, torch.distributed.fsdp.ShardedOptimStateDictConfig], por defectoNone) — Configuración del estado del optimizador a utilizar. Se determina en función destate_dict_typesi no se proporciona. - limit_all_gathers (
bool, por defectoTrue) — 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 defectoFalse) — Si se deben usar los parámetros originales para el optimizador. - param_init_fn (
Optional[Callable[[torch.nn.Module], None], por defectoNone) — UnCallable[torch.nn.Module] -> Noneque especifica cómo deben inicializarse en un dispositivo real los módulos que actualmente están en el dispositivo meta. Solo es aplicable cuandosync_module_statesesTrue. Por defecto es unlambdaque llama ato_emptyen el módulo. - sync_module_states (
bool, por defectoFalse) — 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 esFalsea menos quecpu_ram_efficient_loadingseaTrue, en cuyo caso se habilitará forzosamente. - forward_prefetch (
bool, por defectoFalse) — 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 defectoFalse) — 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 defectoNone) — 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_statesdebe serTrue. - transformer_cls_names_to_wrap (
Optional[List[str]], por defectoNone) — Una lista de nombres de clases de capas de transformer para envolver. Solo aplicable cuandoauto_wrap_policyestransformer_based_wrap. - min_num_params (
Optional[int], por defectoNone) — El número mínimo de parámetros que debe tener un módulo para ser envuelto. Solo aplicable cuandoauto_wrap_policyessize_based_wrap.
Este plugin se utiliza para habilitar el paralelismo de datos totalmente fragmentado.
Dado model, crea una auto_wrap_policy basada en la política pasada y si podemos usar transformer_cls_to_wrap
Establece la política de precisión mixta para FSDP
Establece la configuración del state dict en función del StateDictType.
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
< source >( 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 defectoFalse) — 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
< source >( 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
< source >( acceleratormodel: Module ) → torch.nn.Module
Prepara el modelo para FSDP2 in-place. También devuelve el modelo para evitar el uso incorrecto del modelo original.