Accelerate documentation

Funções e classes utilitárias

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

and get access to the augmented documentation experience

to get started

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

classe accelerate.utils.ComputeEnvironment

< >

( *values )

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.

classe accelerate.DistributedType

< >

( *values )

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.

classe accelerate.utils.DynamoBackend

< >

( *values )

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.

classe accelerate.utils.LoggerType

< >

( *values )

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

classe accelerate.utils.PrecisionType

< >

( *values )

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

classe accelerate.utils.RNGType

< >

( *values )

classe accelerate.utils.SageMakerDistributedType

< >

( *values )

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

< >

( 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.

Exemplo:

from accelerate import Accelerator
from accelerate.utils import AutocastKwargs

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

classe 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 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.

Exemplo:

from accelerate import Accelerator
from accelerate.utils import DistributedDataParallelKwargs

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

classe accelerate.GradScalerKwargs

< >

( 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.

Exemplo:

from accelerate import Accelerator
from accelerate.utils import GradScalerKwargs

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

classe accelerate.InitProcessGroupKwargs

< >

( 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.

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

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

classe accelerate.utils.KwargsHandler

< >

( )

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

to_kwargs

< >

( )

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

< >

( 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ão None) — Caminho para o arquivo de configuração do DeepSpeed, um dicionário ou um objeto da classe accelerate.utils.deepspeed.HfDeepSpeedConfig.
  • gradient_accumulation_steps (int, padrão None) — Número de passos para acumular gradientes antes de atualizar os estados do otimizador. Se não for definido, usará o valor do Accelerator diretamente.
  • gradient_clipping (float, padrão None) — Ativa o recorte de gradiente com o valor especificado.
  • zero_stage (int, padrão None) — 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ão True) — Se ambos os dataloaders de treino e avaliação forem especificados, este parâmetro determinará o train_batch_size.
  • offload_optimizer_device (str, padrão None) — 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ão None) — As opções possíveis são none|cpu|nvme. Aplicável apenas com ZeRO Stage 3.
  • offload_optimizer_nvme_path (str, padrão None) — As opções possíveis são /nvme|/local_nvme. Aplicável apenas com ZeRO Stage 3.
  • offload_param_nvme_path (str, padrão None) — As opções possíveis são /nvme|/local_nvme. Aplicável apenas com ZeRO Stage 3.
  • zero3_init_flag (bool, padrão None) — Indica se o modelo de 16 bits deve ser salvo. Aplicável apenas com ZeRO Stage-3.
  • zero3_save_16bit_model (bool, padrão None) — 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ão None) — 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

< >

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

Processe a configuração do DeepSpeed com os valores dos kwargs.

selecionar

< >

( _from_accelerator_state: bool = False )

Define o HfDeepSpeedWeakref para usar a configuração atual do plugin deepspeed

