Accelerate documentation
Funções e classes utilitárias
Funções e classes utilitárias
Abaixo estão diversas funções utilitárias fornecidas pelo 🤗 Accelerate, divididas por caso de uso.
Constantes
Constantes usadas ao longo do 🤗 Accelerate para referência
A seguir estão as constantes usadas ao utilizar 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
A seguir estão as constantes usadas ao utilizar 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"
Classes de Dados
Estas são dataclasses básicas usadas em todo o 🤗 Accelerate e podem ser passadas como parâmetros.
Independente
Estas são dataclasses independentes usadas para verificações, como o tipo de sistema distribuído em uso
Representa um tipo de ambiente de computação.
Valores:
- LOCAL_MACHINE — hardware de cluster privado/personalizado.
- AMAZON_SAGEMAKER — Amazon SageMaker como ambiente de computação.
Representa um tipo de ambiente distribuído.
Valores:
- NÃO — Não é um ambiente distribuído, apenas um processo único.
- MULTI_CPU — Distribuído em vários nós de CPU.
- MULTI_GPU — Distribuído em várias GPUs.
- MULTI_MLU — Distribuído em múltiplos MLUs.
- MULTI_SDAA — Distribuído em vários SDAAs.
- MULTI_MUSA — Distribuído em múltiplas MUSAs.
- MULTI_NPU — Distribuído em múltiplos NPUs.
- MULTI_XPU — Distribuído em múltiplos XPUs.
- MULTI_HPU — Distribuído em vários HPUs.
- MULTI_NEURON — Distribuído em vários núcleos Neuron.
- DEEPSPEED — Usando o DeepSpeed.
- FSDP — Usando Fully Sharded Data Parallelism (FSDP).
- XLA — Usando o TorchXLA.
- MEGATRON_LM — Usando o Megatron-LM.
Representa um backend de dynamo (veja https://pytorch.org/docs/stable/torch.compiler.html).
Valores:
- NÃO — Não use torch dynamo.
- EAGER — Usa o PyTorch para executar o GraphModule extraído. Isso é bastante útil para depurar problemas do TorchDynamo.
- AOT_EAGER — Usa AotAutograd sem compilador, ou seja, apenas usa o modo eager do PyTorch para os gráficos de forward e backward extraídos pelo AotAutograd. Isso é útil para depuração e é improvável que resulte em ganhos de velocidade.
- INDUCTOR — Usa o backend TorchInductor com AotAutograd e cudagraphs, aproveitando kernels Triton gerados por codegen. Saiba mais
- AOT_TS_NVFUSER — nvFuser com AotAutograd/TorchScript. Saiba mais
- NVPRIMS_NVFUSER — nvFuser com PrimTorch. Saiba mais
- CUDAGRAPHS — cudagraphs com AotAutograd. Saiba mais
- OFI — Usa Torchscript optimize_for_inference. Apenas inferência. Saiba mais
- FX2TRT — Usa o Nvidia TensorRT para otimizações de inferência. Apenas inferência. Saiba mais
- ONNXRT — Usa ONNXRT para inferência em CPU/GPU. Apenas inferência. Saiba mais
- TENSORRT — Usa ONNXRT para executar TensorRT para otimizações de inferência. Saiba mais
- AOT_TORCHXLA_TRACE_ONCE — Usa Pytorch/XLA com otimização TorchDynamo, para treinamento. Saiba mais
- TORCHXLA_TRACE_ONCE — Usa Pytorch/XLA com otimização TorchDynamo, para inferência. Saiba mais
- TVM — Usa o Apache TVM para otimizações de inferência. Saiba mais
- HPU_BACKEND — Usa o backend HPU para otimizações de inferência.
- NEURON — Usa o backend AWS Neuron para Trainium/Inferentia.
Representa um tipo de rastreador de experimentos suportado
Valores:
- TODOS — todos os trackers disponíveis no ambiente que são suportados
- TENSORBOARD — TensorBoard como rastreador de experimentos
- WANDB — wandb como rastreador de experimentos
- TRACKIO — trackio como rastreador de experimentos
- COMETML — comet_ml como rastreador de experimentos
- MLFLOW — mlflow como rastreador de experimentos
- CLEARML — clearml como rastreador de experimentos
- DVCLIVE — dvclive como rastreador de experimentos
- SWANLAB — swanlab como rastreador de experimentos
Representa um tipo de precisão usado em valores de ponto flutuante
Valores:
- NÃO — usando precisão completa (FP32)
- FP16 — usando meia precisão
- BF16 — usando precisão de ponto flutuante cerebral
Representa um tipo de ambiente distribuído.
Valores:
- NÃO — Não é um ambiente distribuído, apenas um processo único.
- DATA_PARALLEL — usando a paralelização distribuída de dados do sagemaker.
- MODEL_PARALLEL — usando paralelismo de modelo distribuído do sagemaker.
Kwargs
Estes são argumentos configuráveis para interações específicas em todo o ecossistema do PyTorch que o Accelerate trata nos bastidores.
classe accelerate.AutocastKwargs
< source >( enabled: bool = Truecache_enabled: bool | None = None )
Use este objeto em seu Accelerator para personalizar o comportamento de torch.autocast. Consulte a
documentação deste context manager para mais
informações sobre cada argumento.
classe accelerate.DistributedDataParallelKwargs
< source >( 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 em seu Accelerator para personalizar como seu modelo é envolvido em um torch.nn.parallel.DistributedDataParallel. Consulte a documentação deste wrapper para mais informações sobre cada argumento.
classe accelerate.GradScalerKwargs
< source >( init_scale: float = 65536.0growth_factor: float = 2.0backoff_factor: float = 0.5growth_interval: int = 2000enabled: bool = True )
Use este objeto em seu Accelerator para personalizar o comportamento da precisão mista, especificamente como o torch.amp.GradScaler ou torch.cuda.amp.GradScaler utilizado é criado. Consulte a documentação deste scaler para mais informações sobre cada argumento.
classe accelerate.InitProcessGroupKwargs
< source >( backend: str | None = 'nccl'init_method: str | None = Nonetimeout: datetime.timedelta | None = None )
Use este objeto em seu Accelerator para personalizar a inicialização dos processos distribuídos. Consulte a documentação deste método para mais informações sobre cada argumento.
Observação: Se timeout for definido como None, o valor padrão será baseado em como backend está configurado.
Mixin interno que implementa um método to_kwargs() para uma dataclass.
Retorna um dicionário contendo os atributos com valores diferentes dos padrões desta classe.
Plugins
Estes são plugins que podem ser passados para o objeto Accelerator. Embora sejam definidos em outra parte da documentação, para sua conveniência, todos eles estão disponíveis para visualização aqui:
classe accelerate.DeepSpeedPlugin
< source >( 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, padrãoNone) — Caminho para o arquivo de configuração do DeepSpeed, um dicionário ou um objeto da classeaccelerate.utils.deepspeed.HfDeepSpeedConfig. - gradient_accumulation_steps (
int, padrãoNone) — Número de passos para acumular gradientes antes de atualizar os estados do otimizador. Se não for definido, usará o valor doAcceleratordiretamente. - gradient_clipping (
float, padrãoNone) — Ativa o recorte de gradiente com o valor especificado. - zero_stage (
int, padrãoNone) — As opções possíveis são 0, 1, 2, 3. O padrão será obtido da variável de ambiente. - is_train_batch_min (
bool, padrãoTrue) — Se ambos os dataloaders de treino e avaliação forem especificados, este parâmetro determinará otrain_batch_size. - offload_optimizer_device (
str, padrãoNone) — As opções possíveis são none|cpu|nvme. Aplicável apenas com os Estágios 2 e 3 do ZeRO. - offload_param_device (
str, padrãoNone) — As opções possíveis são none|cpu|nvme. Aplicável apenas com ZeRO Stage 3. - offload_optimizer_nvme_path (
str, padrãoNone) — As opções possíveis são /nvme|/local_nvme. Aplicável apenas com ZeRO Stage 3. - offload_param_nvme_path (
str, padrãoNone) — As opções possíveis são /nvme|/local_nvme. Aplicável apenas com ZeRO Stage 3. - zero3_init_flag (
bool, padrãoNone) — Indica se o modelo de 16 bits deve ser salvo. Aplicável apenas com ZeRO Stage-3. - zero3_save_16bit_model (
bool, padrãoNone) — Flag para indicar se o modelo de 16 bits deve ser salvo. Aplicável apenas com ZeRO Stage-3. - transformer_moe_cls_names (
str, padrãoNone) — Lista separada por vírgulas dos nomes das classes de camadas MoE do Transformers (sensível a maiúsculas e minúsculas). Por exemplo,MixtralSparseMoeBlock,Qwen2MoeSparseMoeBlock,JetMoEAttention,JetMoEBlock, etc.
Este plugin é usado para integrar o DeepSpeed.
deepspeed_config_process
< source >( prefix = ''mismatches = Noneconfig = Nonemust_match = True**kwargs )
Processe a configuração do DeepSpeed com os valores dos kwargs.
Define o HfDeepSpeedWeakref para usar a configuração atual do plugin deepspeed
classe 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, padrão1) — A versão do FSDP a ser usada. O padrão é 1. Se definido como 2, o launcher espera que a configuração seja convertida para o formato FSDP2. - sharding_strategy (
Union[str, torch.distributed.fsdp.ShardingStrategy], padrão'FULL_SHARD') — Estratégia de sharding a ser utilizada. Deve ser umastrou uma instância detorch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy. Está obsoleta em favor dereshard_after_forward. - reshard_after_forward (
Union[str, torch.distributed.fsdp.ShardingStrategy, bool], padrão'FULL_SHARD'parafsdp_version=1eTrueparafsdp_version=2) — Estratégia de sharding a ser utilizada. Deve ser um bool sefsdp_versionestiver definido como 2, caso contrário, umstrou uma instância detorch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy. - backward_prefetch (
Union[str, torch.distributed.fsdp.BackwardPrefetch], padrão'NO_PREFETCH') — Estratégia de pré-busca reversa a ser utilizada. Deve ser umastrou uma instância detorch.distributed.fsdp.fully_sharded_data_parallel.BackwardPrefetch. - mixed_precision_policy (
Optional[Union[dict, str, torch.distributed.fsdp.MixedPrecision, torch.distributed.fsdp.MixedPrecisionPolicy]], padrãoNone) — Uma configuração para habilitar o treinamento com precisão mista usando FullyShardedDataParallel. Se umdictfor passado, ele deve ter as seguintes chaves:param_dtype,reduce_dtypeebuffer_dtype. Pode ser uma instância detorch.distributed.fsdp.MixedPrecisionPolicysefsdp_versionestiver definido como 2. Se umstrfor passado, ele deve ser um dos seguintes valores: fp8, fp16, bf16, fp32, e é usado para definirparam_dtype,reduce_dtypeebuffer_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], padrãoFalse) — Se os parâmetros devem ser transferidos para a CPU. Deve ser umboolou uma instância detorch.distributed.fsdp.fully_sharded_data_parallel.CPUOffloadoutorch.distributed.fsdp.fully_sharded_data_parallel.CPUOffloadPolicysefsdp_versionestiver definido como 2. - ignored_modules (
Optional[Union[Iterable[torch.nn.Module], str]], padrãoNone) — Uma lista de módulos a serem ignorados ao envolver com FSDP. Ao passar uma string, os módulos serão correspondidos por nome usando regex fullmatch. Sefsdp_versionestiver definido como 2, os módulos são convertidos em parâmetros e utilizados. - state_dict_type (
Union[str, torch.distributed.fsdp.StateDictType], padrão'FULL_STATE_DICT') — Tipo de state dict a ser usado. Se for uma string, deve ser um defull_state_dict,local_state_dictousharded_state_dict. - state_dict_config (
Optional[Union[torch.distributed.fsdp.FullStateDictConfig, torch.distributed.fsdp.ShardedStateDictConfig], padrãoNone) — Configuração do state dict a ser utilizada. É determinada com base nostate_dict_typecaso não seja fornecida. - optim_state_dict_config (
Optional[Union[torch.distributed.fsdp.FullOptimStateDictConfig, torch.distributed.fsdp.ShardedOptimStateDictConfig], padrãoNone) — Configuração do state dict do otimizador a ser usada. É determinada com base nostate_dict_typecaso não seja fornecida. - limit_all_gathers (
bool, padrãoTrue) — Se o FSDP deve sincronizar explicitamente a thread de CPU para evitar que haja muitos all-gathers em andamento. Este bool afeta apenas as estratégias shardadas que agendam all-gathers. Habilitar isso pode ajudar a reduzir o número de retries de malloc da CUDA. - use_orig_params (
bool, padrãoFalse) — Se deve usar os parâmetros originais para o otimizador. - param_init_fn (
Optional[Callable[[torch.nn.Module], None], padrãoNone) — UmCallable[torch.nn.Module] -> Noneque especifica como os módulos que estão atualmente no dispositivo meta devem ser inicializados em um dispositivo real. Aplicável apenas quandosync_module_stateséTrue. Por padrão, é umlambdaque chamato_emptyno módulo. - sync_module_states (
bool, padrãoFalse) — Se cada unidade FSDP individualmente envolvida deve transmitir os parâmetros do módulo a partir do rank 0 para garantir que eles sejam os mesmos em todos os ranks após a inicialização. O padrão éFalse, a menos quecpu_ram_efficient_loadingsejaTrue, caso em que será habilitado forçadamente. - forward_prefetch (
bool, padrãoFalse) — Se o FSDP deve pré-buscar explicitamente o próximo all-gather durante a execução da passagem de forward. Use apenas com grafos estáticos. - activation_checkpointing (
bool, padrãoFalse) — Uma técnica para reduzir o uso de memória limpando as ativações de determinadas camadas e recalculando-as durante uma passada de retropropagação. Efetivamente, isso troca tempo extra de computação por um uso reduzido de memória. - cpu_ram_efficient_loading (
bool, padrãoNone) — Se True, apenas o primeiro processo carrega o checkpoint do modelo pré-treinado, enquanto todos os outros processos têm pesos vazios. Aplicável apenas para Transformers. Ao usar isso,sync_module_statesprecisa serTrue. - transformer_cls_names_to_wrap (
Optional[List[str]], padrãoNone) — Uma lista de nomes de classes de camadas de transformer para envolver. Aplicável apenas quandoauto_wrap_policyétransformer_based_wrap. - min_num_params (
Optional[int], padrãoNone) — O número mínimo de parâmetros que um módulo deve ter para ser envolvido. Aplicável apenas quandoauto_wrap_policyésize_based_wrap.
Este plugin é usado para habilitar o paralelismo totalmente fragmentado de dados.
Dado model, cria um auto_wrap_policy com base na política passada e se podemos usar o transformer_cls_to_wrap
Define a política de precisão mista para FSDP
Defina a configuração do state dict com base no StateDictType.
Valida a política de precisão mista, abstraída para não importar os módulos se não forem necessários.
classe accelerate.utils.GradientAccumulationPlugin
< source >( num_steps: int = Noneadjust_scheduler: bool = Truesync_with_dataloader: bool = Truesync_each_batch: bool = False )
Parâmetros
- num_steps (
int) — O número de passos para acumular gradientes. - adjust_scheduler (
bool, opcional, padrãoTrue) — Se deve ajustar os passos do agendador para levar em conta o número de passos acumulados. Deve serTruese o agendador utilizado não foi ajustado para a acumulação de gradientes. - sync_with_dataloader (
bool, opcional, padrãoTrue) — Se deve sincronizar a configuração dos gradientos ao final do dataloader. - sync_each_batch (
bool, opcional) — Se deve sincronizar a configuração dos gradientes em cada lote de dados. Definir comoTruepode reduzir os requisitos de memória ao usar acúmulo de gradientes com treinamento distribuído, à custa da velocidade.
Um plugin para configurar o comportamento de acúmulo de gradientes. Você só pode passar um de gradient_accumulation_plugin ou gradient_accumulation_steps para Accelerator. Passar ambos gera um erro.
classe accelerate.utils.MegatronLMPlugin
< source >( 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[int] = 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, padrãoNone) — Grau de paralelismo de tensor. - pp_degree (
int, padrãoNone) — Grau de paralelismo de pipeline. - num_micro_batches (
int, padrãoNone) — Número de micro-lotes. - gradient_clipping (
float, padrãoNone) — Valor de recorte de gradiente baseado na norma L2 global (0 para desativar). - sequence_parallelism (
bool, padrãoNone) — Ativa o paralelismo de sequência. - recompute_activations (
bool, padrãoNone) — Ativa a recomputação seletiva de ativações. - use_distributed_optimizer (
bool, padrãoNone) — Ativa o otimizador distribuído. - pipeline_model_parallel_split_rank (
int, padrãoNone) — Rank onde o codificador e o decodificador devem ser separados. - num_layers_per_virtual_pipeline_stage (
int, padrãoNone) — Número de camadas por estágio de pipeline virtual. - is_train_batch_min (
str, padrãoTrue) — Se ambos os dataloaders de treino e avaliação forem especificados, este parâmetro determinará omicro_batch_size. - train_iters (
int, padrãoNone) — Número total de amostras para treinar em todas as execuções de treinamento. Observe que, ao usarMegatronLMDummyScheduler, deve-se fornecer train-iters ou train-samples. - train_samples (
int, padrãoNone) — Número total de amostras para treinar em todas as execuções de treinamento. Observe que, ao usarMegatronLMDummyScheduler, deve-se fornecer train-iters ou train-samples. - weight_decay_incr_style (
str, padrão'constant') — Função de incremento do weight decay. choices=[“constant”, “linear”, “cosine”]. - start_weight_decay (
float, padrãoNone) — Coeficiente inicial de decaimento de peso para regularização L2. - end_weight_decay (
float, padrãoNone) — Coeficiente de decaimento de peso no final da execução para regularização L2. - lr_decay_style (
str, padrão'linear') — Função de decaimento da taxa de aprendizado. choices=[‘constant’, ‘linear’, ‘cosine’]. - lr_decay_iters (
int, padrãoNone) — Número de iterações para o decaimento da taxa de aprendizado. Se for None, o padrão étrain_iters. - lr_decay_samples (
int, padrãoNone) — Número de amostras para o decaimento da taxa de aprendizado. Se for None, o padrão étrain_samples. - lr_warmup_iters (
int, padrãoNone) — Número de iterações para o aquecimento linear da taxa de aprendizado. - lr_warmup_samples (
int, padrãoNone) — Número de amostras para o aquecimento linear da taxa de aprendizado. - lr_warmup_fraction (
float, padrãoNone) — Fração de lr-warmup-(iters/samples) para aquecer linearmente a taxa de aprendizado. - min_lr (
float, padrão0) — Valor mínimo para a taxa de aprendizado. O agendador limita os valores abaixo desse limite. - consumed_samples (
List, padrãoNone) — Número de amostras consumidas na mesma ordem dos dataloaders para a chamada deaccelerator.prepare. - no_wd_decay_cond (
Optional, padrãoNone) — Condição para desativar o decaimento de peso. - scale_lr_cond (
Optional, padrãoNone) — Condição para escalar a taxa de aprendizado. - lr_mult (
float, padrão1.0) — Multiplicador da taxa de aprendizado. - megatron_dataset_flag (
bool, padrãoFalse) — Se o formato do conjunto de dados segue o formato Indexed/Cached/MemoryMapped do Megatron-LM. - seq_length (
int, padrãoNone) — Comprimento máximo da sequência a ser processado. - encoder_seq_length (
int, padrãoNone) — Comprimento máximo da sequência a ser processada pelo codificador. - decoder_seq_length (
int, padrãoNone) — Comprimento máximo da sequência a ser processada para o decodificador. - tensorboard_dir (
str, padrãoNone) — Caminho para salvar os logs do tensorboard. - set_all_logging_options (
bool, padrãoFalse) — Se deve definir todas as opções de log. - eval_iters (
int, padrão100) — Número de iterações a serem executadas para a validação/teste de avaliação. - eval_interval (
int, padrão1000) — Intervalo entre a execução da avaliação no conjunto de validação. - return_logits (
bool, padrãoFalse) — Se deve retornar os logits do modelo. - custom_train_step_class (
Optional, padrãoNone) — Classe de etapa de treinamento personalizada. - custom_train_step_kwargs (
Optional, padrãoNone) — Kwargs personalizados para o passo de treinamento. - custom_model_provider_function (
Optional, padrãoNone) — Função de provedor de modelo personalizada. - custom_prepare_model_function (
Optional, padrãoNone) — Função personalizada para preparar o modelo. - custom_megatron_datasets_provider_function (
Optional, padrãoNone) — Função de provedor de conjuntos de dados de treino, validação e teste do Megatron personalizada. - custom_get_batch_function (
Optional, padrãoNone) — Função personalizada para obter um lote. - custom_loss_function (
Optional, padrãoNone) — Função de perda personalizada. - other_megatron_args (
Optional, padrãoNone) — Outros argumentos do Megatron-LM. Consulte a documentação do Megatron-LM.
Plugin para Megatron-LM para habilitar paralelismo de tensor, pipeline, sequência e dados. Também para habilitar recomputação seletiva de ativação e kernels fundidos otimizados.
classe accelerate.utils.TorchDynamoPlugin
< source >( backend: DynamoBackend = Nonemode: str = Nonefullgraph: bool = Nonedynamic: bool = Noneoptions: Any = Nonedisable: bool = Falseuse_regional_compilation: bool = None )
Parâmetros
- backend (
DynamoBackend, padrãoNone) — Um backend Dynamo válido. Consulte https://pytorch.org/docs/stable/torch.compiler.html para mais detalhes. - mode (
str, padrãoNone) — As opções possíveis são ‘default’, ‘reduce-overhead’ ou ‘max-autotune’. - fullgraph (
bool, padrãoNone) — Se é aceitável dividir o modelo em vários subgrafos. - dynamic (
bool, padrãoNone) — Se deve usar forma dinâmica para o tracing. - options (
Any, padrãoNone) — Um dicionário de opções para passar ao backend. - disable (
bool, padrãoFalse) — Torna o torch.compile() uma operação nula para testes - use_regional_compilation (
bool, padrãoNone) — Use para reduzir o tempo de compilação inicial do torch.compile() ao direcionar blocos repetidos da mesma classe e compilá-los sequencialmente para aproveitar o cache do compilador. Por exemplo, emGPT2LMHeadModel, o bloco/classe repetido éGPT2Block, e pode ser acessado comomodel.transformer.h[0]. O restante do modelo (por exemplo, model.lm_head) é compilado separadamente.
Este plugin é usado para compilar um modelo com PyTorch 2.0
Configurações
Estas são classes que podem ser configuradas e passadas para a integração apropriada
classe accelerate.utils.BnbQuantizationConfig
< source >( 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[str] = Nonekeep_in_fp32_modules: list[str] = None )
Parâmetros
- load_in_8bit (
bool, padrãoFalse) — Ativa a quantização de 8 bits. - llm_int8_threshold (
float, padrão6.0) — Valor do limiar do outliner. Relevante apenas quandoload_in_8bit=True. - load_in_4bit (
bool, padrãoFalse) — Ativa a quantização em 4 bits. - bnb_4bit_quant_type (
str, padrãofp4) — Define o tipo de dados de quantização nas camadasbnb.nn.Linear4Bit. As opções são {‘fp4’,‘np4’}. - bnb_4bit_use_double_quant (
bool, padrãoFalse) — Ativa a quantização aninhada, na qual as constantes de quantização da primeira quantização são quantizadas novamente. - bnb_4bit_compute_dtype (
bool, padrãofp16) — Isso define o tipo de cálculo, que pode ser diferente do tipo de entrada. Por exemplo, as entradas podem ser fp32, mas o cálculo pode ser definido como bf16 para ganhos de velocidade. As opções são {‘fp32’,‘fp16’,‘bf16’}. - torch_dtype (
torch.dtype, padrãoNone) — Isso define o dtype das camadas restantes não quantizadas. A bibliotecabitsandbytessugere definir o valor comotorch.float16para modelos de 8 bits e usar o mesmo dtype do dtype de computação para modelos de 4 bits. - skip_modules (
List[str], padrãoNone) — Uma lista explícita dos módulos que não serão quantizados. O dtype desses módulos serátorch_dtype. - keep_in_fp32_modules (
List, padrãoNone) — Uma lista explícita dos módulos que não são quantizados. Eles são mantidos emtorch.float32.
Um plugin para habilitar a quantização de 4 bits e 8 bits do BitsAndBytes
classe accelerate.DataLoaderConfiguration
< source >( 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, padrãoFalse) — Se o acelerador deve ou não dividir os lotes gerados pelos dataloaders entre os dispositivos. SeTrue, o tamanho real do lote usado será o mesmo em qualquer tipo de processo distribuído, mas deve ser um múltiplo exato denum_processesque você está usando. SeFalse, o tamanho real do lote usado será o definido no seu script multiplicado pelo número de processos. - dispatch_batches (
bool, padrãoNone) — Se definido comoTrue, o dataloader preparado pelo Accelerator é iterado apenas no processo principal e, em seguida, os lotes são divididos e transmitidos para cada processo. O padrão seráTrueparaDataLoadercujo conjunto de dados subjacente é umIterableDataset,Falsecaso contrário. - even_batches (
bool, padrãoTrue) — Se definido comoTrue, em casos em que o tamanho total do lote em todos os processos não divide exatamente o conjunto de dados, as amostras no início do conjunto de dados serão duplicadas para que o lote possa ser dividido igualmente entre todos os workers. - use_seedable_sampler (
bool, padrãoFalse) — Indica se deve ou não usar um amostrador aleatório totalmente semeadável (data_loader.SeedableRandomSampler). Garante que os resultados do treinamento sejam totalmente reproduzíveis usando uma técnica de amostragem diferente. Embora os resultados entre sementes possam diferir, em média as diferenças são insignificantes ao usar várias sementes diferentes para comparação. Deve ser executado também com set_seed() para obter os melhores resultados. - data_seed (
int, padrãoNone) — A semente a ser usada para o gerador subjacente ao utilizaruse_seedable_sampler. SeNone, o gerador usará a semente padrão atual do torch. - non_blocking (
bool, padrãoFalse) — Se definido comoTrue, o dataloader preparado pelo Accelerator utilizará transferências não bloqueantes de host para dispositivo, permitindo um melhor sobreposição entre a comunicação do dataloader e a computação. Recomenda-se que o dataloader preparado tenhapin_memorydefinido comoTruepara funcionar corretamente. - use_stateful_dataloader (
bool, padrãoFalse) — Se definido comoTrue, o dataloader preparado pelo Accelerator será baseado em torchdata.StatefulDataLoader. Isso requer a instalação da versão 0.8.0 ou superior dotorchdataque suporte StatefulDataLoader.
Configuração para itens relacionados ao dataloader ao chamar accelerator.prepare.
classe accelerate.utils.ProjectConfiguration
< source >( 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, padrãoNone) — Um caminho para um diretório de armazenamento de dados. - logging_dir (
str, padrãoNone) — Um caminho para um diretório de armazenamento de logs de loggers compatíveis localmente. Se for None, o padrão éproject_dir. - automatic_checkpoint_naming (
bool, padrãoFalse) — Se os estados salvos devem ser nomeados automaticamente de forma iterativa. - total_limit (
int, padrãoNone) — O número máximo de estados salvos no total a serem mantidos. - iteration (
int, padrão0) — A iteração de salvamento atual. - save_on_each_node (
bool, padrãoFalse) — Ao realizar treinamento distribuído em vários nós, se os modelos e checkpoints devem ser salvos em cada nó ou apenas no principal.
Configuração para o objeto Accelerator com base nas necessidades internas do projeto.
Define self.project_dir e self.logging_dir para os valores apropriados.
Variáveis de Ambiente
Estas são variáveis de ambiente que podem ser ativadas para diferentes casos de uso
ACCELERATE_DEBUG_MODE(str): Se o accelerate deve ser executado em modo de depuração. Mais informações disponíveis aqui.
Manipulação de Dados e Operações
Isso inclui operações de dados que imitam as mesmas operações do torch, mas que podem ser usadas em processos distribuídos.
accelerate.utils.broadcast
< source >( tensorfrom_process: int = 0 )
Dissemine recursivamente o tensor em uma lista/tupla/dicionário aninhado de tensors para todos os dispositivos.
accelerate.utils.broadcast_object_list
< source >( object_listfrom_process: int = 0 )
Broadcast uma lista de objetos picklable de um processo para os outros.
accelerate.utils.concatenate
< source >( datadim = 0 )
Concatena recursivamente os tensors em uma lista/tupela/dicionário aninhado de listas de tensors com a mesma forma. Se houver apenas um único lote de dados, ele é retornado como está.
accelerate.utils.convert_to_fp32
< source >( tensor )
Converte recursivamente os elementos de listas/tuplas/dicionários aninhados de tensores em precisão FP16/BF16 para FP32.
accelerate.utils.gather
< source >( tensor )
Recolher recursivamente um tensor em uma lista/tupla/dicionário aninhado de tensors de todos os dispositivos.
accelerate.utils.gather_object
< source >( object: Any )
Recolher recursivamente um objeto em uma lista/tupela/dicionário aninhado de objetos de todos os dispositivos.
accelerate.utils.get_grad_scaler
< source >( distributed_type: DistributedType = None**kwargs )
Um auxiliar genérico que inicializa a implementação correta de GradScaler com base no ambiente e a retorna.
accelerate.utils.get_mixed_precision_context_manager
< source >( native_amp: bool = Falseautocast_kwargs: AutocastKwargs = None )
Retorna um gerenciador de contexto para o autocasting de precisão mista
accelerate.utils.listify
< source >( data )
Encontra recursivamente tensores em uma lista/tupela/dicionário aninhado e os converte em uma lista de números.
accelerate.utils.pad_across_processes
< source >( tensordim = 0pad_index = 0pad_first = False )
Parâmetros
- tensor (lista/tupla/dicionário aninhado de
torch.Tensor) — Os dados a serem coletados. - dim (
int, opcional, padrão 0) — A dimensão na qual aplicar o preenchimento. - pad_index (
int, opcional, padrão 0) — O valor usado para o preenchimento. - pad_first (
bool, opcional, padrãoFalse) — Se o preenchimento deve ser feito no início ou no final.
Preencha recursivamente os tensores em uma lista/tupla/dicionário aninhado de tensores de todos os dispositivos até o mesmo tamanho para que possam ser coletados com segurança.
accelerate.utils.recursively_apply
< source >( funcdata*argstest_type = <function is_torch_tensor at 0x7fda201c8460>error_on_other_type = False**kwargs )
Parâmetros
- func (
callable) — A função a ser aplicada recursivamente. - data (lista/tupla/dicionário aninhado de objetos aceitos por
test_type) — Os dados nos quais aplicarfunc - *args —
Argumentos posicionais que serão passados para
funcquando aplicado aos dados descompactados. - test_type (
Callable[[Any], bool], opcional, padrãois_torch_tensor) — O predicado que decide sefuncdeve ser aplicado a um determinado objeto folha. - error_on_other_type (
bool, opcional, padrãoFalse) — Se deve retornar um erro ou não se, após descompactardata, obtermos um objeto para o qualtest_typeretornaFalse. SeFalse, a função deixará tais objetos inalterados. - **kwargs (argumentos de palavra-chave adicionais, opcional) —
Argumentos de palavra-chave que serão passados para
funcquando aplicado aos dados descompactados.
Aplica recursivamente uma função em uma estrutura de dados que é uma lista/tupela/dicionário aninhado de um tipo base dado.
Reduz recursivamente os tensors em uma lista/tupela/dicionário aninhado de listas de tensors em todos os processos pela média de uma operação dada.
accelerate.utils.send_to_device
< source >( tensordevicenon_blocking = Falseskip_keys = None )
Parâmetros
- tensor (lista/tupla/dicionário aninhado de
torch.Tensor) — Os dados a serem enviados para um dispositivo específico. - device (
torch.device) — O dispositivo para o qual os dados devem ser enviados. - non_blocking (
bool, opcional, padrãoFalse) — SeTrue, a transferência para o dispositivo é executada de forma assíncrona, o que pode sobrepor o movimento de dados com a computação. Efetivo apenas quando o dispositivo oferece suporte (por exemplo, CUDA). - skip_keys (
strouList[str], opcional) — Uma chave ou lista de chaves em um dicionáriotensorcujos valores não devem ser enviados para odeviceespecificado. As entradas com essas chaves permanecem no dispositivo original.
Envia recursivamente os elementos de uma lista/tupela/dicionário aninhado de tensores para um dispositivo específico.
accelerate.utils.slice_tensors
< source >( datatensor_sliceprocess_index = Nonenum_processes = None )
Extrai recursivamente uma fatia de uma lista/tupela/dicionário aninhado de tensores.
Verificações de Ambiente
Essas funcionalidades verificam o estado do ambiente de trabalho atual, incluindo informações sobre o próprio sistema operacional, o que ele pode suportar e se dependências específicas estão instaladas.
Verifica se o bf16 é suportado, ignorando opcionalmente o TPU
Verifica se o dispositivo MPS está disponível. A versão mínima necessária é 1.12.
Verifica se torch_npu está instalado e, potencialmente, se há uma NPU no ambiente
accelerate.utils.is_torch_version
< source >( operation: strversion: str )
Compara a versão atual do PyTorch com uma referência dada usando uma operação.
Verifique se torch_xla está disponível. Para treinar um job nativo de pytorch em um ambiente com torch xla instalado, defina
o USE_TORCH_XLA como false.
Verifica se a aceleração XPU está disponível via PyTorch padrão (>=2.7) e, potencialmente, se há uma XPU no ambiente
Manipulação de Ambiente
Um gerenciador de contexto que adiciona cada argumento de palavra-chave passado para os.environ e os remove ao sair.
Converterá os valores em kwargs para strings e colocará todas as chaves em maiúsculas.
Um gerenciador de contexto que limpa temporariamente variáveis de ambiente.
Quando este contexto termina, as variáveis de ambiente anteriores serão restauradas.
accelerate.commands.config.default.write_basic_config
< source >( mixed_precision = 'no'save_location: str = '/home/runner/.cache/huggingface/accelerate/default_config.yaml' )
Parâmetros
- mixed_precision (
str, opcional, padrão “no”) — Precisão Mista a ser usada. Deve ser um dos valores “no”, “fp16” ou “bf16” - save_location (
str, opcional, padrãodefault_json_config_file) — Local de salvamento personalizado opcional. Deve ser passado para--config_fileao usaraccelerate launch. O local padrão está dentro da pasta de cache do huggingface (~/.cache/huggingface), mas pode ser substituído definindo a variável de ambienteHF_HOME, seguida poraccelerate/default_config.yaml.
Cria e salva uma configuração básica de cluster para ser usada em uma máquina local, possivelmente com múltiplas GPUs. Também configurará a CPU, caso se trate de uma máquina apenas com CPU.
Ao configurar o 🤗 Accelerate pela primeira vez, em vez de executar accelerate config, [~utils.write_basic_config] pode ser usado como alternativa para uma configuração rápida.
Atribui o processo atual a um nó NUMA específico. É idealmente mais eficiente quando há pelo menos 2 cpus por nó.
Este resultado é armazenado em cache entre as chamadas. Se você deseja sobrescrevê-lo, use accelerate.utils.environment.override_numa_afifnity.
accelerate.utils.environment.override_numa_affinity
< source >( local_process_index: intverbose: bool | None = None )
Substitui qualquer afinidade NUMA definida para o processo atual. Isso é muito oneroso e requer recalcular a afinidade a ser definida; idealmente, você deve usar utils.environment.set_numa_affinity em vez disso.
Decorator para limpar as variáveis de ambiente do accelerate definidas pela classe ou função decorada.
Em algumas circunstâncias, a chamada de determinadas classes ou funções pode resultar em variáveis de ambiente do accelerate sendo definidas e não limpas em seguida. Como exemplo, ao chamar:
TrainingArguments(fp16=True, …)
A seguinte variável de ambiente será definida:
ACCELERATE_MIXED_PRECISION=fp16
Isso pode afetar o código subsequente, pois a variável de ambiente tem precedência sobre TrainingArguments(fp16=False). Isso é especialmente relevante para testes unitários, onde queremos evitar que os testes individuais tenham efeitos colaterais uns nos outros. Decore a função de teste unitário ou a classe inteira com este decorador para garantir que, após cada teste, as variáveis de ambiente sejam limpas. Isso funciona tanto para unittest.TestCase quanto para classes normais (pytest); também funciona ao decorar a classe pai.
Memória
accelerate.find_executable_batch_size
< source >( function: callable | None = Nonestarting_batch_size: int = 128reduce_batch_size_fn: callable | None = None )
Parâmetros
- function (
callable, opcional) — Uma função para encapsular - starting_batch_size (
int, opcional) — O tamanho do lote a ser tentado para caber na memória - reduce_batch_size_fn (
callable, opcional) — Uma função para determinar o novo tamanho de lote após um erro de memória insuficiente. Se não for fornecida, o tamanho do lote é multiplicado por 0,9 a cada falha. A função não recebe argumentos e deve retornar o novo tamanho de lote (reduzido) como umint.
Um decorador básico que tentará executar function. Se falhar devido a exceções relacionadas a falta de memória ou
CUDNN, o tamanho do lote é multiplicado por 0,9 e passado para function
function deve receber um parâmetro batch_size como seu primeiro argumento.
Modelagem
Essas utilidades estão relacionadas à interação com modelos do PyTorch
Calcula o tamanho total do modelo e de sua camada mais larga
accelerate.utils.compute_module_sizes
< source >( model: Moduledtype: str | torch.device | None = Nonespecial_dtypes: dict[str, str | torch.device] | None = Nonebuffers_only: bool = False )
Calcule o tamanho de cada submódulo de um modelo específico.
accelerate.utils.extract_model_from_parallel
< source >( modelkeep_fp32_wrapper: bool = Truekeep_torch_compile: bool = Truerecursive: bool = False ) → torch.nn.Module
Parâmetros
- model (
torch.nn.Module) — O modelo a ser extraído. - keep_fp32_wrapper (
bool, opcional) — Se deve remover os hooks de precisão mista do modelo. - keep_torch_compile (
bool, opcional) — Se deve desembrulhar o modelo compilado. - recursive (
bool, opcional, padrãoFalse) — Se deve extrair recursivamente todos os casos demodule.moduledemodel, bem como desembrulhar recursivamente as subcamadas filhas, e não apenas os contêineres distribuídos de nível superior.
Retorna
torch.nn.Module
O modelo extraído.
Extraia um modelo de seus contêineres distribuídos.
accelerate.utils.get_balanced_memory
< source >( 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) — O modelo a ser analisado. - max_memory (
Dict, opcional) — Um dicionário de identificador de dispositivo para memória máxima. Se não definido, o padrão será a memória máxima disponível. Exemplo:max_memory={0: "1GB"}. - no_split_module_classes (
List[str], opcional) — Uma lista de nomes de classes de camadas que nunca devem ser divididas entre dispositivos (por exemplo, qualquer camada que tenha uma conexão residual). - dtype (
stroutorch.dtype, opcional) — Se fornecido, os pesos serão convertidos para esse tipo ao serem carregados. - special_dtypes (
Dict[str, Union[str, torch.device]], opcional) — Se fornecido, dtypes especiais a considerar para alguns pesos específicos (substituirá o dtype usado como padrão para todos os pesos). - low_zero (
bool, opcional) — Minimiza o número de pesos na GPU 0, o que é conveniente quando ela é usada para outras operações (como a função generate do Transformers).
Calcule um dicionário max_memory para infer_auto_device_map() que equilibrará o uso de cada GPU disponível.
Todo o cálculo é realizado analisando os tamanhos e os dtypes dos parâmetros do modelo. Como resultado, o modelo pode estar no dispositivo meta (como estaria se fosse inicializado dentro do gerenciador de contexto
init_empty_weights).
accelerate.utils.get_max_layer_size
< source >( modules: list[tuple[str, torch.nn.Module]]module_sizes: dict[str, int]no_split_module_classes: list[str] ) → Tuple[int, List[str]]
Parâmetros
- modules (
List[Tuple[str, torch.nn.Module]]) — A lista de módulos nomeados onde queremos determinar o tamanho máximo da camada. - module_sizes (
Dict[str, int]) — Um dicionário que mapeia cada nome de camada para seu tamanho (gerado porcompute_module_sizes). - no_split_module_classes (
List[str]) — Uma lista de nomes de classes para camadas que não devem ser divididas.
Retorna
Tuple[int, List[str]]
O tamanho máximo de uma camada com a lista de nomes de camadas que realizam esse tamanho máximo.
Função utilitária que varre uma lista de módulos nomeados e retorna o tamanho máximo usado por uma camada completa. A definição de uma camada é:
- um módulo sem filhos diretos (apenas parâmetros e buffers)
- um módulo cujo nome de classe está na lista
no_split_module_classes
accelerate.infer_auto_device_map
< source >( 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) — O modelo a ser analisado. - max_memory (
Dict, opcional) — Um dicionário de identificador de dispositivo para memória máxima. Se não definido, o padrão será a memória máxima disponível. Exemplo:max_memory={0: "1GB"}. - no_split_module_classes (
List[str], opcional) — Uma lista de nomes de classes de camadas que nunca devem ser divididas entre dispositivos (por exemplo, qualquer camada que tenha uma conexão residual). - dtype (
stroutorch.dtype, opcional) — Se fornecido, os pesos serão convertidos para esse tipo ao serem carregados. - special_dtypes (
Dict[str, Union[str, torch.device]], opcional) — Se fornecido, dtypes especiais a considerar para alguns pesos específicos (substituirá o dtype usado como padrão para todos os pesos). - verbose (
bool, opcional, padrãoFalse) — Se deve ou não fornecer declarações de depuração conforme a função constrói o device_map. - clean_result (
bool, opcional, padrãoTrue) — Limpa o device_map resultante agrupando todos os submódulos que ficam no mesmo dispositivo. - offload_buffers (
bool, opcional, padrãoFalse) — Nas camadas que são descarregadas na CPU ou no disco rígido, se os buffers devem ser descarregados junto com os parâmetros. - fallback_allocation (
bool, opcional, padrãoFalse) — Quando a alocação regular falha, tenta alocar um módulo que caiba no limite de tamanho usando BFS.
Calcule um mapa de dispositivos para um modelo específico, dando prioridade às GPUs, depois faça o offload para a CPU e, por fim, para o disco, de modo que:
- não excedemos a memória disponível de nenhuma das GPUs.
- se o offload para a CPU for necessário, sempre haverá espaço disponível na GPU 0 para colocar de volta a camada offloadada na CPU que tem o maior tamanho.
- se o offload para a CPU for necessário, não excedemos a RAM disponível na CPU.
- se o offload para o disco for necessário, sempre haverá espaço disponível na CPU para colocar de volta a camada offloadada no disco que tem o maior tamanho.
Todo o cálculo é realizado analisando os tamanhos e os dtypes dos parâmetros do modelo. Como resultado, o modelo pode estar no dispositivo meta (como estaria se fosse inicializado dentro do gerenciador de contexto
init_empty_weights).
accelerate.load_checkpoint_in_model
< source >( 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) — O modelo no qual queremos carregar um checkpoint. - checkpoint (
strouos.PathLike) — O checkpoint de pasta a ser carregado. Pode ser:- um caminho para um arquivo contendo um state dict completo do modelo
- um caminho para um arquivo
.jsoncontendo o índice de um checkpoint fragmentado - um caminho para uma pasta contendo um arquivo
.index.jsonúnico e os shards de um checkpoint. - um caminho para uma pasta contendo um arquivo pytorch_model.bin ou model.safetensors único.
- device_map (
Dict[str, Union[int, str, torch.device]], opcional) — Um mapa que especifica para onde cada submódulo deve ser enviado. Não é necessário refinar para cada nome de parâmetro/buffer, pois, uma vez que um determinado nome de módulo esteja incluído, todos os seus submódulos serão enviados para o mesmo dispositivo. - offload_folder (
strouos.PathLike, opcional) — Se odevice_mapcontiver qualquer valor"disk", a pasta onde os pesos serão descarregados. - dtype (
stroutorch.dtype, opcional) — Se fornecido, os pesos serão convertidos para esse tipo ao serem carregados. - offload_state_dict (
bool, opcional, padrãoFalse) — SeTrue, o state dict da CPU será temporariamente offloadado no disco rígido para evitar a falta de RAM na CPU caso o peso do state dict da CPU + o maior shard não caiba. - offload_buffers (
bool, opcional, padrãoFalse) — Se os buffers devem ser incluídos nos pesos descarregados para o disco. - keep_in_fp32_modules(
List[str], opcional) — Uma lista dos módulos que mantemos no dtypetorch.float32. - offload_8bit_bnb (
bool, opcional) — Se deve ou não habilitar o offload de módulos de 8 bits para cpu/disco. - strict (
bool, opcional, padrãoFalse) — Se deve aplicar estritamente que as chaves no state_dict do checkpoint correspondam às chaves do state_dict do modelo. - full_state_dict (
bool, opcional, padrãoTrue) — se definido comoTrue, todos os tensors no state_dict carregado serão reunidos. Não haverá ShardedTensor nem DTensor no state_dict carregado. - broadcast_from_rank0 (
False, opcional, padrãoFalse) — quando a opção éTrue, umProcessGroupdistribuído deve ser inicializado. O rank0 deve receber um state_dict completo e fará o broadcast dos tensors no state_dict um a um para os outros ranks. Os outros ranks receberão os tensors e farão o sharding (se aplicável) de acordo com os shards locais no modelo.
Carrega um checkpoint (possivelmente fragmentado) dentro de um modelo, potencialmente enviando os pesos para um dispositivo específico à medida que são carregados.
Depois de carregar em vários dispositivos, você ainda precisa chamar dispatch_model() no seu modelo para que ele possa ser executado. Para agrupar o carregamento do checkpoint e o despacho em uma única chamada, use load_checkpoint_and_dispatch().
accelerate.utils.load_offloaded_weights
< source >( modelindexoffload_folder )
Carrega os pesos da pasta de offload para o modelo.
accelerate.utils.load_state_dict
< source >( checkpoint_filedevice_map = None )
Parâmetros
- checkpoint_file (
str) — O caminho para o checkpoint a ser carregado. - device_map (
Dict[str, Union[int, str, torch.device]], opcional) — Um mapa que especifica para onde cada submódulo deve ser enviado. Não é necessário refinar para cada nome de parâmetro/buffer, pois, uma vez que um determinado nome de módulo esteja incluído, todos os seus submódulos serão enviados para o mesmo dispositivo.
Carrega um checkpoint de um arquivo específico. Se o checkpoint estiver no formato safetensors e um mapa de dispositivos for passado, os pesos podem ser carregados rapidamente diretamente na GPU.
accelerate.utils.offload_state_dict
< source >( save_dir: str | os.PathLikestate_dict: dict[str, torch.Tensor] )
Desloque um state dict para uma pasta específica.
accelerate.utils.retie_parameters
< source >( modeltied_params )
Retie parâmetros vinculados em um modelo dado se o vínculo foi quebrado (por exemplo, ao adicionar hooks).
accelerate.utils.set_module_tensor_to_device
< source >( 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) — O módulo no qual reside o tensor que queremos mover. - tensor_name (
str) — O nome completo do parâmetro/buffer. - device (
int,stroutorch.device) — O dispositivo no qual definir o tensor. - value (
torch.Tensor, opcional) — O valor do tensor (útil ao passar do dispositivo meta para qualquer outro dispositivo). - dtype (
torch.dtype, opcional) — Se for passado, o valor do parâmetro será convertido para estedtype. Caso contrário,valueserá convertido para o dtype do parâmetro existente no modelo. - fp16_statistics (
torch.HalfTensor, opcional) — A lista de estatísticas fp16 a ser definida no módulo, usada para serialização de modelos de 8 bits. - tied_params_map (Dict[int, Dict[torch.device, torch.Tensor]], opcional, padrão
None) — Um mapa de ponteiros de dados atuais para dicionários de dispositivos para pesos vinculados já despachados. Para um determinado dispositivo de execução, este parâmetro é útil para reutilizar o primeiro ponteiro disponível de um peso compartilhado no dispositivo para todos os outros, em vez de duplicar a memória. - non_blocking (
bool, opcional, padrãoFalse) — SeTrue, a transferência para o dispositivo será assíncrona em relação ao host, se possível. - clear_cache (
bool, opcional, padrãoTrue) — Se deve ou não limpar o cache do dispositivo após definir o tensor no dispositivo.
Uma função auxiliar para definir um tensor específico (parâmetro ou buffer) de um módulo em um dispositivo específico (observe que executar param.to(device) cria um novo tensor não vinculado ao parâmetro, motivo pelo qual precisamos desta função).
accelerate.utils.get_module_children_bottom_up
< source >( model: Modulereturn_fqns: bool = False ) → list[torch.nn.Module]
Percorra o modelo em ordem de baixo para cima e retorne os módulos filhos nessa ordem.
Paralelo
Isso inclui utilitários gerais que devem ser usados ao trabalhar em paralelo.
accelerate.utils.extract_model_from_parallel
< source >( modelkeep_fp32_wrapper: bool = Truekeep_torch_compile: bool = Truerecursive: bool = False ) → torch.nn.Module
Parâmetros
- model (
torch.nn.Module) — O modelo a ser extraído. - keep_fp32_wrapper (
bool, opcional) — Se deve remover os hooks de precisão mista do modelo. - keep_torch_compile (
bool, opcional) — Se deve desembrulhar o modelo compilado. - recursive (
bool, opcional, padrãoFalse) — Se deve extrair recursivamente todos os casos demodule.moduledemodel, bem como desembrulhar recursivamente as subcamadas filhas, e não apenas os contêineres distribuídos de nível superior.
Retorna
torch.nn.Module
O modelo extraído.
Extraia um modelo de seus contêineres distribuídos.
accelerate.utils.save
< source >( objfsave_on_each_node: bool = Falsesafe_serialization: bool = False )
Parâmetros
- obj — Os dados a serem salvos
- f — O arquivo (ou objeto semelhante a arquivo) a ser usado para salvar os dados
- save_on_each_node (
bool, opcional, padrãoFalse) — Se deve salvar apenas no processo principal global - safe_serialization (
bool, opcional, padrãoFalse) — Se deve salvarobjusandosafetensorsou da maneira tradicional do PyTorch (que usapickle).
Salve os dados no disco. Use no lugar de torch.save().
accelerate.utils.load
< source >( fmap_location = None**kwargs )
Substituto compatível de torch.load() que permite o uso de weights_only se a versão do torch for 2.4.0 ou superior. Caso contrário, o parâmetro será ignorado.
Também será adicionada (e depois removida) uma exceção para arrays do numpy
Introduz um ponto de bloqueio no script, garantindo que todos os processos tenham alcançado esse ponto antes de continuar.
Certifique-se de que todos os processos chegarão a esta instrução, caso contrário, um dos seus processos ficará pendurado para sempre.
Aleatório
Essas utilidades se relacionam com a configuração e a sincronização de todos os estados aleatórios.
accelerate.utils.set_seed
< source >( seed: intdevice_specific: bool = Falsedeterministic: bool = False )
Parâmetros
- seed (
int) — A semente a ser definida. - device_specific (
bool, opcional, padrãoFalse) — Se deve diferenciar levemente a semente em cada dispositivo comself.process_index. - deterministic (
bool, opcional, padrãoFalse) — Se deve usar algoritmos determinísticos quando disponíveis. Pode deixar o treinamento mais lento.
Função auxiliar para comportamento reprodutível, definindo a semente em random, numpy, torch.
accelerate.utils.synchronize_rng_state
< source >( rng_type: str | accelerate.utils.dataclasses.RNGTypegenerator: torch.Generator | None = None )
Sincronize um RNG embutido ou o RNG do acelerador atual, identificado pelo tipo de dispositivo.
accelerate.synchronize_rng_states
< source >( rng_types: list[str | accelerate.utils.dataclasses.RNGType]generator: torch.Generator | None = None )
PyTorch XLA
Isso inclui utilitários que são úteis ao usar o PyTorch com XLA.
accelerate.utils.install_xla
< source >( upgrade: bool = False )
Função auxiliar para instalar as rodas xla apropriadas com base na versão do torch no Google Colaboratory.
Carregando pesos do modelo
Isso inclui utilitários que são úteis para carregar checkpoints.
accelerate.load_checkpoint_in_model
< source >( 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) — O modelo no qual queremos carregar um checkpoint. - checkpoint (
strouos.PathLike) — O checkpoint de pasta a ser carregado. Pode ser:- um caminho para um arquivo contendo um state dict completo do modelo
- um caminho para um arquivo
.jsoncontendo o índice de um checkpoint fragmentado - um caminho para uma pasta contendo um arquivo
.index.jsonúnico e os shards de um checkpoint. - um caminho para uma pasta contendo um arquivo pytorch_model.bin ou model.safetensors único.
- device_map (
Dict[str, Union[int, str, torch.device]], opcional) — Um mapa que especifica para onde cada submódulo deve ser enviado. Não é necessário refinar para cada nome de parâmetro/buffer, pois, uma vez que um determinado nome de módulo esteja incluído, todos os seus submódulos serão enviados para o mesmo dispositivo. - offload_folder (
strouos.PathLike, opcional) — Se odevice_mapcontiver qualquer valor"disk", a pasta onde os pesos serão descarregados. - dtype (
stroutorch.dtype, opcional) — Se fornecido, os pesos serão convertidos para esse tipo ao serem carregados. - offload_state_dict (
bool, opcional, padrãoFalse) — SeTrue, o state dict da CPU será temporariamente offloadado no disco rígido para evitar a falta de RAM na CPU caso o peso do state dict da CPU + o maior shard não caiba. - offload_buffers (
bool, opcional, padrãoFalse) — Se os buffers devem ser incluídos nos pesos descarregados para o disco. - keep_in_fp32_modules(
List[str], opcional) — Uma lista dos módulos que mantemos no dtypetorch.float32. - offload_8bit_bnb (
bool, opcional) — Se deve ou não habilitar o offload de módulos de 8 bits para cpu/disco. - strict (
bool, opcional, padrãoFalse) — Se deve aplicar estritamente que as chaves no state_dict do checkpoint correspondam às chaves do state_dict do modelo. - full_state_dict (
bool, opcional, padrãoTrue) — se definido comoTrue, todos os tensors no state_dict carregado serão reunidos. Não haverá ShardedTensor nem DTensor no state_dict carregado. - broadcast_from_rank0 (
False, opcional, padrãoFalse) — quando a opção éTrue, umProcessGroupdistribuído deve ser inicializado. O rank0 deve receber um state_dict completo e fará o broadcast dos tensors no state_dict um a um para os outros ranks. Os outros ranks receberão os tensors e farão o sharding (se aplicável) de acordo com os shards locais no modelo.
Carrega um checkpoint (possivelmente fragmentado) dentro de um modelo, potencialmente enviando os pesos para um dispositivo específico à medida que são carregados.
Depois de carregar em vários dispositivos, você ainda precisa chamar dispatch_model() no seu modelo para que ele possa ser executado. Para agrupar o carregamento do checkpoint e o despacho em uma única chamada, use load_checkpoint_and_dispatch().
Quantização
Isso inclui utilitários que são úteis para quantizar o modelo.
accelerate.utils.load_and_quantize_model
< source >( 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. O modelo pode já estar carregado ou no dispositivo meta - bnb_quantization_config (
BnbQuantizationConfig) — Os parâmetros de quantização bitsandbytes - weights_location (
strouos.PathLike) — A pasta weights_location a ser carregada. Pode ser:- um caminho para um arquivo contendo um state dict completo do modelo
- um caminho para um arquivo
.jsoncontendo o índice de um checkpoint fragmentado - um caminho para uma pasta contendo um arquivo
.index.jsonúnico e os shards de um checkpoint. - um caminho para uma pasta contendo um arquivo pytorch_model.bin único.
- device_map (
Dict[str, Union[int, str, torch.device]], opcional) — Um mapa que especifica para onde cada submódulo deve ser enviado. Não é necessário refinar para cada nome de parâmetro/buffer, pois, uma vez que um determinado nome de módulo esteja incluído, todos os seus submódulos serão enviados para o mesmo dispositivo. - no_split_module_classes (
List[str], opcional) — Uma lista de nomes de classes de camadas que nunca devem ser divididas entre dispositivos (por exemplo, qualquer camada que tenha uma conexão residual). - max_memory (
Dict, opcional) — Um dicionário de identificador de dispositivo para memória máxima. Se não definido, o padrão será a memória máxima disponível. - offload_folder (
strouos.PathLike, opcional) — Se odevice_mapcontiver qualquer valor"disk", a pasta onde os pesos serão descarregados. - offload_state_dict (
bool, opcional, padrãoFalse) — SeTrue, o state dict da CPU será temporariamente offloadado no disco rígido para evitar a falta de RAM na CPU caso o peso do state dict da CPU + o maior shard não caiba.
Retorna
torch.nn.Module
O modelo quantizado
Esta função quantiza o modelo de entrada com a configuração associada passada em bnb_quantization_config. Se o
modelo estiver no dispositivo meta, carregaremos e distribuiremos os pesos de acordo com o device_map passado. Se o
modelo já estiver carregado, quantizaremos o modelo e o colocaremos na GPU,