Hugging Face's logo

Accelerate documentation

Funciones y clases de utilidad

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

Funciones y clases de utilidad

A continuación se muestran diversas funciones de utilidad que proporciona 🤗 Accelerate, clasificadas por caso de uso.

Constantes

Constantes utilizadas en todo 🤗 Accelerate como referencia

Los siguientes son constantes utilizadas al emplear Accelerator.save_state()

utils.MODEL_NAME: "pytorch_model" utils.OPTIMIZER_NAME: "optimizer" utils.RNG_STATE_NAME: "random_states" utils.SCALER_NAME: "scaler.pt utils.SCHEDULER_NAME: "scheduler

Los siguientes son constantes utilizadas al emplear Accelerator.save_model()

utils.WEIGHTS_NAME: "pytorch_model.bin" utils.SAFE_WEIGHTS_NAME: "model.safetensors" utils.WEIGHTS_INDEX_NAME: "pytorch_model.bin.index.json" utils.SAFE_WEIGHTS_INDEX_NAME: "model.safetensors.index.json"

Clases de datos

Estas son dataclasses básicas que se utilizan en todo 🤗 Accelerate y pueden pasarse como parámetros.

Independiente

Estas son dataclasses independientes que se utilizan para comprobaciones, como el tipo de sistema distribuido que se está utilizando

clase accelerate.utils.ComputeEnvironment

< >

( *values )

Representa un tipo de entorno de cálculo.

Valores:

  • LOCAL_MACHINE — hardware de clúster privado/personalizado.
  • AMAZON_SAGEMAKER — Amazon SageMaker como entorno de cálculo.

clase accelerate.DistributedType

< >

( *values )

Representa un tipo de entorno distribuido.

Valores:

  • NO — No es un entorno distribuido, solo un proceso único.
  • MULTI_CPU — Distribuido en varios nodos de CPU.
  • MULTI_GPU — Distribuido en varias GPU.
  • MULTI_MLU — Distribuido en varias MLU.
  • MULTI_SDAA — Distribuido en múltiples SDAAs.
  • MULTI_MUSA — Distribuido en múltiples MUSAs.
  • MULTI_NPU — Distribuido en múltiples NPU.
  • MULTI_XPU — Distribuido en varios XPUs.
  • MULTI_HPU — Distribuido en varios HPU.
  • MULTI_NEURON — Distribuido en varios núcleos Neuron.
  • DEEPSPEED — Uso de DeepSpeed.
  • FSDP — Uso de Fully Sharded Data Parallelism (FSDP).
  • XLA — Uso de TorchXLA.
  • MEGATRON_LM — Uso de Megatron-LM.

clase accelerate.utils.DynamoBackend

< >

( *values )