classe 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, padrão 1) — 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 uma str ou uma instância de torch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy. Está obsoleta em favor de reshard_after_forward.
  • reshard_after_forward (Union[str, torch.distributed.fsdp.ShardingStrategy, bool], padrão 'FULL_SHARD' para fsdp_version=1 e True para fsdp_version=2) — Estratégia de sharding a ser utilizada. Deve ser um bool se fsdp_version estiver definido como 2, caso contrário, um str ou uma instância de torch.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 uma str ou uma instância de torch.distributed.fsdp.fully_sharded_data_parallel.BackwardPrefetch.
  • mixed_precision_policy (Optional[Union[dict, str, torch.distributed.fsdp.MixedPrecision, torch.distributed.fsdp.MixedPrecisionPolicy]], padrão None) — Uma configuração para habilitar o treinamento com precisão mista usando FullyShardedDataParallel. Se um dict for passado, ele deve ter as seguintes chaves: param_dtype, reduce_dtype e buffer_dtype. Pode ser uma instância de torch.distributed.fsdp.MixedPrecisionPolicy se fsdp_version estiver definido como 2. Se um str for passado, ele deve ser um dos seguintes valores: fp8, fp16, bf16, fp32, e é usado para definir param_dtype, reduce_dtype e 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], padrão False) — Se os parâmetros devem ser transferidos para a CPU. Deve ser um bool ou uma instância de torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffload ou torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffloadPolicy se fsdp_version estiver definido como 2.
  • ignored_modules (Optional[Union[Iterable[torch.nn.Module], str]], padrão None) — 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. Se fsdp_version estiver 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 de full_state_dict, local_state_dict ou sharded_state_dict.
  • state_dict_config (Optional[Union[torch.distributed.fsdp.FullStateDictConfig, torch.distributed.fsdp.ShardedStateDictConfig], padrão None) — Configuração do state dict a ser utilizada. É determinada com base no state_dict_type caso não seja fornecida.
  • optim_state_dict_config (Optional[Union[torch.distributed.fsdp.FullOptimStateDictConfig, torch.distributed.fsdp.ShardedOptimStateDictConfig], padrão None) — Configuração do state dict do otimizador a ser usada. É determinada com base no state_dict_type caso não seja fornecida.
  • limit_all_gathers (bool, padrão True) — 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ão False) — Se deve usar os parâmetros originais para o otimizador.
  • param_init_fn (Optional[Callable[[torch.nn.Module], None], padrão None) — Um Callable[torch.nn.Module] -> None que especifica como os módulos que estão atualmente no dispositivo meta devem ser inicializados em um dispositivo real. Aplicável apenas quando sync_module_states é True. Por padrão, é um lambda que chama to_empty no módulo.
  • sync_module_states (bool, padrão False) — 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 que cpu_ram_efficient_loading seja True, caso em que será habilitado forçadamente.
  • forward_prefetch (bool, padrão False) — 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ão False) — 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ão None) — 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_states precisa ser True.
  • transformer_cls_names_to_wrap (Optional[List[str]], padrão None) — Uma lista de nomes de classes de camadas de transformer para envolver. Aplicável apenas quando auto_wrap_policy é transformer_based_wrap.
  • min_num_params (Optional[int], padrão None) — O número mínimo de parâmetros que um módulo deve ter para ser envolvido. Aplicável apenas quando auto_wrap_policy é size_based_wrap.

Este plugin é usado para habilitar o paralelismo totalmente fragmentado de dados.

set_auto_wrap_policy

< >

( model )

Dado model, cria um auto_wrap_policy com base na política passada e se podemos usar o transformer_cls_to_wrap

set_mixed_precision

< >

( mixed_precisionbuffer_autocast = Falseoverride = False )

Define a política de precisão mista para FSDP

set_state_dict_type

< >

( state_dict_type = None )

Defina a configuração do state dict com base no StateDictType.

validate_mixed_precision_policy

< >

( )

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

< >

( 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ão True) — Se deve ajustar os passos do agendador para levar em conta o número de passos acumulados. Deve ser True se o agendador utilizado não foi ajustado para a acumulação de gradientes.
  • sync_with_dataloader (bool, opcional, padrão True) — 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 como True pode 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.

Exemplo:

from accelerate.utils import GradientAccumulationPlugin

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

classe 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[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ão None) — Grau de paralelismo de tensor.
  • pp_degree (int, padrão None) — Grau de paralelismo de pipeline.
  • num_micro_batches (int, padrão None) — Número de micro-lotes.
  • gradient_clipping (float, padrão None) — Valor de recorte de gradiente baseado na norma L2 global (0 para desativar).
  • sequence_parallelism (bool, padrão None) — Ativa o paralelismo de sequência.
  • recompute_activations (bool, padrão None) — Ativa a recomputação seletiva de ativações.
  • use_distributed_optimizer (bool, padrão None) — Ativa o otimizador distribuído.
  • pipeline_model_parallel_split_rank (int, padrão None) — Rank onde o codificador e o decodificador devem ser separados.
  • num_layers_per_virtual_pipeline_stage (int, padrão None) — Número de camadas por estágio de pipeline virtual.
  • is_train_batch_min (str, padrão True) — Se ambos os dataloaders de treino e avaliação forem especificados, este parâmetro determinará o micro_batch_size.
  • train_iters (int, padrão None) — Número total de amostras para treinar em todas as execuções de treinamento. Observe que, ao usar MegatronLMDummyScheduler, deve-se fornecer train-iters ou train-samples.
  • train_samples (int, padrão None) — Número total de amostras para treinar em todas as execuções de treinamento. Observe que, ao usar MegatronLMDummyScheduler, 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ão None) — Coeficiente inicial de decaimento de peso para regularização L2.
  • end_weight_decay (float, padrão None) — 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ão None) — 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ão None) — Número de amostras para o decaimento da taxa de aprendizado. Se for None, o padrão é train_samples.
  • lr_warmup_iters (int, padrão None) — Número de iterações para o aquecimento linear da taxa de aprendizado.
  • lr_warmup_samples (int, padrão None) — Número de amostras para o aquecimento linear da taxa de aprendizado.
  • lr_warmup_fraction (float, padrão None) — Fração de lr-warmup-(iters/samples) para aquecer linearmente a taxa de aprendizado.
  • min_lr (float, padrão 0) — Valor mínimo para a taxa de aprendizado. O agendador limita os valores abaixo desse limite.
  • consumed_samples (List, padrão None) — Número de amostras consumidas na mesma ordem dos dataloaders para a chamada de accelerator.prepare.
  • no_wd_decay_cond (Optional, padrão None) — Condição para desativar o decaimento de peso.
  • scale_lr_cond (Optional, padrão None) — Condição para escalar a taxa de aprendizado.
  • lr_mult (float, padrão 1.0) — Multiplicador da taxa de aprendizado.
  • megatron_dataset_flag (bool, padrão False) — Se o formato do conjunto de dados segue o formato Indexed/Cached/MemoryMapped do Megatron-LM.
  • seq_length (int, padrão None) — Comprimento máximo da sequência a ser processado.
  • encoder_seq_length (int, padrão None) — Comprimento máximo da sequência a ser processada pelo codificador.
  • decoder_seq_length (int, padrão None) — Comprimento máximo da sequência a ser processada para o decodificador.
  • tensorboard_dir (str, padrão None) — Caminho para salvar os logs do tensorboard.
  • set_all_logging_options (bool, padrão False) — Se deve definir todas as opções de log.
  • eval_iters (int, padrão 100) — Número de iterações a serem executadas para a validação/teste de avaliação.
  • eval_interval (int, padrão 1000) — Intervalo entre a execução da avaliação no conjunto de validação.
  • return_logits (bool, padrão False) — Se deve retornar os logits do modelo.
  • custom_train_step_class (Optional, padrão None) — Classe de etapa de treinamento personalizada.
  • custom_train_step_kwargs (Optional, padrão None) — Kwargs personalizados para o passo de treinamento.
  • custom_model_provider_function (Optional, padrão None) — Função de provedor de modelo personalizada.
  • custom_prepare_model_function (Optional, padrão None) — Função personalizada para preparar o modelo.
  • custom_megatron_datasets_provider_function (Optional, padrão None) — Função de provedor de conjuntos de dados de treino, validação e teste do Megatron personalizada.
  • custom_get_batch_function (Optional, padrão None) — Função personalizada para obter um lote.
  • custom_loss_function (Optional, padrão None) — Função de perda personalizada.
  • other_megatron_args (Optional, padrão None) — 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

< >

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