Representa un backend de dynamo (consulte https://pytorch.org/docs/stable/torch.compiler.html).

Valores:

  • NO — No utilices torch dynamo.
  • EAGER — Utiliza PyTorch para ejecutar el GraphModule extraído. Esto resulta bastante útil para depurar problemas de TorchDynamo.
  • AOT_EAGER — Utiliza AotAutograd sin compilador, es decir, solo usa PyTorch eager para los grafos de forward y backward extraídos por AotAutograd. Esto es útil para depurar y es poco probable que ofrezca mejoras de velocidad.
  • INDUCTOR — Utiliza el backend TorchInductor con AotAutograd y cudagraphs aprovechando los kernels de Triton generados por código. Leer más
  • AOT_TS_NVFUSER — nvFuser con AotAutograd/TorchScript. Más información
  • NVPRIMS_NVFUSER — nvFuser con PrimTorch. Más información
  • CUDAGRAPHS — cudagraphs con AotAutograd. Leer más
  • OFI — Utiliza Torchscript optimize_for_inference. Solo para inferencia. Más información
  • FX2TRT — Utiliza Nvidia TensorRT para optimizaciones de inferencia. Solo inferencia. Leer más
  • ONNXRT — Utiliza ONNXRT para la inferencia en CPU/GPU. Solo inferencia. Leer más
  • TENSORRT — Utiliza ONNXRT para ejecutar TensorRT con fines de optimización de inferencia. Más información
  • AOT_TORCHXLA_TRACE_ONCE — Utiliza Pytorch/XLA con la optimización de TorchDynamo, para el entrenamiento. Más información
  • TORCHXLA_TRACE_ONCE — Utiliza Pytorch/XLA con la optimización de TorchDynamo, para inferencia. Más información
  • TVM — Utiliza Apache TVM para optimizaciones de inferencia. Leer más
  • HPU_BACKEND — Utiliza el backend HPU para optimizaciones de inferencia.
  • NEURON — Utiliza el backend AWS Neuron para Trainium/Inferentia.

clase accelerate.utils.LoggerType

< >

( *values )

Representa un tipo de rastreador de experimentos admitido

Valores:

  • TODOS — todos los trackers disponibles en el entorno que son compatibles
  • TENSORBOARD — TensorBoard como rastreador de experimentos
  • WANDB — wandb como rastreador de experimentos
  • TRACKIO — trackio como registrador de experimentos
  • COMETML — comet_ml como rastreador de experimentos
  • MLFLOW — mlflow como rastreador de experimentos
  • CLEARML — clearml como registrador de experimentos
  • DVCLIVE — dvclive como rastreador de experimentos
  • SWANLAB — swanlab como rastreador de experimentos

clase accelerate.utils.PrecisionType

< >

( *values )

Representa un tipo de precisión utilizado en valores de punto flotante

Valores:

  • NO — usando precisión completa (FP32)
  • FP16 — usando media precisión
  • BF16 — usando precisión de coma flotante cerebral

clase accelerate.utils.RNGType

< >

( *values )

clase accelerate.utils.SageMakerDistributedType

< >

( *values )

Representa un tipo de entorno distribuido.

Valores:

  • NO — No es un entorno distribuido, solo un proceso único.
  • DATA_PARALLEL — usando la paralelización distribuida de datos de sagemaker.
  • MODEL_PARALLEL — uso de la paralelización distribuida de modelos de sagemaker.

Kwargs

Estos son argumentos configurables para interacciones específicas en todo el ecosistema de PyTorch que Accelerate gestiona internamente.

clase accelerate.AutocastKwargs

< >

( enabled: bool = Truecache_enabled: bool | None = None )

Use este objeto en su Accelerator para personalizar el comportamiento de torch.autocast. Consulte la documentación de este context manager para obtener más información sobre cada argumento.

Ejemplo:

from accelerate import Accelerator
from accelerate.utils import AutocastKwargs

kwargs = AutocastKwargs(cache_enabled=True)
accelerator = Accelerator(kwargs_handlers=[kwargs])

clase accelerate.DistributedDataParallelKwargs

< >

( dim: int = 0broadcast_buffers: bool = Truebucket_cap_mb: int = 25find_unused_parameters: bool = Falsecheck_reduction: bool = Falsegradient_as_bucket_view: bool = Falsestatic_graph: bool = Falsecomm_hook: DDPCommunicationHookType = <DDPCommunicationHookType.NO: 'no'>comm_wrapper: typing.Literal[<DDPCommunicationHookType.NO: 'no'>, <DDPCommunicationHookType.FP16: 'fp16'>, <DDPCommunicationHookType.BF16: 'bf16'>] = <DDPCommunicationHookType.NO: 'no'>comm_state_option: dict = <factory> )

Use este objeto en su Accelerator para personalizar cómo se envuelve su modelo en un torch.nn.parallel.DistributedDataParallel. Consulte la documentación de este wrapper para obtener más información sobre cada argumento.

Ejemplo:

from accelerate import Accelerator
from accelerate.utils import DistributedDataParallelKwargs

kwargs = DistributedDataParallelKwargs(find_unused_parameters=True)
accelerator = Accelerator(kwargs_handlers=[kwargs])

clase accelerate.GradScalerKwargs

< >

( init_scale: float = 65536.0growth_factor: float = 2.0backoff_factor: float = 0.5growth_interval: int = 2000enabled: bool = True )

Use este objeto en su Accelerator para personalizar el comportamiento de la precisión mixta, específicamente cómo se crea el torch.amp.GradScaler o torch.cuda.amp.GradScaler que se utiliza. Consulte la documentación de este scaler para obtener más información sobre cada argumento.

Ejemplo:

from accelerate import Accelerator
from accelerate.utils import GradScalerKwargs

kwargs = GradScalerKwargs(backoff_factor=0.25)
accelerator = Accelerator(kwargs_handlers=[kwargs])

clase accelerate.InitProcessGroupKwargs

< >

( backend: str | None = 'nccl'init_method: str | None = Nonetimeout: datetime.timedelta | None = None )

Use este objeto en su Accelerator para personalizar la inicialización de los procesos distribuidos. Consulte la documentación de este método para obtener más información sobre cada argumento.

Nota: Si timeout se establece en None, el valor predeterminado se basará en cómo se configure backend.

from datetime import timedelta
from accelerate import Accelerator
from accelerate.utils import InitProcessGroupKwargs

kwargs = InitProcessGroupKwargs(timeout=timedelta(seconds=800))
accelerator = Accelerator(kwargs_handlers=[kwargs])

clase accelerate.utils.KwargsHandler

< >

( )

Mixin interno que implementa un método to_kwargs() para un dataclass.

to_kwargs

< >

( )

Devuelve un diccionario que contiene los atributos con valores diferentes de los valores predeterminados de esta clase.

Plugins

Estos son complementos que pueden pasarse al objeto Accelerator. Aunque se definen en otras partes de la documentación, por comodidad, todos están disponibles para verlos aquí:

clase accelerate.DeepSpeedPlugin

< >

( hf_ds_config: Any = Nonegradient_accumulation_steps: int = Nonegradient_clipping: float = Nonezero_stage: int = Noneis_train_batch_min: bool = Trueoffload_optimizer_device: str = Noneoffload_param_device: str = Noneoffload_optimizer_nvme_path: str = Noneoffload_param_nvme_path: str = Nonezero3_init_flag: bool = Nonezero3_save_16bit_model: bool = Nonetransformer_moe_cls_names: str = None )

Parámetros

  • hf_ds_config (Any, por defecto None) — Ruta al archivo de configuración de DeepSpeed o un diccionario o un objeto de la clase accelerate.utils.deepspeed.HfDeepSpeedConfig.
  • gradient_accumulation_steps (int, por defecto None) — Número de pasos para acumular gradientes antes de actualizar los estados del optimizador. Si no se establece, se usará el valor de Accelerator directamente.
  • gradient_clipping (float, por defecto None) — Activa el recorte de gradientes con el valor indicado.
  • zero_stage (int, por defecto None) — Las opciones posibles son 0, 1, 2, 3. El valor por defecto se tomará de la variable de entorno.
  • is_train_batch_min (bool, por defecto True) — Si se especifican tanto los dataloaders de entrenamiento como de evaluación, este parámetro determinará el train_batch_size.
  • offload_optimizer_device (str, por defecto None) — Las opciones posibles son none|cpu|nvme. Solo es aplicable con ZeRO Stages 2 y 3.
  • offload_param_device (str, por defecto None) — Las opciones posibles son none|cpu|nvme. Solo es aplicable con ZeRO Stage 3.
  • offload_optimizer_nvme_path (str, por defecto None) — Las opciones posibles son /nvme|/local_nvme. Solo es aplicable con ZeRO Stage 3.
  • offload_param_nvme_path (str, por defecto None) — Las opciones posibles son /nvme|/local_nvme. Solo es aplicable con ZeRO Stage 3.
  • zero3_init_flag (bool, por defecto None) — Indica si se debe guardar el modelo de 16 bits. Solo es aplicable con ZeRO Stage-3.
  • zero3_save_16bit_model (bool, por defecto None) — Indica si se debe guardar el modelo de 16 bits. Solo es aplicable con ZeRO Stage-3.
  • transformer_moe_cls_names (str, por defecto None) — Lista separada por comas de nombres de clases de capas MoE de Transformers (distingue entre mayúsculas y minúsculas). Por ejemplo, MixtralSparseMoeBlock, Qwen2MoeSparseMoeBlock, JetMoEAttention, JetMoEBlock, etc.

Este plugin se utiliza para integrar DeepSpeed.

deepspeed_config_process

< >

( prefix = ''mismatches = Noneconfig = Nonemust_match = True**kwargs )

Procesa la configuración de DeepSpeed con los valores de kwargs.

select

< >

( _from_accelerator_state: bool = False )

Establece el HfDeepSpeedWeakref para que utilice la configuración actual del plugin de deepspeed

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.

clase accelerate.utils.GradientAccumulationPlugin

< >

( num_steps: int = Noneadjust_scheduler: bool = Truesync_with_dataloader: bool = Truesync_each_batch: bool = False )

Parámetros

  • num_steps (int) — El número de pasos para acumular gradientes.
  • adjust_scheduler (bool, opcional, valor predeterminado True) — Si se deben ajustar los pasos del programador para tener en cuenta el número de pasos acumulados. Debe ser True si el programador utilizado no se ajustó para la acumulación de gradientes.
  • sync_with_dataloader (bool, opcional, valor predeterminado True) — Si se debe sincronizar la configuración de los gradientos al llegar al final del dataloader.
  • sync_each_batch (bool, opcional) — Si se sincroniza la configuración de los gradientes en cada lote de datos. Establecerlo en True puede reducir los requisitos de memoria al usar acumulación de gradientes con entrenamiento distribuido, a costa de la velocidad.

Un plugin para configurar el comportamiento de la acumulación de gradientes. Solo puede pasar uno de gradient_accumulation_plugin o gradient_accumulation_steps a Accelerator. Pasar ambos provoca un error.

Ejemplo:

from accelerate.utils import GradientAccumulationPlugin

gradient_accumulation_plugin = GradientAccumulationPlugin(num_steps=2)
accelerator = Accelerator(gradient_accumulation_plugin=gradient_accumulation_plugin)

clase accelerate.utils.MegatronLMPlugin

< >

( tp_degree: int = Nonepp_degree: int = Noneuse_custom_fsdp: bool = Noneoverlap_cpu_optimizer_d2h_h2d: bool = Noneno_load_optim: bool = Noneeod_mask_loss: bool = Noneno_save_optim: bool = Noneoptimizer_cpu_offload: bool = Noneuse_precision_aware_optimizer: bool = Nonedecoder_last_pipeline_num_layers: int = Nonerecompute_granularity: str = Nonerecompute_method: str = Nonerecompute_num_layers: int = Noneattention_backend: bool = Noneexpert_model_parallel_size: int = Nonecontext_parallel_size: int = Noneattention_dropout: float = Nonehidden_dropout: float = Noneattention_softmax_in_fp32: bool = Noneexpert_tensor_parallel_size: int = Nonecalculate_per_token_loss: bool = Noneuse_rotary_position_embeddings: bool = Nonenum_micro_batches: int = Nonegradient_clipping: float = Nonesequence_parallelism: bool = Nonerecompute_activations: bool = Noneuse_distributed_optimizer: bool = Nonepipeline_model_parallel_split_rank: int = Nonenum_layers_per_virtual_pipeline_stage: int = Noneis_train_batch_min: str = Truetrain_iters: int = Nonetrain_samples: int = Noneweight_decay_incr_style: str = 'constant'start_weight_decay: float = Noneend_weight_decay: float = Nonelr_decay_style: str = 'linear'lr_decay_iters: int = Nonelr_decay_samples: int = Nonelr_warmup_iters: int = Nonelr_warmup_samples: int = Nonelr_warmup_fraction: float = Nonemin_lr: float = 0consumed_samples: list = Noneno_wd_decay_cond: typing.Callable | None = Nonescale_lr_cond: typing.Callable | None = Nonelr_mult: float = 1.0megatron_dataset_flag: bool = Falseseq_length: int = Noneencoder_seq_length: int = Nonedecoder_seq_length: int = Nonetensorboard_dir: str = Noneset_all_logging_options: bool = Falseeval_iters: int = 100eval_interval: int = 1000return_logits: bool = Falsecustom_train_step_class: typing.Any | None = Nonecustom_train_step_kwargs: dict[str, typing.Any] | None = Nonecustom_model_provider_function: typing.Callable | None = Nonecustom_prepare_model_function: typing.Callable | None = Nonecustom_megatron_datasets_provider_function: typing.Callable | None = Nonecustom_get_batch_function: typing.Callable | None = Nonecustom_loss_function: typing.Callable | None = Noneother_megatron_args: dict[str, typing.Any] | None = None )

Parámetros

  • tp_degree (int, por defecto None) — Grado de paralelismo de tensores.
  • pp_degree (int, por defecto None) — Grado de paralelismo de pipeline.
  • num_micro_batches (int, por defecto None) — Número de micro-lotes.
  • gradient_clipping (float, por defecto None) — Valor de recorte de gradientes basado en la norma L2 global (0 para desactivarlo).
  • sequence_parallelism (bool, por defecto None) — Habilita el paralelismo de secuencia.
  • recompute_activations (bool, por defecto None) — Activa la recomputación selectiva de activaciones.
  • use_distributed_optimizer (bool, por defecto None) — Habilita el optimizador distribuido.
  • pipeline_model_parallel_split_rank (int, por defecto None) — Rango donde se deben dividir el codificador y el decodificador.
  • num_layers_per_virtual_pipeline_stage (int, por defecto None) — Número de capas por etapa de pipeline virtual.
  • is_train_batch_min (str, por defecto True) — Si se especifican tanto los dataloaders de entrenamiento como de evaluación, este parámetro determinará el micro_batch_size.
  • train_iters (int, por defecto None) — Número total de muestras para entrenar en todas las ejecuciones de entrenamiento. Tenga en cuenta que debe proporcionar train-iters o train-samples al usar MegatronLMDummyScheduler.
  • train_samples (int, por defecto None) — Número total de muestras para entrenar en todas las ejecuciones de entrenamiento. Tenga en cuenta que debe proporcionar train-iters o train-samples al usar MegatronLMDummyScheduler.
  • weight_decay_incr_style (str, por defecto 'constant') — Función de incremento del decaimiento de peso. choices=[“constant”, “linear”, “cosine”].
  • start_weight_decay (float, por defecto None) — Coeficiente inicial de decaimiento de pesos para la regularización L2.
  • end_weight_decay (float, por defecto None) — Coeficiente de decaimiento de peso al final de la ejecución para la regularización L2.
  • lr_decay_style (str, por defecto 'linear') — Función de decaimiento de la tasa de aprendizaje. choices=[‘constant’, ‘linear’, ‘cosine’].
  • lr_decay_iters (int, por defecto None) — Número de iteraciones para el decaimiento de la tasa de aprendizaje. Si es None, por defecto toma el valor de train_iters.
  • lr_decay_samples (int, por defecto None) — Número de muestras para el decaimiento de la tasa de aprendizaje. Si es None, por defecto toma el valor de train_samples.
  • lr_warmup_iters (int, por defecto None) — Número de iteraciones para calentar linealmente la tasa de aprendizaje.
  • lr_warmup_samples (int, por defecto None) — Número de muestras sobre las que calentar linealmente la tasa de aprendizaje.
  • lr_warmup_fraction (float, por defecto None) — Fracción de lr-warmup-(iteraciones/muestras) sobre la que calentar linealmente la tasa de aprendizaje.
  • min_lr (float, por defecto 0) — Valor mínimo para la tasa de aprendizaje. El programador recorta los valores por debajo de este umbral.
  • consumed_samples (List, por defecto None) — Número de muestras consumidas en el mismo orden que los dataloaders de la llamada a accelerator.prepare.
  • no_wd_decay_cond (Optional, por defecto None) — Condición para desactivar el decaimiento de pesos.
  • scale_lr_cond (Optional, por defecto None) — Condición para escalar la tasa de aprendizaje.
  • lr_mult (float, por defecto 1.0) — Multiplicador de la tasa de aprendizaje.
  • megatron_dataset_flag (bool, por defecto False) — Si el formato del conjunto de datos sigue el formato Indexed/Cached/MemoryMapped de Megatron-LM.
  • seq_length (int, por defecto None) — Longitud máxima de secuencia a procesar.
  • encoder_seq_length (int, por defecto None) — Longitud máxima de secuencia a procesar para el codificador.
  • decoder_seq_length (int, por defecto None) — Longitud máxima de secuencia a procesar para el decodificador.
  • tensorboard_dir (str, por defecto None) — Ruta para guardar los registros de tensorboard.
  • set_all_logging_options (bool, por defecto False) — Si se deben establecer todas las opciones de registro.
  • eval_iters (int, por defecto 100) — Número de iteraciones para ejecutar la validación/prueba de evaluación.
  • eval_interval (int, por defecto 1000) — Intervalo entre la ejecución de la evaluación en el conjunto de validación.
  • return_logits (bool, por defecto False) — Si se deben devolver los logits del modelo.
  • custom_train_step_class (Optional, por defecto None) — Clase de paso de entrenamiento personalizada.
  • custom_train_step_kwargs (Optional, por defecto None) — Argumentos personalizados para el paso de entrenamiento.
  • custom_model_provider_function (Optional, por defecto None) — Función de proveedor de modelo personalizada.
  • custom_prepare_model_function (Optional, por defecto None) — Función personalizada para preparar el modelo.
  • custom_megatron_datasets_provider_function (Optional, por defecto None) — Función de proveedor de conjuntos de datos de entrenamiento, validación y prueba de megatron personalizada.
  • custom_get_batch_function (Optional, por defecto None) — Función personalizada para obtener el lote.
  • custom_loss_function (Optional, por defecto None) — Función de pérdida personalizada.
  • other_megatron_args (Optional, por defecto None) — Otros argumentos de Megatron-LM. Consulte Megatron-LM.

Plugin para Megatron-LM que habilita el paralelismo de tensor, pipeline, secuencia y datos. También habilita la recomputación selectiva de activaciones y kernels fusionados optimizados.

clase accelerate.utils.TorchDynamoPlugin

< >

( backend: DynamoBackend = Nonemode: str = Nonefullgraph: bool = Nonedynamic: bool = Noneoptions: Any = Nonedisable: bool = Falseuse_regional_compilation: bool = None )

Parámetros

  • backend (DynamoBackend, por defecto None) — Un backend de Dynamo válido. Consulte https://pytorch.org/docs/stable/torch.compiler.html para más detalles.
  • mode (str, por defecto None) — Las opciones posibles son ‘default’, ‘reduce-overhead’ o ‘max-autotune’.
  • fullgraph (bool, por defecto None) — Si se permite dividir el modelo en varios subgrafos.
  • dynamic (bool, por defecto None) — Si se debe usar una forma dinámica para el trazado.
  • options (Any, por defecto None) — Un diccionario de opciones para pasar al backend.
  • disable (bool, por defecto False) — Convierte torch.compile() en una operación sin efecto para pruebas
  • use_regional_compilation (bool, por defecto None) — Úsela para reducir el tiempo de compilación en frío de torch.compile() al apuntar a bloques repetidos de la misma clase y compilarlos de forma secuencial para aprovechar la caché del compilador. Por ejemplo, en GPT2LMHeadModel, el bloque/clase repetido es GPT2Block, y se puede acceder a él como model.transformer.h[0]. El resto del modelo (p. ej. model.lm_head) se compila por separado.

Este plugin se utiliza para compilar un modelo con PyTorch 2.0

Configuraciones

Estas son clases que se pueden configurar y pasar a la integración correspondiente

clase accelerate.utils.BnbQuantizationConfig

< >

( load_in_8bit: bool = Falsellm_int8_threshold: float = 6.0load_in_4bit: bool = Falsebnb_4bit_quant_type: str = 'fp4'bnb_4bit_use_double_quant: bool = Falsebnb_4bit_compute_dtype: str = 'fp16'torch_dtype: dtype = Noneskip_modules: list = Nonekeep_in_fp32_modules: list = None )

Parámetros

  • load_in_8bit (bool, por defecto False) — Habilita la cuantización de 8 bits.
  • llm_int8_threshold (float, por defecto 6.0) — Valor del umbral del outliner. Solo es relevante cuando load_in_8bit=True.
  • load_in_4bit (bool, por defecto False) — Habilita la cuantización de 4 bits.
  • bnb_4bit_quant_type (str, por defecto fp4) — Establece el tipo de datos de cuantización en las capas bnb.nn.Linear4Bit. Las opciones son {‘fp4’,‘np4’}.
  • bnb_4bit_use_double_quant (bool, por defecto False) — Activa la cuantización anidada, donde las constantes de cuantización de la primera cuantización se cuantizan de nuevo.
  • bnb_4bit_compute_dtype (bool, por defecto fp16) — Esto establece el tipo de cálculo, que puede ser diferente al tipo de entrada. Por ejemplo, las entradas pueden ser fp32, pero el cálculo puede configurarse en bf16 para obtener mejoras de velocidad. Las opciones son {‘fp32’,‘fp16’,‘bf16’}.
  • torch_dtype (torch.dtype, por defecto None) — Esto establece el dtype de las capas restantes no cuantizadas. La biblioteca bitsandbytes sugiere establecer el valor en torch.float16 para modelos de 8 bits y usar el mismo dtype que el dtype de cálculo para modelos de 4 bits.
  • skip_modules (List[str], por defecto None) — Una lista explícita de los módulos que no se cuantizan. El dtype de estos módulos será torch_dtype.
  • keep_in_fp32_modules (List, por defecto None) — Una lista explícita de los módulos que no cuantizamos. Los mantenemos en torch.float32.

Un plugin para habilitar la cuantización de 4 bits y 8 bits de BitsAndBytes

clase accelerate.DataLoaderConfiguration

< >

( split_batches: bool = Falsedispatch_batches: bool = Noneeven_batches: bool = Trueuse_seedable_sampler: bool = Falsedata_seed: int = Nonenon_blocking: bool = Falseuse_stateful_dataloader: bool = False )

Parámetros

  • split_batches (bool, por defecto False) — Indica si el acelerador debe dividir los lotes generados por los dataloaders entre los dispositivos. Si es True, el tamaño de lote real utilizado será el mismo en cualquier tipo de proceso distribuido, pero debe ser un múltiplo exacto de num_processes que estés utilizando. Si es False, el tamaño de lote real utilizado será el establecido en tu script multiplicado por el número de procesos.
  • dispatch_batches (bool, por defecto None) — Si se establece en True, el dataloader preparado por el Accelerator solo se itera en el proceso principal y luego los lotes se dividen y se difunden a cada proceso. Por defecto será True para un DataLoader cuyo conjunto de datos subyacente sea un IterableDataset, False en caso contrario.
  • even_batches (bool, por defecto True) — Si se establece en True, en los casos en que el tamaño total del lote en todos los procesos no divide exactamente al conjunto de datos, se duplicarán las muestras del inicio del conjunto de datos para que el lote pueda dividirse equitativamente entre todos los trabajadores.
  • use_seedable_sampler (bool, por defecto False) — Indica si se debe utilizar un muestreador aleatorio totalmente sembrable (data_loader.SeedableRandomSampler). Garantiza que los resultados del entrenamiento sean totalmente reproducibles mediante una técnica de muestreo diferente. Si bien los resultados de una semilla a otra pueden variar, en promedio las diferencias son despreciables al utilizar varias semillas diferentes para comparar. También debe ejecutarse junto con set_seed() para obtener los mejores resultados.
  • data_seed (int, por defecto None) — La semilla que se utilizará para el generador subyacente al usar use_seedable_sampler. Si es None, el generador utilizará la semilla predeterminada actual de torch.
  • non_blocking (bool, por defecto False) — Si se establece en True, el dataloader preparado por el Accelerator utilizará transferencias no bloqueantes de host a dispositivo, lo que permite una mejor superposición entre la comunicación del dataloader y la computación. Se recomienda que el dataloader preparado tenga pin_memory establecido en True para que funcione correctamente.
  • use_stateful_dataloader (bool, por defecto False) — Si se establece en True, el dataloader preparado por el Accelerator estará respaldado por torchdata.StatefulDataLoader. Esto requiere que esté instalada la versión 0.8.0 o superior de torchdata que admita StatefulDataLoader.

Configuración para los elementos relacionados con el dataloader al llamar a accelerator.prepare.

clase accelerate.utils.ProjectConfiguration

< >

( project_dir: str = Nonelogging_dir: str = Noneautomatic_checkpoint_naming: bool = Falsetotal_limit: int = Noneiteration: int = 0save_on_each_node: bool = False )

Parámetros

  • project_dir (str, por defecto None) — Una ruta a un directorio para almacenar datos.
  • logging_dir (str, por defecto None) — Una ruta a un directorio para almacenar registros de registradores compatibles localmente. Si es None, por defecto es project_dir.
  • automatic_checkpoint_naming (bool, por defecto False) — Si los estados guardados deben nombrarse automáticamente de forma iterativa.
  • total_limit (int, por defecto None) — El número máximo de estados guardados totales que se deben conservar.
  • iteration (int, por defecto 0) — La iteración de guardado actual.
  • save_on_each_node (bool, por defecto False) — En el entrenamiento distribuido multinodo, si se guardan los modelos y puntos de control en cada nodo o solo en el principal.

Configuración del objeto Accelerator según las necesidades internas del proyecto.

set_directories

< >

( project_dir: str | None = None )

Establece self.project_dir y self.logging_dir en los valores apropiados.

Variables de entorno

Estas son variables de entorno que se pueden habilitar para diferentes casos de uso

  • ACCELERATE_DEBUG_MODE (str): Si se ejecuta accelerate en modo de depuración. Más información disponible aquí.

Manipulación de datos y operaciones

Estas incluyen operaciones de datos que imitan las mismas operaciones de torch pero que pueden usarse en procesos distribuidos.

accelerate.utils.broadcast

< >

( tensorfrom_process: int = 0 )

Parámetros

  • tensor (lista/tupla/diccionario anidado de torch.Tensor) — Los datos que se deben recopilar.
  • from_process (int, opcional, valor predeterminado 0) — El proceso desde el que se envían los datos

Difunde recursivamente el tensor en una lista/tupla/diccionario anidado de tensors a todos los dispositivos.

accelerate.utils.broadcast_object_list

< >

( object_listfrom_process: int = 0 )

Parámetros

  • object_list (lista de objetos picklable) — La lista de objetos que se van a difundir. Esta lista se modificará in situ.
  • from_process (int, opcional, valor predeterminado 0) — El proceso desde el que se envían los datos.

Difunda una lista de objetos serializables desde un proceso a los demás.

accelerate.utils.concatenate

< >

( datadim = 0 )

Parámetros

  • data (lista/tupla/diccionario anidado de listas de tensores torch.Tensor) — Los datos a concatenar.
  • dim (int, opcional, valor predeterminado 0) — La dimensión sobre la que concatenar.

Concatena recursivamente los tensores en una lista/tupla/diccionario anidado de listas de tensores con la misma forma. Si solo hay un solo lote de datos, se devuelve tal cual.

accelerate.utils.convert_outputs_to_fp32

< >

( model_forward )

accelerate.utils.convert_to_fp32

< >

( tensor )

Parámetros

  • tensor (lista/tupla/diccionario anidado de torch.Tensor) — Los datos que se van a convertir de FP16/BF16 a FP32.

Convierte recursivamente los elementos de listas/tuplas/diccionarios anidados de tensores en precisión FP16/BF16 a FP32.

accelerate.utils.gather

< >

( tensor )

Parámetros

  • tensor (lista/tupla/diccionario anidado de torch.Tensor) — Los datos que se deben recopilar.

Recolectar recursivamente un tensor en una lista/tupla/diccionario anidado de tensors desde todos los dispositivos.

accelerate.utils.gather_object

< >

( object: Any )

Parámetros

  • object (lista/tupla/diccionario anidado de objetos serializables) — Los datos que se deben recopilar.

Recolectar recursivamente un objeto en una lista/tupla/diccionario anidado de objetos desde todos los dispositivos.

accelerate.utils.get_grad_scaler

< >

( distributed_type: DistributedType = None**kwargs )

Parámetros

  • distributed_type (DistributedType, opcional, valor predeterminado None) — El tipo de entorno distribuido.
  • kwargs — Argumentos adicionales para el constructor de GradScaler utilizado.

Un helper genérico que inicializará la implementación correcta de GradScaler en función del entorno y la devolverá.

accelerate.utils.get_mixed_precision_context_manager

< >

( native_amp: bool = Falseautocast_kwargs: AutocastKwargs = None )

Parámetros

  • native_amp (bool, opcional, predeterminado en False) — Si la precisión mixta está realmente habilitada.

Devuelve un gestor de contexto para el autocast de precisión mixta

accelerate.utils.listify

< >

( data )

Parámetros

  • data (lista/tupla/diccionario anidado de torch.Tensor) — Los datos de los que se debe convertir a números regulares.

Encuentra recursivamente tensores en una lista/tupla/diccionario anidado y los convierte en una lista de números.

accelerate.utils.pad_across_processes

< >

( tensordim = 0pad_index = 0pad_first = False )

Parámetros

  • tensor (lista/tupla/diccionario anidado de torch.Tensor) — Los datos que se deben recopilar.
  • dim (int, opcional, valor predeterminado 0) — La dimensión sobre la que se debe rellenar.
  • pad_index (int, opcional, valor predeterminado 0) — El valor con el que se rellena.
  • pad_first (bool, opcional, valor predeterminado False) — Si se debe rellenar al principio o al final.

Rellena recursivamente los tensores en una lista/tupla/diccionario anidado de tensores de todos los dispositivos hasta el mismo tamaño para que puedan recopilarse de forma segura.

accelerate.utils.recursively_apply

< >

( funcdata*argstest_type = <function is_torch_tensor at 0x7fe7449bfed0>error_on_other_type = False**kwargs )

Parámetros

  • func (callable) — La función que se aplicará de forma recursiva.
  • data (lista/tupla/diccionario anidado de objetos aceptados por test_type) — Los datos sobre los que aplicar func
  • *args — Argumentos posicionales que se pasarán a func cuando se aplique sobre los datos desempaquetados.
  • test_type (Callable[[Any], bool], opcional, valor predeterminado is_torch_tensor) — El predicado que decide si func debe aplicarse a un objeto hoja dado.
  • error_on_other_type (bool, opcional, valor predeterminado False) — Indica si se debe devolver un error o no si, después de desempaquetar data, se obtiene un objeto para el cual test_type devuelve False. Si es False, la función dejará dichos objetos sin cambios.
  • **kwargs (argumentos de palabra clave adicionales, opcional) — Argumentos de palabra clave que se pasarán a func cuando se aplique a los datos desempaquetados.

Aplicar recursivamente una función sobre una estructura de datos que es una lista/tupla/diccionario anidado de un tipo base dado.

accelerate.utils.reduce

< >

( tensorreduction = 'mean'scale = 1.0 )

Parámetros

  • tensor (lista/tupla/diccionario anidado de torch.Tensor) — Los datos a reducir.
  • reduction (str, opcional, por defecto "mean") — Un método de reducción. Puede ser “mean”, “sum”, “max” o “none”
  • scale (float, opcional) — Un valor de escala predeterminado que se aplica después de la reducción, válido solo en XLA.

Reducir recursivamente los tensores en una lista/tupla/diccionario anidado de listas de tensores en todos los procesos mediante la media de una operación dada.

accelerate.utils.send_to_device

< >

( tensordevicenon_blocking = Falseskip_keys = None )

Parámetros

  • tensor (lista/tupla/diccionario anidado de torch.Tensor) — Los datos que se enviarán a un dispositivo determinado.
  • device (torch.device) — El dispositivo al que se enviarán los datos.
  • non_blocking (bool, opcional, valor predeterminado False) — Si es True, la transferencia al dispositivo se realiza de forma asíncrona, lo que permite superponer el movimiento de datos con el cálculo. Solo es efectivo cuando el dispositivo lo admite (p. ej., CUDA).
  • skip_keys (str o List[str], opcional) — Una clave o lista de claves en un diccionario tensor cuyos valores no deben enviarse al device indicado. Las entradas con estas claves se mantienen en su dispositivo original.

Envía recursivamente los elementos de una lista/tupla/diccionario anidado de tensores a un dispositivo dado.

accelerate.utils.slice_tensors

< >

( datatensor_sliceprocess_index = Nonenum_processes = None )

Parámetros

  • data (lista/tupla/diccionario anidado de torch.Tensor) — Los datos a segmentar.
  • tensor_slice (slice) — La porción a tomar.

Toma recursivamente una porción de una lista/tupla/diccionario anidado de tensores.

Comprobaciones del entorno

Estas funcionalidades verifican el estado del entorno de trabajo actual, incluida información sobre el propio sistema operativo, lo que puede admitir y si se han instalado dependencias específicas.

accelerate.utils.is_bf16_available

< >

( ignore_tpu = False )

Comprueba si bf16 es compatible, ignorando opcionalmente el TPU

accelerate.utils.is_mps_available

< >

( min_version = '1.12' )

Comprueba si el dispositivo MPS está disponible. La versión mínima requerida es 1.12.

accelerate.utils.is_npu_available

( check_device = False )

Comprueba si torch_npu está instalado y, en su caso, si hay una NPU en el entorno

accelerate.utils.is_torch_version

< >

( operation: strversion: str )

Parámetros

  • operation (str) — Una representación en cadena de un operador, como ">" o "<="
  • version (str) — Una versión de PyTorch en formato de cadena

Compara la versión actual de PyTorch con una referencia dada mediante una operación.

accelerate.utils.is_torch_xla_available

( check_is_tpu = Falsecheck_is_gpu = False )

Comprueba si torch_xla está disponible. Para entrenar un trabajo nativo de pytorch en un entorno con torch xla instalado, establece USE_TORCH_XLA en false.

accelerate.utils.is_xpu_available

( check_device = False )

Comprueba si la aceleración XPU está disponible a través de PyTorch estándar (>=2.7) y, potencialmente, si hay una XPU en el entorno

Manipulación del entorno

accelerate.utils.patch_environment

< >

( **kwargs )

Un gestor de contexto que añadirá cada argumento de palabra clave pasado a os.environ y los eliminará al salir.

Convertirá los valores en kwargs a cadenas de texto y pondrá todas las claves en mayúsculas.

Ejemplo:

>>> import os
>>> from accelerate.utils import patch_environment

>>> with patch_environment(FOO="bar"):
...     print(os.environ["FOO"])  # prints "bar"
>>> print(os.environ["FOO"])  # raises KeyError

accelerate.utils.clear_environment

< >

( )

Un administrador de contexto que limpiará temporalmente las variables de entorno.

Cuando este contexto termina, las variables de entorno anteriores se restaurarán.

Ejemplo:

>>> import os
>>> from accelerate.utils import clear_environment

>>> os.environ["FOO"] = "bar"
>>> with clear_environment():
...     print(os.environ)
...     os.environ["FOO"] = "new_bar"
...     print(os.environ["FOO"])
{}
new_bar

>>> print(os.environ["FOO"])
bar

accelerate.commands.config.default.write_basic_config

< >

( mixed_precision = 'no'save_location: str = '/home/runner/.cache/huggingface/accelerate/default_config.yaml' )

Parámetros

  • mixed_precision (str, opcional, valor predeterminado “no”) — Mixed Precision a utilizar. Debe ser uno de “no”, “fp16” o “bf16”
  • save_location (str, opcional, por defecto default_json_config_file) — Ubicación de guardado personalizada opcional. Debe pasarse a --config_file al usar accelerate launch. La ubicación por defecto está dentro de la carpeta de caché de huggingface (~/.cache/huggingface), pero se puede sobrescribir estableciendo la variable de entorno HF_HOME, seguida de accelerate/default_config.yaml.

Crea y guarda una configuración básica de clúster para usarla en una máquina local con varias GPU. También configurará la CPU si se trata de una máquina solo de CPU.

Al configurar 🤗 Accelerate por primera vez, en lugar de ejecutar accelerate config [~utils.write_basic_config] puede usarse como alternativa para una configuración rápida.

accelerate.utils.set_numa_affinity

( local_process_index: intverbose: bool | None = None )

Parámetros

  • local_process_index (int) — El índice del proceso actual en el servidor actual.
  • verbose (bool, opcional) — Si se debe imprimir la nueva asignación de núcleos de cpu para cada proceso. Si ACCELERATE_DEBUG_MODE está habilitado, el valor predeterminado será True.

Asigna el proceso actual a un nodo NUMA específico. Es más eficiente idealmente cuando se tienen al menos 2 cpus por nodo.

Este resultado se almacena en caché entre llamadas. Si desea invalidarlo, use accelerate.utils.environment.override_numa_afifnity.

accelerate.utils.environment.override_numa_affinity

< >

( local_process_index: intverbose: bool | None = None )

Parámetros

  • local_process_index (int) — El índice del proceso actual en el servidor actual.
  • verbose (bool, opcional) — Si se debe registrar la asignación de cada CPU. Si ACCELERATE_DEBUG_MODE está habilitado, el valor predeterminado será True.

Anula la afinidad NUMA establecida para el proceso actual. Esto es muy costoso y requiere recalcular la afinidad a establecer; idealmente, debería usar utils.environment.set_numa_affinity en su lugar.

accelerate.utils.purge_accelerate_environment

< >

( func_or_cls )

Decorador para limpiar las variables de entorno de accelerate establecidas por la clase o función decorada.

En algunas circunstancias, la llamada a ciertas clases o funciones puede provocar que se establezcan variables de entorno de accelerate y no se limpien después. Por ejemplo, al llamar a:

TrainingArguments(fp16=True, …)

Se establecerá la siguiente variable de entorno:

ACCELERATE_MIXED_PRECISION=fp16

Esto puede afectar al código posterior, ya que la variable de entorno tiene prioridad sobre TrainingArguments(fp16=False). Esto es especialmente relevante para las pruebas unitarias, donde queremos evitar que las pruebas individuales tengan efectos secundarios entre sí. Decore la función de prueba unitaria o la clase completa con este decorador para asegurarse de que, después de cada prueba, las variables de entorno se limpien. Esto funciona tanto para unittest.TestCase como para clases normales (pytest); también funciona al decorar la clase padre.

Memoria

accelerate.find_executable_batch_size

< >

( function: callable | None = Nonestarting_batch_size: int = 128reduce_batch_size_fn: callable | None = None )

Parámetros

  • function (callable, optional) — Una función para envolver
  • starting_batch_size (int, opcional) — El tamaño de lote que se intentará ajustar en la memoria
  • reduce_batch_size_fn (callable, opcional) — Una función para determinar el nuevo tamaño de lote tras un error de memoria insuficiente. Si no se proporciona, el tamaño de lote se multiplica por 0,9 en cada fallo. La función no toma argumentos y debe devolver el nuevo tamaño de lote (reducido) como un int.

Un decorador básico que intentará ejecutar function. Si falla debido a excepciones relacionadas con la falta de memoria o con CUDNN, el tamaño del lote se multiplica por 0.9 y se pasa a function

function debe recibir un parámetro batch_size como su primer argumento.

Ejemplo:

>>> from accelerate.utils import find_executable_batch_size


>>> @find_executable_batch_size(starting_batch_size=128)
... def train(batch_size, model, optimizer):
...     ...


>>> train(model, optimizer)

Modelado

Estas utilidades se relacionan con la interacción con modelos de PyTorch

accelerate.utils.calculate_maximum_sizes

< >

( model: Module )

Calcula el tamaño total del modelo y su capa más grande

accelerate.utils.compute_module_sizes

< >

( model: Moduledtype: str | torch.device | None = Nonespecial_dtypes: dict[str, str | torch.device] | None = Nonebuffers_only: bool = False )

Calcule el tamaño de cada submódulo de un modelo dado.

accelerate.utils.extract_model_from_parallel

< >

( modelkeep_fp32_wrapper: bool = Truekeep_torch_compile: bool = Truerecursive: bool = False ) → torch.nn.Module

Parámetros

  • model (torch.nn.Module) — El modelo a extraer.
  • keep_fp32_wrapper (bool, opcional) — Si se deben eliminar los hooks de precisión mixta del modelo.
  • keep_torch_compile (bool, opcional) — Si se debe desenvolver el modelo compilado.
  • recursive (bool, opcional, valor predeterminado False) — Si se deben extraer recursivamente todos los casos de module.module de model, así como desenrollar recursivamente las subcapas hijas, no solo los contenedores distribuidos de nivel superior.

Devuelve

torch.nn.Module

El modelo extraído.

Extraer un modelo de sus contenedores distribuidos.

accelerate.utils.get_balanced_memory

< >

( model: Modulemax_memory: dict[int | str, int | str] | None = Noneno_split_module_classes: list[str] | None = Nonedtype: str | torch.dtype | None = Nonespecial_dtypes: dict[str, str | torch.device] | None = Nonelow_zero: bool = False )

Parámetros

  • model (torch.nn.Module) — El modelo a analizar.
  • max_memory (Dict, opcional) — Un diccionario de identificador de dispositivo a memoria máxima. Si no se establece, se usará la memoria máxima disponible. Ejemplo: max_memory={0: "1GB"}.
  • no_split_module_classes (List[str], opcional) — Una lista de nombres de clases de capas que nunca deben dividirse entre dispositivos (por ejemplo, cualquier capa que tenga una conexión residual).
  • dtype (str o torch.dtype, opcional) — Si se proporciona, los pesos se convertirán a ese tipo al cargarlos.
  • special_dtypes (Dict[str, Union[str, torch.device]], opcional) — Si se proporciona, dtypes especiales a considerar para algunos pesos específicos (anulará el dtype utilizado de forma predeterminada para todos los pesos).
  • low_zero (bool, opcional) — Minimiza el número de pesos en la GPU 0, lo cual es conveniente cuando se utiliza para otras operaciones (como la función generate de Transformers).

Calcule un diccionario max_memory para infer_auto_device_map() que equilibre el uso de cada GPU disponible.

Todos los cálculos se realizan analizando los tamaños y los dtypes de los parámetros del modelo. Como resultado, el modelo puede estar en el dispositivo meta (como lo estaría si se inicializara dentro del administrador de contexto init_empty_weights).

accelerate.utils.get_max_layer_size

< >

( modules: listmodule_sizes: dictno_split_module_classes: list ) → Tuple[int, List[str]]

Parámetros

  • modules (List[Tuple[str, torch.nn.Module]]) — La lista de módulos con nombre en los que queremos determinar el tamaño máximo de capa.
  • module_sizes (Dict[str, int]) — Un diccionario que asigna a cada nombre de capa su tamaño (tal como lo genera compute_module_sizes).
  • no_split_module_classes (List[str]) — Una lista de nombres de clases para capas que no queremos dividir.

Devuelve

Tuple[int, List[str]]

El tamaño máximo de una capa con la lista de nombres de capas que alcanzan ese tamaño máximo.

Función de utilidad que escaneará una lista de módulos nombrados y devolverá el tamaño máximo utilizado por una capa completa. La definición de una capa es:

  • un módulo sin hijos directos (solo parámetros y búferes)
  • un módulo cuyo nombre de clase está en la lista no_split_module_classes

accelerate.infer_auto_device_map

< >

( model: Modulemax_memory: dict[int | str, int | str] | None = Noneno_split_module_classes: list[str] | None = Nonedtype: str | torch.dtype | None = Nonespecial_dtypes: dict[str, str | torch.dtype] | None = Noneverbose: bool = Falseclean_result: bool = Trueoffload_buffers: bool = Falsefallback_allocation: bool = False )

Parámetros

  • model (torch.nn.Module) — El modelo a analizar.
  • max_memory (Dict, opcional) — Un diccionario de identificador de dispositivo a memoria máxima. Si no se establece, se usará la memoria máxima disponible. Ejemplo: max_memory={0: "1GB"}.
  • no_split_module_classes (List[str], opcional) — Una lista de nombres de clases de capas que nunca deben dividirse entre dispositivos (por ejemplo, cualquier capa que tenga una conexión residual).
  • dtype (str o torch.dtype, opcional) — Si se proporciona, los pesos se convertirán a ese tipo al cargarlos.
  • special_dtypes (Dict[str, Union[str, torch.device]], opcional) — Si se proporciona, dtypes especiales a considerar para algunos pesos específicos (anulará el dtype utilizado de forma predeterminada para todos los pesos).
  • verbose (bool, opcional, valor predeterminado False) — Indica si se deben proporcionar declaraciones de depuración mientras la función construye el device_map.
  • clean_result (bool, opcional, valor predeterminado True) — Limpia el device_map resultante agrupando todos los submódulos que se colocan en el mismo dispositivo.
  • offload_buffers (bool, opcional, valor predeterminado False) — En las capas que se descargan en la CPU o en el disco duro, si se deben descargar o no los buffers además de los parámetros.
  • fallback_allocation (bool, opcional, valor predeterminado False) — Si la asignación regular falla, intenta asignar un módulo que quepa dentro del límite de tamaño usando BFS.

Calcule un mapa de dispositivos para un modelo dado dando prioridad a las GPUs, luego descargue en la CPU y finalmente descargue en el disco, de modo que:

  • no superamos la memoria disponible de ninguna de las GPU.
  • si se necesita descargar en la CPU, siempre queda espacio en la GPU 0 para volver a colocar la capa descargada en la CPU que tiene el mayor tamaño.
  • si se necesita offload a la CPU, no superamos la RAM disponible en la CPU.
  • si se necesita descargar en el disco, siempre queda espacio en la CPU para volver a colocar la capa descargada en el disco que tiene el mayor tamaño.

Todos los cálculos se realizan analizando los tamaños y los dtypes de los parámetros del modelo. Como resultado, el modelo puede estar en el dispositivo meta (como lo estaría si se inicializara dentro del administrador de contexto init_empty_weights).

accelerate.load_checkpoint_in_model

< >

( model: Modulecheckpoint: str | os.PathLikedevice_map: dict[str, int | str | torch.device] | None = Noneoffload_folder: str | os.PathLike | None = Nonedtype: str | torch.dtype | None = Noneoffload_state_dict: bool = Falseoffload_buffers: bool = Falsekeep_in_fp32_modules: list[str] | None = Noneoffload_8bit_bnb: bool = Falsestrict: bool = Falsefull_state_dict: bool = Truebroadcast_from_rank0: bool = False )

Parámetros

  • model (torch.nn.Module) — El modelo en el que queremos cargar un punto de control.
  • checkpoint (str o os.PathLike) — El checkpoint de la carpeta a cargar. Puede ser:
    • una ruta a un archivo que contiene un diccionario de estado completo del modelo
    • una ruta a un archivo .json que contiene el índice de un punto de control fragmentado
    • una ruta a una carpeta que contiene un archivo .index.json único y los fragmentos de un punto de control.
    • una ruta a una carpeta que contenga un archivo pytorch_model.bin o model.safetensors único.
  • device_map (Dict[str, Union[int, str, torch.device]], opcional) — Un mapa que especifica dónde debe ir cada submódulo. No es necesario detallarlo para cada nombre de parámetro/buffer; una vez que un nombre de módulo está incluido, todos sus submódulos se enviarán al mismo dispositivo.
  • offload_folder (str o os.PathLike, opcional) — Si el device_map contiene algún valor "disk", la carpeta donde se descargarán los pesos.
  • dtype (str o torch.dtype, opcional) — Si se proporciona, los pesos se convertirán a ese tipo al cargarlos.
  • offload_state_dict (bool, opcional, valor predeterminado False) — Si True, se descargará temporalmente el state dict de CPU en el disco duro para evitar quedarse sin RAM de CPU si el peso del state dict de CPU + el fragmento más grande no cabe.
  • offload_buffers (bool, opcional, valor predeterminado False) — Si se incluyen o no los buffers en los pesos que se descargan en el disco.
  • keep_in_fp32_modules(List[str], opcional) — Una lista de los módulos que se mantienen en el tipo de datos torch.float32.
  • offload_8bit_bnb (bool, opcional) — Si se habilita o no el offload de módulos de 8 bits en cpu/disco.
  • strict (bool, opcional, valor predeterminado False) — Si se debe aplicar estrictamente que las claves del state_dict del checkpoint coincidan con las claves del state_dict del modelo.
  • full_state_dict (bool, opcional, valor predeterminado True) — si se establece en True, se recopilarán todos los tensores del state_dict cargado. No habrá ShardedTensor ni DTensor en el state_dict cargado.
  • broadcast_from_rank0 (False, opcional, valor predeterminado False) — cuando la opción es True, se debe inicializar un ProcessGroup distribuido. rank0 debe recibir un state_dict completo y retransmitirá los tensores del state_dict uno a uno a los demás ranks. Los demás ranks recibirán los tensores y los fragmentarán (si aplica) según los fragmentos locales del modelo.

Carga un punto de control (posiblemente fragmentado) dentro de un modelo, enviando potencialmente los pesos a un dispositivo dado a medida que se cargan.

Una vez cargado en los dispositivos, aún debe llamar a dispatch_model() en su modelo para que pueda ejecutarse. Para agrupar la carga del checkpoint y el despacho en una sola llamada, use load_checkpoint_and_dispatch().

accelerate.utils.load_offloaded_weights

< >

( modelindexoffload_folder )

Parámetros

  • model (torch.nn.Module) — El modelo en el que se cargarán los pesos.
  • index (dict) — Un diccionario que contiene el nombre del parámetro y sus metadatos para cada parámetro que se descargó del modelo.
  • offload_folder (str) — La carpeta donde se almacenan los pesos descargados.

Carga los pesos desde la carpeta de descarga en el modelo.

accelerate.utils.load_state_dict

< >

( checkpoint_filedevice_map = None )

Parámetros

  • checkpoint_file (str) — La ruta del punto de control que se va a cargar.
  • device_map (Dict[str, Union[int, str, torch.device]], opcional) — Un mapa que especifica dónde debe ir cada submódulo. No es necesario detallarlo para cada nombre de parámetro/buffer; una vez que un nombre de módulo está incluido, todos sus submódulos se enviarán al mismo dispositivo.

Carga un punto de control desde un archivo dado. Si el punto de control está en el formato safetensors y se pasa un mapa de dispositivos, los pesos se pueden cargar rápidamente directamente en la GPU.

accelerate.utils.offload_state_dict

< >

( save_dir: str | os.PathLikestate_dict: dict )

Parámetros

  • save_dir (str o os.PathLike) — El directorio en el que se descargará el state dict.
  • state_dict (Dict[str, torch.Tensor]) — El diccionario de tensores para descargar.

Descarga un state dict en una carpeta dada.

accelerate.utils.retie_parameters

< >

( modeltied_params )

Parámetros

  • model (torch.nn.Module) — El modelo en el que se deben volver a vincular los parámetros.
  • tied_params (List[List[str]]) — Un parámetro de mapeo de nombre de parámetro a nombre de parámetro vinculado, tal como se obtiene mediante find_tied_parameters.

Vuelve a atar los parámetros atados en un modelo dado si el vínculo se rompió (por ejemplo, al agregar hooks).

accelerate.utils.set_module_tensor_to_device

< >

( module: Moduletensor_name: strdevice: int | str | torch.devicevalue: torch.Tensor | None = Nonedtype: str | torch.dtype | None = Nonefp16_statistics: torch.HalfTensor | None = Nonetied_params_map: dict[int, dict[torch.device, torch.Tensor]] | None = Nonenon_blocking: bool = Falseclear_cache: bool = True )

Parámetros

  • module (torch.nn.Module) — El módulo en el que reside el tensor que queremos mover.
  • tensor_name (str) — El nombre completo del parámetro/buffer.
  • device (int, str o torch.device) — El dispositivo en el que se establecerá el tensor.
  • value (torch.Tensor, opcional) — El valor del tensor (útil al pasar del dispositivo meta a cualquier otro dispositivo).
  • dtype (torch.dtype, opcional) — Si se pasa, el valor del parámetro se convertirá a este dtype. De lo contrario, value se convertirá al dtype del parámetro existente en el modelo.
  • fp16_statistics (torch.HalfTensor, opcional) — La lista de estadísticas de fp16 para configurar en el módulo, utilizada para la serialización de modelos de 8 bits.
  • tied_params_map (Dict[int, Dict[torch.device, torch.Tensor]], opcional, valor predeterminado None) — Un mapa de punteros de datos actuales a diccionarios de dispositivos a pesos vinculados ya despachados. Para un dispositivo de ejecución dado, este parámetro es útil para reutilizar el primer puntero disponible de un peso compartido en el dispositivo para todos los demás, en lugar de duplicar la memoria.
  • non_blocking (bool, opcional, valor predeterminado False) — Si es True, la transferencia de dispositivo será asíncrona con respecto al host, si es posible.
  • clear_cache (bool, opcional, valor predeterminado True) — Si se debe o no limpiar la caché del dispositivo después de establecer el tensor en el dispositivo.

Una función auxiliar para establecer un tensor dado (parámetro o buffer) de un módulo en un dispositivo específico (tenga en cuenta que hacer param.to(device) crea un nuevo tensor no vinculado al parámetro, por lo que necesitamos esta función).

accelerate.utils.get_module_children_bottom_up

< >

( model: Modulereturn_fqns: bool = False ) → list[torch.nn.Module]

Parámetros

  • model (torch.nn.Module) — el modelo del que se obtendrán los hijos

Devuelve

list[torch.nn.Module]

una lista de los módulos hijos de model en orden ascendente. El último elemento es el propio model.

Recorre el modelo en orden ascendente y devuelve los módulos hijos en ese orden.

Paralelo

Estas incluyen utilidades generales que deben usarse al trabajar en paralelo.

accelerate.utils.extract_model_from_parallel

< >

( modelkeep_fp32_wrapper: bool = Truekeep_torch_compile: bool = Truerecursive: bool = False ) → torch.nn.Module

Parámetros

  • model (torch.nn.Module) — El modelo a extraer.
  • keep_fp32_wrapper (bool, opcional) — Si se deben eliminar los hooks de precisión mixta del modelo.
  • keep_torch_compile (bool, opcional) — Si se debe desenvolver el modelo compilado.
  • recursive (bool, opcional, valor predeterminado False) — Si se deben extraer recursivamente todos los casos de module.module de model, así como desenrollar recursivamente las subcapas hijas, no solo los contenedores distribuidos de nivel superior.

Devuelve

torch.nn.Module

El modelo extraído.

Extraer un modelo de sus contenedores distribuidos.

accelerate.utils.save

< >

( objfsave_on_each_node: bool = Falsesafe_serialization: bool = False )

Parámetros

  • obj — Los datos a guardar
  • f — El archivo (o objeto similar a un archivo) que se usará para guardar los datos
  • save_on_each_node (bool, opcional, valor predeterminado False) — Si se debe guardar solo en el proceso principal global
  • safe_serialization (bool, opcional, valor predeterminado False) — Si se debe guardar obj usando safetensors o el método tradicional de PyTorch (que usa pickle).

Guarde los datos en el disco. Utilice en lugar de torch.save().

accelerate.utils.load

< >

( fmap_location = None**kwargs )

Parámetros

  • f — El archivo (o objeto similar a un archivo) que se usará para cargar los datos
  • map_location — una función, torch.device, una cadena o un diccionario que especifica cómo remapear las ubicaciones de almacenamiento
  • **kwargs — Argumentos de palabra clave adicionales para pasar a torch.load().

Sustituto compatible de torch.load() que permite usar weights_only si la versión de torch es 2.4.0 o superior. En caso contrario, se ignorará el parámetro.

También se añadirá (y luego se eliminará) una excepción para los arreglos de numpy

accelerate.utils.wait_for_everyone

< >

( )

Introduce un punto de bloqueo en el script, asegurándose de que todos los procesos hayan alcanzado este punto antes de continuar.

Asegúrese de que todos los procesos lleguen a esta instrucción, de lo contrario, uno de sus procesos se quedará colgado para siempre.

Aleatorio

Estas utilidades se relacionan con la configuración y sincronización de todos los estados aleatorios.

accelerate.utils.set_seed

< >

( seed: intdevice_specific: bool = Falsedeterministic: bool = False )

Parámetros

  • seed (int) — La semilla a establecer.
  • device_specific (bool, opcional, valor predeterminado False) — Si se debe diferenciar ligeramente la semilla en cada dispositivo con self.process_index.
  • deterministic (bool, opcional, valor predeterminado False) — Si se deben usar algoritmos deterministas cuando estén disponibles. Puede ralentizar el entrenamiento.

Función auxiliar para un comportamiento reproducible que establece la semilla en random, numpy, torch.

accelerate.utils.synchronize_rng_state

< >

( rng_type: accelerate.utils.dataclasses.RNGType | None = Nonegenerator: torch.Generator | None = None )

accelerate.synchronize_rng_states

< >

( rng_types: listgenerator: torch.Generator | None = None )

PyTorch XLA

Estas incluyen utilidades que resultan útiles al usar PyTorch con XLA.

accelerate.utils.install_xla

< >

( upgrade: bool = False )

Parámetros

  • upgrade (bool, opcional, valor predeterminado False) — Si se debe actualizar torch e instalar las ruedas más recientes de torch_xla.

Función auxiliar para instalar las ruedas xla adecuadas según la versión de torch en Google Colaboratory.

Ejemplo:

>>> from accelerate.utils import install_xla

>>> install_xla(upgrade=True)

Carga de los pesos del modelo

Estos incluyen utilidades que resultan útiles para cargar puntos de control.

accelerate.load_checkpoint_in_model

< >

( model: Modulecheckpoint: str | os.PathLikedevice_map: dict[str, int | str | torch.device] | None = Noneoffload_folder: str | os.PathLike | None = Nonedtype: str | torch.dtype | None = Noneoffload_state_dict: bool = Falseoffload_buffers: bool = Falsekeep_in_fp32_modules: list[str] | None = Noneoffload_8bit_bnb: bool = Falsestrict: bool = Falsefull_state_dict: bool = Truebroadcast_from_rank0: bool = False )

Parámetros

  • model (torch.nn.Module) — El modelo en el que queremos cargar un punto de control.
  • checkpoint (str o os.PathLike) — El checkpoint de la carpeta a cargar. Puede ser:
    • una ruta a un archivo que contiene un diccionario de estado completo del modelo
    • una ruta a un archivo .json que contiene el índice de un punto de control fragmentado
    • una ruta a una carpeta que contiene un archivo .index.json único y los fragmentos de un punto de control.
    • una ruta a una carpeta que contenga un archivo pytorch_model.bin o model.safetensors único.
  • device_map (Dict[str, Union[int, str, torch.device]], opcional) — Un mapa que especifica dónde debe ir cada submódulo. No es necesario detallarlo para cada nombre de parámetro/buffer; una vez que un nombre de módulo está incluido, todos sus submódulos se enviarán al mismo dispositivo.
  • offload_folder (str o os.PathLike, opcional) — Si el device_map contiene algún valor "disk", la carpeta donde se descargarán los pesos.
  • dtype (str o torch.dtype, opcional) — Si se proporciona, los pesos se convertirán a ese tipo al cargarlos.
  • offload_state_dict (bool, opcional, valor predeterminado False) — Si True, se descargará temporalmente el state dict de CPU en el disco duro para evitar quedarse sin RAM de CPU si el peso del state dict de CPU + el fragmento más grande no cabe.
  • offload_buffers (bool, opcional, valor predeterminado False) — Si se incluyen o no los buffers en los pesos que se descargan en el disco.
  • keep_in_fp32_modules(List[str], opcional) — Una lista de los módulos que se mantienen en el tipo de datos torch.float32.
  • offload_8bit_bnb (bool, opcional) — Si se habilita o no el offload de módulos de 8 bits en cpu/disco.
  • strict (bool, opcional, valor predeterminado False) — Si se debe aplicar estrictamente que las claves del state_dict del checkpoint coincidan con las claves del state_dict del modelo.
  • full_state_dict (bool, opcional, valor predeterminado True) — si se establece en True, se recopilarán todos los tensores del state_dict cargado. No habrá ShardedTensor ni DTensor en el state_dict cargado.
  • broadcast_from_rank0 (False, opcional, valor predeterminado False) — cuando la opción es True, se debe inicializar un ProcessGroup distribuido. rank0 debe recibir un state_dict completo y retransmitirá los tensores del state_dict uno a uno a los demás ranks. Los demás ranks recibirán los tensores y los fragmentarán (si aplica) según los fragmentos locales del modelo.

Carga un punto de control (posiblemente fragmentado) dentro de un modelo, enviando potencialmente los pesos a un dispositivo dado a medida que se cargan.

Una vez cargado en los dispositivos, aún debe llamar a dispatch_model() en su modelo para que pueda ejecutarse. Para agrupar la carga del checkpoint y el despacho en una sola llamada, use load_checkpoint_and_dispatch().

Cuantización

Estas incluyen utilidades que resultan útiles para cuantizar el modelo.

accelerate.utils.load_and_quantize_model

< >

( model: Modulebnb_quantization_config: BnbQuantizationConfigweights_location: str | os.PathLike | None = Nonedevice_map: dict[str, int | str | torch.device] | None = Noneno_split_module_classes: list[str] | None = Nonemax_memory: dict[int | str, int | str] | None = Noneoffload_folder: str | os.PathLike | None = Noneoffload_state_dict: bool = False ) → torch.nn.Module

Parámetros

  • model (torch.nn.Module) — Modelo de entrada. El modelo puede estar ya cargado o en el dispositivo meta
  • bnb_quantization_config (BnbQuantizationConfig) — Los parámetros de cuantización de bitsandbytes
  • weights_location (str o os.PathLike) — La carpeta weights_location a cargar. Puede ser:
    • una ruta a un archivo que contiene un diccionario de estado completo del modelo
    • una ruta a un archivo .json que contiene el índice de un punto de control fragmentado
    • una ruta a una carpeta que contiene un archivo .index.json único y los fragmentos de un punto de control.
    • una ruta a una carpeta que contiene un archivo pytorch_model.bin único.
  • device_map (Dict[str, Union[int, str, torch.device]], opcional) — Un mapa que especifica dónde debe ir cada submódulo. No es necesario detallarlo para cada nombre de parámetro/buffer; una vez que un nombre de módulo está incluido, todos sus submódulos se enviarán al mismo dispositivo.
  • no_split_module_classes (List[str], opcional) — Una lista de nombres de clases de capas que nunca deben dividirse entre dispositivos (por ejemplo, cualquier capa que tenga una conexión residual).
  • max_memory (Dict, opcional) — Un diccionario de identificador de dispositivo a memoria máxima. Si no se establece, se usará la memoria máxima disponible.
  • offload_folder (str o os.PathLike, opcional) — Si el device_map contiene algún valor "disk", la carpeta donde se descargarán los pesos.
  • offload_state_dict (bool, opcional, valor predeterminado False) — Si True, se descargará temporalmente el state dict de CPU en el disco duro para evitar quedarse sin RAM de CPU si el peso del state dict de CPU + el fragmento más grande no cabe.

Devuelve

torch.nn.Module

El modelo cuantizado

Esta función cuantizará el modelo de entrada con la configuración asociada pasada en bnb_quantization_config. Si el modelo está en el dispositivo meta, cargaremos y despacharemos los pesos según el device_map pasado. Si el modelo ya está cargado, cuantizaremos el modelo y lo colocaremos en la GPU,

Update on GitHub

←FP8 Utilidades de Megatron-LM→