Parâmetros

  • backend (DynamoBackend, padrão None) — Um backend Dynamo válido. Consulte https://pytorch.org/docs/stable/torch.compiler.html para mais detalhes.
  • mode (str, padrão None) — As opções possíveis são ‘default’, ‘reduce-overhead’ ou ‘max-autotune’.
  • fullgraph (bool, padrão None) — Se é aceitável dividir o modelo em vários subgrafos.
  • dynamic (bool, padrão None) — Se deve usar forma dinâmica para o tracing.
  • options (Any, padrão None) — Um dicionário de opções para passar ao backend.
  • disable (bool, padrão False) — Torna o torch.compile() uma operação nula para testes
  • use_regional_compilation (bool, padrão None) — 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, em GPT2LMHeadModel, o bloco/classe repetido é GPT2Block, e pode ser acessado como model.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

< >

( 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ão False) — Ativa a quantização de 8 bits.
  • llm_int8_threshold (float, padrão 6.0) — Valor do limiar do outliner. Relevante apenas quando load_in_8bit=True.
  • load_in_4bit (bool, padrão False) — Ativa a quantização em 4 bits.
  • bnb_4bit_quant_type (str, padrão fp4) — Define o tipo de dados de quantização nas camadas bnb.nn.Linear4Bit. As opções são {‘fp4’,‘np4’}.
  • bnb_4bit_use_double_quant (bool, padrão False) — 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ão fp16) — 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ão None) — Isso define o dtype das camadas restantes não quantizadas. A biblioteca bitsandbytes sugere definir o valor como torch.float16 para modelos de 8 bits e usar o mesmo dtype do dtype de computação para modelos de 4 bits.
  • skip_modules (List[str], padrão None) — 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ão None) — Uma lista explícita dos módulos que não são quantizados. Eles são mantidos em torch.float32.

Um plugin para habilitar a quantização de 4 bits e 8 bits do BitsAndBytes

classe 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, padrão False) — Se o acelerador deve ou não dividir os lotes gerados pelos dataloaders entre os dispositivos. Se True, o tamanho real do lote usado será o mesmo em qualquer tipo de processo distribuído, mas deve ser um múltiplo exato de num_processes que você está usando. Se False, o tamanho real do lote usado será o definido no seu script multiplicado pelo número de processos.
  • dispatch_batches (bool, padrão None) — Se definido como True, 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á True para DataLoader cujo conjunto de dados subjacente é um IterableDataset, False caso contrário.
  • even_batches (bool, padrão True) — Se definido como True, 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ão False) — 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ão None) — A semente a ser usada para o gerador subjacente ao utilizar use_seedable_sampler. Se None, o gerador usará a semente padrão atual do torch.
  • non_blocking (bool, padrão False) — Se definido como True, 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 tenha pin_memory definido como True para funcionar corretamente.
  • use_stateful_dataloader (bool, padrão False) — Se definido como True, o dataloader preparado pelo Accelerator será baseado em torchdata.StatefulDataLoader. Isso requer a instalação da versão 0.8.0 ou superior do torchdata que suporte StatefulDataLoader.

Configuração para itens relacionados ao dataloader ao chamar accelerator.prepare.

classe 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, padrão None) — Um caminho para um diretório de armazenamento de dados.
  • logging_dir (str, padrão None) — 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ão False) — Se os estados salvos devem ser nomeados automaticamente de forma iterativa.
  • total_limit (int, padrão None) — O número máximo de estados salvos no total a serem mantidos.
  • iteration (int, padrão 0) — A iteração de salvamento atual.
  • save_on_each_node (bool, padrão False) — 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.

set_directories

< >

( project_dir: str | None = None )

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

< >

( tensorfrom_process: int = 0 )

Parâmetros

  • tensor (lista/tupla/dicionário aninhado de torch.Tensor) — Os dados a serem coletados.
  • from_process (int, opcional, padrão 0) — O processo do qual os dados serão enviados

Dissemine recursivamente o tensor em uma lista/tupla/dicionário aninhado de tensors para todos os dispositivos.

accelerate.utils.broadcast_object_list

< >

( object_listfrom_process: int = 0 )

Parâmetros

  • object_list (lista de objetos picklable) — A lista de objetos a serem transmitidos. Esta lista será modificada in place.
  • from_process (int, opcional, padrão 0) — O processo de onde os dados serão enviados.

Broadcast uma lista de objetos picklable de um processo para os outros.

accelerate.utils.concatenate

< >

( datadim = 0 )

Parâmetros

  • data (lista/tupla/dicionário aninhado de listas de tensores torch.Tensor) — Os dados a serem concatenados.
  • dim (int, opcional, padrão 0) — A dimensão na qual concatenar.

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_outputs_to_fp32

< >

( model_forward )

accelerate.utils.convert_to_fp32

< >

( tensor )

Parâmetros

  • tensor (lista/tupla/dicionário aninhado de torch.Tensor) — Os dados a serem convertidos de FP16/BF16 para FP32.

Converte recursivamente os elementos de listas/tuplas/dicionários aninhados de tensores em precisão FP16/BF16 para FP32.

accelerate.utils.gather

< >

( tensor )

Parâmetros

  • tensor (lista/tupla/dicionário aninhado de torch.Tensor) — Os dados a serem coletados.

Recolher recursivamente um tensor em uma lista/tupla/dicionário aninhado de tensors de todos os dispositivos.

accelerate.utils.gather_object

< >

( object: Any )

Parâmetros

  • object (lista/tupla/dicionário aninhado de objetos picklable) — Os dados a serem reunidos.

Recolher recursivamente um objeto em uma lista/tupela/dicionário aninhado de objetos de todos os dispositivos.

accelerate.utils.get_grad_scaler

< >

( distributed_type: DistributedType = None**kwargs )

Parâmetros

  • distributed_type (DistributedType, opcional, padrão None) — O tipo de ambiente distribuído.
  • kwargs — Argumentos adicionais para o construtor do GradScaler utilizado.

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

< >

( native_amp: bool = Falseautocast_kwargs: AutocastKwargs = None )

Parâmetros

  • native_amp (bool, opcional, padrão é False) — Se a precisão mista está realmente habilitada.

Retorna um gerenciador de contexto para o autocasting de precisão mista

accelerate.utils.listify

< >

( data )

Parâmetros

  • data (lista/tupla/dicionário aninhado de torch.Tensor) — Os dados a partir dos quais converter para números regulares.

Encontra recursivamente tensores em uma lista/tupela/dicionário aninhado e os converte em uma lista de números.

accelerate.utils.pad_across_processes

< >

( 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ão False) — 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

< >

( 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 aplicar func
  • *args — Argumentos posicionais que serão passados para func quando aplicado aos dados descompactados.
  • test_type (Callable[[Any], bool], opcional, padrão is_torch_tensor) — O predicado que decide se func deve ser aplicado a um determinado objeto folha.
  • error_on_other_type (bool, opcional, padrão False) — Se deve retornar um erro ou não se, após descompactar data, obtermos um objeto para o qual test_type retorna False. Se False, a função deixará tais objetos inalterados.
  • **kwargs (argumentos de palavra-chave adicionais, opcional) — Argumentos de palavra-chave que serão passados para func quando 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.

accelerate.utils.reduce

< >

( tensorreduction = 'mean'scale = 1.0 )

Parâmetros

  • tensor (lista/tupla/dicionário aninhado de torch.Tensor) — Os dados a serem reduzidos.
  • reduction (str, opcional, padrão "mean") — Um método de redução. Pode ser “mean”, “sum”, “max” ou “none”
  • scale (float, opcional) — Um valor de escala padrão a ser aplicado após o reduce, válido apenas no XLA.

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

< >

( 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ão False) — Se True, 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 (str ou List[str], opcional) — Uma chave ou lista de chaves em um dicionário tensor cujos valores não devem ser enviados para o device especificado. 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

< >

( datatensor_sliceprocess_index = Nonenum_processes = None )

Parâmetros

  • data (lista/tupla/dicionário aninhado de torch.Tensor) — Os dados a serem fatiados.
  • tensor_slice (slice) — O slice a ser extraído.

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.

accelerate.utils.is_bf16_available

< >

( ignore_tpu = False )

Verifica se o bf16 é suportado, ignorando opcionalmente o TPU

accelerate.utils.is_mps_available

< >

( min_version = '1.12' )

Verifica se o dispositivo MPS está disponível. A versão mínima necessária é 1.12.

accelerate.utils.is_npu_available

( check_device = False )

Verifica se torch_npu está instalado e, potencialmente, se há uma NPU no ambiente

accelerate.utils.is_torch_version

< >

( operation: strversion: str )

Parâmetros

  • operation (str) — Uma representação em string de um operador, como ">" ou "<="
  • version (str) — Uma versão em string do PyTorch

Compara a versão atual do PyTorch com uma referência dada usando uma operação.

accelerate.utils.is_torch_xla_available

( check_is_tpu = Falsecheck_is_gpu = False )

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.

accelerate.utils.is_xpu_available

( check_device = 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

accelerate.utils.patch_environment

< >

( **kwargs )

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.

Exemplo:

>>> 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

< >

( )

Um gerenciador de contexto que limpa temporariamente variáveis de ambiente.

Quando este contexto termina, as variáveis de ambiente anteriores serão restauradas.

Exemplo:

>>> 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, padrão “no”) — Precisão Mista a ser usada. Deve ser um dos valores “no”, “fp16” ou “bf16”
  • save_location (str, opcional, padrão default_json_config_file) — Local de salvamento personalizado opcional. Deve ser passado para --config_file ao usar accelerate 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 ambiente HF_HOME, seguida por accelerate/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.

accelerate.utils.set_numa_affinity

( local_process_index: intverbose: bool | None = None )

Parâmetros

  • local_process_index (int) — O índice do processo atual no servidor atual.
  • verbose (bool, opcional) — Se deve imprimir a nova atribuição de núcleos de CPU para cada processo. Se ACCELERATE_DEBUG_MODE estiver habilitado, o valor padrão será True.

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

< >

( local_process_index: intverbose: bool | None = None )

Parâmetros

  • local_process_index (int) — O índice do processo atual no servidor atual.
  • verbose (bool, opcional) — Se deve registrar a atribuição de cada CPU. Se ACCELERATE_DEBUG_MODE estiver habilitado, o valor padrão será True.

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.

accelerate.utils.purge_accelerate_environment

< >

( func_or_cls )

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

< >

( 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 um int.

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.

Exemplo:

>>> 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)

Modelagem

Essas utilidades estão relacionadas à interação com modelos do PyTorch

accelerate.utils.calculate_maximum_sizes

< >

( model: Module )

Calcula o tamanho total do modelo e de sua camada mais larga

accelerate.utils.compute_module_sizes

< >

( 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

< >

( 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ão False) — Se deve extrair recursivamente todos os casos de module.module de model, 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

< >

( 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 (str ou torch.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

< >

( 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 por compute_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

< >

( 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 (str ou torch.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ão False) — 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ão True) — Limpa o device_map resultante agrupando todos os submódulos que ficam no mesmo dispositivo.
  • offload_buffers (bool, opcional, padrão False) — 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ão False) — 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

< >

( 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 (str ou os.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 .json contendo 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 (str ou os.PathLike, opcional) — Se o device_map contiver qualquer valor "disk", a pasta onde os pesos serão descarregados.
  • dtype (str ou torch.dtype, opcional) — Se fornecido, os pesos serão convertidos para esse tipo ao serem carregados.
  • offload_state_dict (bool, opcional, padrão False) — Se True, 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ão False) — 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 dtype torch.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ão False) — 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ão True) — se definido como True, 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ão False) — quando a opção é True, um ProcessGroup distribuí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

< >

( modelindexoffload_folder )

Parâmetros

  • model (torch.nn.Module) — O modelo para o qual os pesos serão carregados.
  • index (dict) — Um dicionário contendo o nome do parâmetro e seus metadados para cada parâmetro que foi descarregado do modelo.
  • offload_folder (str) — A pasta onde os pesos descarregados são armazenados.

Carrega os pesos da pasta de offload para o modelo.

accelerate.utils.load_state_dict

< >

( 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

< >

( save_dir: str | os.PathLikestate_dict: dict[str, torch.Tensor] )

Parâmetros

  • save_dir (str ou os.PathLike) — O diretório no qual descarregar o state dict.
  • state_dict (Dict[str, torch.Tensor]) — O dicionário de tensores para descarregar.

Desloque um state dict para uma pasta específica.

accelerate.utils.retie_parameters

< >

( modeltied_params )

Parâmetros

  • model (torch.nn.Module) — O modelo no qual reassociar os parâmetros.
  • tied_params (List[List[str]]) — Um mapeamento do nome do parâmetro para o nome do parâmetro vinculado, obtido por find_tied_parameters.

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

< >

( 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, str ou torch.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 este dtype. Caso contrário, value será 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ão False) — Se True, a transferência para o dispositivo será assíncrona em relação ao host, se possível.
  • clear_cache (bool, opcional, padrão True) — 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

< >

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

Parâmetros

  • model (torch.nn.Module) — o modelo do qual se deseja obter os filhos

Retorna

list[torch.nn.Module]

uma lista dos módulos filhos de model em ordem de baixo para cima. O último elemento é o próprio model.

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

< >

( 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ão False) — Se deve extrair recursivamente todos os casos de module.module de model, 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

< >

( 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ão False) — Se deve salvar apenas no processo principal global
  • safe_serialization (bool, opcional, padrão False) — Se deve salvar obj usando safetensors ou da maneira tradicional do PyTorch (que usa pickle).

Salve os dados no disco. Use no lugar de torch.save().

accelerate.utils.load

< >

( fmap_location = None**kwargs )

Parâmetros

  • f — O arquivo (ou objeto semelhante a arquivo) a ser usado para carregar os dados
  • map_location — uma função, torch.device, string ou um dicionário especificando como remapear os locais de armazenamento
  • **kwargs — Argumentos de palavra-chave adicionais para passar para torch.load().

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

accelerate.utils.wait_for_everyone

< >

( )

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

< >

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

Parâmetros

  • seed (int) — A semente a ser definida.
  • device_specific (bool, opcional, padrão False) — Se deve diferenciar levemente a semente em cada dispositivo com self.process_index.
  • deterministic (bool, opcional, padrão False) — 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

< >

( 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

< >

( 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

< >

( upgrade: bool = False )

Parâmetros

  • upgrade (bool, opcional, padrão False) — Se deve atualizar o torch e instalar as rodas mais recentes do torch_xla.

Função auxiliar para instalar as rodas xla apropriadas com base na versão do torch no Google Colaboratory.

Exemplo:

>>> from accelerate.utils import install_xla

>>> install_xla(upgrade=True)

Carregando pesos do modelo

Isso inclui utilitários que são úteis para carregar checkpoints.

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) — O modelo no qual queremos carregar um checkpoint.
  • checkpoint (str ou os.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 .json contendo 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 (str ou os.PathLike, opcional) — Se o device_map contiver qualquer valor "disk", a pasta onde os pesos serão descarregados.
  • dtype (str ou torch.dtype, opcional) — Se fornecido, os pesos serão convertidos para esse tipo ao serem carregados.
  • offload_state_dict (bool, opcional, padrão False) — Se True, 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ão False) — 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 dtype torch.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ão False) — 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ão True) — se definido como True, 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ão False) — quando a opção é True, um ProcessGroup distribuí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

< >

( 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 (str ou os.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 .json contendo 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 (str ou os.PathLike, opcional) — Se o device_map contiver qualquer valor "disk", a pasta onde os pesos serão descarregados.
  • offload_state_dict (bool, opcional, padrão False) — Se True, 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,

Update on GitHub