Hugging Face's logo

Accelerate documentation

Вспомогательные функции и классы

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

and get access to the augmented documentation experience

to get started

Вспомогательные функции и классы

Ниже перечислены различные вспомогательные функции, которые предоставляет 🤗 Accelerate, сгруппированные по сценариям использования.

Константы

Константы, используемые в 🤗 Accelerate для справки

Ниже приведены константы, используемые при обращении к 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

Ниже приведены константы, используемые при обращении к 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"

Классы данных

Это базовые dataclasses, используемые во всех модулях 🤗 Accelerate, которые можно передавать в качестве параметров.

Автономный

Это независимые dataclass, используемые для проверок, например, типа используемой распределённой системы

класс accelerate.utils.ComputeEnvironment

< >

( *values )

Представляет тип вычислительной среды.

Значения:

  • LOCAL_MACHINE — оборудование частного/собственного кластера.
  • AMAZON_SAGEMAKER — Amazon SageMaker в качестве вычислительной среды.

класс accelerate.DistributedType

< >

( *values )

Представляет тип распределённой среды.

Значения:

  • NO — не распределённая среда, только один процесс.
  • MULTI_CPU — распределение по нескольким CPU-узлам.
  • MULTI_GPU — распределённый режим на нескольких GPU.
  • MULTI_MLU — распределённый режим на нескольких MLU.
  • MULTI_SDAA — распределено по нескольким SDAAs.
  • MULTI_MUSA — распределённый режим на нескольких устройствах MUSA.
  • MULTI_NPU — распределённый режим на нескольких NPU.
  • MULTI_XPU — распределённый режим на нескольких XPU.
  • MULTI_HPU — распределённый режим на нескольких HPU.
  • MULTI_NEURON — распределено по нескольким ядрам Neuron.
  • DEEPSPEED — Использование DeepSpeed.
  • FSDP — Использование полностью шардированной параллелизации данных (FSDP).
  • XLA — Использование TorchXLA.
  • MEGATRON_LM — Использование Megatron-LM.

класс accelerate.utils.DynamoBackend

< >

( *values )

Представляет динамо-бэкенд (см. https://pytorch.org/docs/stable/torch.compiler.html).

Значения:

  • NO — Не использовать torch dynamo.
  • EAGER — использует PyTorch для выполнения извлечённого GraphModule. Это очень полезно при отладке проблем TorchDynamo.
  • AOT_EAGER — Использует AotAutograd без компилятора, то есть применяет PyTorch eager для извлечённых AotAutograd графов прямой и обратной передачи. Это полезно для отладки, но вряд ли даст ускорение.
  • INDUCTOR — Использует бэкенд TorchInductor с AotAutograd и cudagraphs, опираясь на сгенерированные ядра Triton. Подробнее
  • AOT_TS_NVFUSER — nvFuser с AotAutograd/TorchScript. Подробнее
  • NVPRIMS_NVFUSER — nvFuser с PrimTorch. Подробнее
  • CUDAGRAPHS — cudagraphs с AotAutograd. Подробнее
  • OFI — Использует Torchscript optimize_for_inference. Только для инференса. Подробнее
  • FX2TRT — Использует Nvidia TensorRT для оптимизации инференса. Только инференс. Подробнее
  • ONNXRT — Использует ONNXRT для вывода на CPU/GPU. Только вывод. Подробнее
  • TENSORRT — Использует ONNXRT для запуска TensorRT с целью оптимизации вывода. Подробнее
  • AOT_TORCHXLA_TRACE_ONCE — Использует Pytorch/XLA с оптимизацией TorchDynamo, для обучения. Подробнее
  • TORCHXLA_TRACE_ONCE — Использует Pytorch/XLA с оптимизацией TorchDynamo для инференса. Подробнее
  • TVM — Использует Apache TVM для оптимизации вывода. Подробнее
  • HPU_BACKEND — Использует HPU-бэкенд для оптимизации инференса.
  • NEURON — Использует бэкенд AWS Neuron для Trainium/Inferentia.

класс accelerate.utils.LoggerType

< >

( *values )

Представляет тип поддерживаемого трекера экспериментов

Значения:

  • ALL — все доступные в среде поддерживаемые трекеры
  • TENSORBOARD — TensorBoard в качестве трекера экспериментов
  • WANDB — wandb в качестве трекера экспериментов
  • TRACKIO — trackio в качестве трекера экспериментов
  • COMETML — comet_ml в качестве трекера экспериментов
  • MLFLOW — mlflow в качестве трекера экспериментов
  • CLEARML — clearml в качестве трекера экспериментов
  • DVCLIVE — dvclive в качестве трекера экспериментов
  • SWANLAB — swanlab в качестве трекера экспериментов

класс accelerate.utils.PrecisionType

< >

( *values )

Представляет тип точности, используемый для значений с плавающей запятой

Значения:

  • НЕТ — использование полной точности (FP32)
  • FP16 — использование половинной точности
  • BF16 — использование точности brain floating point

класс accelerate.utils.RNGType

< >

( *values )

класс accelerate.utils.SageMakerDistributedType

< >

( *values )

Представляет тип распределённой среды.

Значения:

  • NO — не распределённая среда, только один процесс.
  • DATA_PARALLEL — использование распределённого параллелизма данных sagemaker.
  • MODEL_PARALLEL — использование распределённого параллелизма моделей sagemaker.

Kwargs

Это настраиваемые аргументы для конкретных взаимодействий в экосистеме PyTorch, которые Accelerate обрабатывает «под капотом».

класс accelerate.AutocastKwargs

< >

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

Используйте этот объект в вашем Accelerator, чтобы настроить поведение torch.autocast. Подробности о каждом аргументе см. в документации этого контекстного менеджера.

Пример:

from accelerate import Accelerator
from accelerate.utils import AutocastKwargs

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

класс 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> )

Используйте этот объект в вашем Accelerator, чтобы настроить способ обёртывания вашей модели в torch.nn.parallel.DistributedDataParallel. Подробности о каждом аргументе см. в документации этого обёртывающего класса.

Пример:

from accelerate import Accelerator
from accelerate.utils import DistributedDataParallelKwargs

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

класс accelerate.GradScalerKwargs

< >

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

Используйте этот объект в вашем Accelerator, чтобы настроить поведение смешанной точности, в частности, способ создания используемого torch.amp.GradScaler или torch.cuda.amp.GradScaler. Подробную информацию о каждом аргументе см. в документации этого scaler.

Пример:

from accelerate import Accelerator
from accelerate.utils import GradScalerKwargs

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

класс accelerate.InitProcessGroupKwargs

< >

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

Используйте этот объект в вашем Accelerator для настройки инициализации распределённых процессов. Подробности о каждом аргументе см. в документации этого метода.

Примечание: если timeout установлено в None, значение по умолчанию будет определяться на основе параметра backend.

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

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

класс accelerate.utils.KwargsHandler

< >

( )

Внутренний миксин, реализующий метод to_kwargs() для dataclass.

to_kwargs

< >

( )

Возвращает словарь, содержащий атрибуты со значениями, отличными от значений по умолчанию для этого класса.

Плагины

Это плагины, которые можно передать объекту Accelerator. Хотя они описаны в других разделах документации, для удобства все они перечислены здесь:

класс 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 )

Параметры

  • hf_ds_config (Any, по умолчанию None) — Путь к файлу конфигурации DeepSpeed, словарь или объект класса accelerate.utils.deepspeed.HfDeepSpeedConfig.
  • gradient_accumulation_steps (int, по умолчанию None) — Количество шагов для накопления градиентов перед обновлением состояний оптимизатора. Если не задано, будет использовано значение из Accelerator напрямую.
  • gradient_clipping (float, по умолчанию None) — Включает обрезание градиентов с указанным значением.
  • zero_stage (int, по умолчанию None) — Допустимые значения: 0, 1, 2, 3. По умолчанию значение берётся из переменной окружения.
  • is_train_batch_min (bool, по умолчанию True) — Если указаны оба загрузчика данных для обучения и оценки, этот параметр определяет train_batch_size.
  • offload_optimizer_device (str, по умолчанию None) — Допустимые значения: none|cpu|nvme. Применимо только для ZeRO Stages 2 и 3.
  • offload_param_device (str, по умолчанию None) — Допустимые значения: none|cpu|nvme. Применимо только для ZeRO Stage 3.
  • offload_optimizer_nvme_path (str, по умолчанию None) — Допустимые значения: /nvme|/local_nvme. Применимо только для ZeRO Stage 3.
  • offload_param_nvme_path (str, по умолчанию None) — Допустимые значения: /nvme|/local_nvme. Применимо только для ZeRO Stage 3.
  • zero3_init_flag (bool, по умолчанию None) — Флаг, указывающий, следует ли сохранять модель в 16-битном формате. Применимо только для ZeRO Stage-3.
  • zero3_save_16bit_model (bool, по умолчанию None) — Флаг, указывающий, следует ли сохранять модель в 16-битном формате. Применимо только для ZeRO Stage-3.
  • transformer_moe_cls_names (str, по умолчанию None) — Список имён классов MoE-слоёв Transformers, разделённых запятыми (с учётом регистра). Например, MixtralSparseMoeBlock, Qwen2MoeSparseMoeBlock, JetMoEAttention, JetMoEBlock и т. д.

Этот плагин используется для интеграции DeepSpeed.

deepspeed_config_process

< >

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

Обработайте конфигурацию DeepSpeed с значениями из kwargs.

select

< >

( _from_accelerator_state: bool = False )

Устанавливает HfDeepSpeedWeakref для использования текущей конфигурации плагина deepspeed

класс 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 )

Параметры

  • fsdp_version (int, по умолчанию 1) — Версия FSDP, которую следует использовать. По умолчанию — 1. Если установлено значение 2, загрузчик ожидает, что конфигурация будет преобразована в формат FSDP2.
  • sharding_strategy (Union[str, torch.distributed.fsdp.ShardingStrategy], по умолчанию 'FULL_SHARD') — Стратегия шардирования. Должна быть либо str, либо экземпляром torch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy. Устарела, рекомендуется использовать reshard_after_forward.
  • reshard_after_forward (Union[str, torch.distributed.fsdp.ShardingStrategy, bool], по умолчанию 'FULL_SHARD' для fsdp_version=1 и True для fsdp_version=2) — Стратегия шардирования. Должна быть bool, если fsdp_version установлено в 2, иначе str или экземпляр torch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy.
  • backward_prefetch (Union[str, torch.distributed.fsdp.BackwardPrefetch], по умолчанию 'NO_PREFETCH') — Стратегия предварительной загрузки в обратном направлении. Должно быть строкой str или экземпляром torch.distributed.fsdp.fully_sharded_data_parallel.BackwardPrefetch.
  • mixed_precision_policy (Optional[Union[dict, str, torch.distributed.fsdp.MixedPrecision, torch.distributed.fsdp.MixedPrecisionPolicy]], по умолчанию None) — Конфигурация для включения обучения с смешанной точностью с использованием FullyShardedDataParallel. Если передается dict, он должен содержать следующие ключи: param_dtype, reduce_dtype и buffer_dtype. Может быть экземпляром torch.distributed.fsdp.MixedPrecisionPolicy, если fsdp_version установлено в 2. Если передается str, он должен быть одним из следующих значений: fp8, fp16, bf16, fp32, и используется для установки param_dtype, reduce_dtype и 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], по умолчанию False) — Следует ли выгружать параметры на CPU. Значением может быть bool или экземпляр torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffload или torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffloadPolicy, если fsdp_version установлено в 2.
  • ignored_modules (Optional[Union[Iterable[torch.nn.Module], str]], по умолчанию None) — Список модулей, которые следует игнорировать при обёртке в FSDP. Если передана строка, модули будут сопоставляться по имени с использованием полного совпадения регулярного выражения. Если fsdp_version установлен в 2, модули преобразуются в параметры и используются.
  • state_dict_type (Union[str, torch.distributed.fsdp.StateDictType], по умолчанию 'FULL_STATE_DICT') — Тип state dict для использования. Если передана строка, она должна быть одной из full_state_dict, local_state_dict или sharded_state_dict.
  • state_dict_config (Optional[Union[torch.distributed.fsdp.FullStateDictConfig, torch.distributed.fsdp.ShardedStateDictConfig], по умолчанию None) — Конфигурация state dict, которую следует использовать. Если не передана, определяется на основе state_dict_type.
  • optim_state_dict_config (Optional[Union[torch.distributed.fsdp.FullOptimStateDictConfig, torch.distributed.fsdp.ShardedOptimStateDictConfig], по умолчанию None) — Конфигурация state dict для оптимизатора. Если не передана, определяется на основе state_dict_type.
  • limit_all_gathers (bool, по умолчанию True) — Определяет, следует ли FSDP явно синхронизировать CPU-поток, чтобы предотвратить слишком большое количество незавершённых all-gather операций. Этот параметр bool влияет только на стратегии с шардированием, которые планируют all-gather операции. Включение этого параметра может помочь снизить количество повторных попыток выделения памяти CUDA.
  • use_orig_params (bool, по умолчанию False) — Использовать ли исходные параметры для оптимизатора.
  • param_init_fn (Optional[Callable[[torch.nn.Module], None], по умолчанию None) — Callable[torch.nn.Module] -> None, определяющая, как модули, находящиеся на meta-устройстве, должны быть инициализированы на реальном устройстве. Применимо только тогда, когда sync_module_states равно True. По умолчанию это lambda, вызывающая to_empty для модуля.
  • sync_module_states (bool, по умолчанию False) — Определяет, следует ли каждому индивидуально обернутому модулю FSDP транслировать параметры модуля с ранга 0, чтобы гарантировать их идентичность на всех рангах после инициализации. По умолчанию False, если только cpu_ram_efficient_loading не равно True, в этом случае параметр принудительно включается.
  • forward_prefetch (bool, по умолчанию False) — Определяет, следует ли FSDP явно выполнять предварительную загрузку (prefetch) следующего all-gather во время выполнения прямого прохода (forward pass). Используйте только со статическими графами.
  • activation_checkpointing (bool, по умолчанию False) — Техника для снижения потребления памяти путём очистки активаций определённых слоёв и их повторного вычисления во время обратного прохода. По сути, это дополнительное время вычислений в обмен на уменьшенное потребление памяти.
  • cpu_ram_efficient_loading (bool, по умолчанию None) — Если True, предобученную контрольную точку модели загружает только первый процесс, а все остальные процессы имеют пустые веса. Применимо только для Transformers. При использовании этого параметра sync_module_states должно быть True.
  • transformer_cls_names_to_wrap (Optional[List[str]], по умолчанию None) — Список имён классов слоёв трансформера, которые нужно обернуть. Применимо только тогда, когда auto_wrap_policy равно transformer_based_wrap.
  • min_num_params (Optional[int], по умолчанию None) — Минимальное количество параметров, которое должен иметь модуль для его обёртывания. Применимо только тогда, когда auto_wrap_policy равно size_based_wrap.

Это плагин используется для включения полностью шардированного параллелизма данных.

set_auto_wrap_policy

< >

( model )

Создаёт auto_wrap_policy на основе переданной политики и возможности использования transformer_cls_to_wrap для model.

set_mixed_precision

< >

( mixed_precisionbuffer_autocast = Falseoverride = False )

Устанавливает политику смешанной точности для FSDP

set_state_dict_type

< >

( state_dict_type = None )

Установите конфигурацию state dict на основе StateDictType.

validate_mixed_precision_policy

< >

( )

Проверяет политику смешанной точности, абстрагированную так, чтобы не импортировать зависимости, если они не нужны.

класс accelerate.utils.GradientAccumulationPlugin

< >

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

Параметры

  • num_steps (int) — Количество шагов для накопления градиентов.
  • adjust_scheduler (bool, необязательный, по умолчанию True) — Определяет, следует ли корректировать шаги планировщика с учётом количества накапливаемых шагов. Должно быть True, если используемый планировщик не был настроен с учётом накопления градиентов.
  • sync_with_dataloader (bool, необязательный, по умолчанию True) — Синхронизировать ли установку градиентов в конце загрузки данных.
  • sync_each_batch (bool, необязательный) — Синхронизировать ли установку градиентов на каждом батче данных. Установка значения True может снизить требования к памяти при использовании накопления градиентов в распределённом обучении, но за счёт скорости.

Плагин для настройки поведения накопления градиентов. В Accelerator можно передать только один из параметров: gradient_accumulation_plugin или gradient_accumulation_steps. Передача обоих параметров приводит к ошибке.

Пример:

from accelerate.utils import GradientAccumulationPlugin

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

класс accelerate.utils.MegatronLMPlugin

< >

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

Параметры

  • tp_degree (int, по умолчанию None) — Степень параллелизма тензоров.
  • pp_degree (int, по умолчанию None) — Степень конвейерного параллелизма.
  • num_micro_batches (int, по умолчанию None) — Количество микробатчей.
  • gradient_clipping (float, по умолчанию None) — Значение обрезки градиентов на основе глобальной L2-нормы (0 для отключения).
  • sequence_parallelism (bool, по умолчанию None) — Включает параллелизм последовательностей.
  • recompute_activations (bool, по умолчанию None) — Включает выборочный пересчёт активаций.
  • use_distributed_optimizer (bool, по умолчанию None) — Включить распределённый оптимизатор.
  • pipeline_model_parallel_split_rank (int, по умолчанию None) — Ранг, на котором следует разделить энкодер и декодер.
  • num_layers_per_virtual_pipeline_stage (int, по умолчанию None) — Количество слоев на виртуальную стадию конвейера.
  • is_train_batch_min (str, по умолчанию True) — Если указаны оба загрузчика данных для обучения и оценки, этот параметр определяет micro_batch_size.
  • train_iters (int, по умолчанию None) — Общее количество образцов для обучения во всех прогонах обучения. Обратите внимание, что при использовании MegatronLMDummyScheduler необходимо указать либо train-iters, либо train-samples.
  • train_samples (int, по умолчанию None) — Общее количество образцов для обучения во всех циклах обучения. Обратите внимание, что при использовании MegatronLMDummyScheduler необходимо указать либо train-iters, либо train-samples.
  • weight_decay_incr_style (str, по умолчанию 'constant') — Функция приращения весового затухания. choices=[“constant”, “linear”, “cosine”].
  • start_weight_decay (float, по умолчанию None) — Начальный коэффициент затухания весов для L2-регуляризации.
  • end_weight_decay (float, по умолчанию None) — Коэффициент затухания веса в конце обучения для L2-регуляризации.
  • lr_decay_style (str, по умолчанию 'linear') — Функция затухания скорости обучения. choices=[‘constant’, ‘linear’, ‘cosine’].
  • lr_decay_iters (int, по умолчанию None) — Количество итераций для затухания скорости обучения. Если значение равно None, по умолчанию используется train_iters.
  • lr_decay_samples (int, по умолчанию None) — Количество образцов для затухания скорости обучения. Если значение равно None, по умолчанию используется train_samples.
  • lr_warmup_iters (int, по умолчанию None) — Количество итераций для линейного прогрева скорости обучения.
  • lr_warmup_samples (int, по умолчанию None) — Количество образцов, на протяжении которых линейно выполняется прогрев скорости обучения.
  • lr_warmup_fraction (float, по умолчанию None) — Доля lr-warmup-(итераций/образцов), в течение которой линейно выполняется прогрев скорости обучения.
  • min_lr (float, по умолчанию 0) — Минимальное значение коэффициента обучения. Планировщик обрезает значения ниже этого порога.
  • consumed_samples (List, по умолчанию None) — Количество использованных образцов в том же порядке, что и загрузчики данных для вызова accelerator.prepare.
  • no_wd_decay_cond (Optional, по умолчанию None) — Условие для отключения weight decay.
  • scale_lr_cond (Optional, по умолчанию None) — Условие для масштабирования скорости обучения.
  • lr_mult (float, по умолчанию 1.0) — Множитель скорости обучения.
  • megatron_dataset_flag (bool, по умолчанию False) — Указывает, следует ли формат набора данных формату Indexed/Cached/MemoryMapped от Megatron-LM.
  • seq_length (int, по умолчанию None) — Максимальная длина последовательности для обработки.
  • encoder_seq_length (int, по умолчанию None) — Максимальная длина последовательности для обработки энкодером.
  • decoder_seq_length (int, по умолчанию None) — Максимальная длина последовательности для обработки декодером.
  • tensorboard_dir (str, по умолчанию None) — Путь для сохранения журналов tensorboard.
  • set_all_logging_options (bool, по умолчанию False) — Указывает, следует ли установить все параметры журналирования.
  • eval_iters (int, по умолчанию 100) — Количество итераций, выполняемых для оценки валидации/теста.
  • eval_interval (int, по умолчанию 1000) — Интервал между запусками оценки на валидационной выборке.
  • return_logits (bool, по умолчанию False) — Возвращать ли логиты из модели.
  • custom_train_step_class (Optional, по умолчанию None) — Пользовательский класс для шага обучения.
  • custom_train_step_kwargs (Optional, по умолчанию None) — Пользовательские аргументы для шага обучения.
  • custom_model_provider_function (Optional, по умолчанию None) — Пользовательская функция провайдера модели.
  • custom_prepare_model_function (Optional, по умолчанию None) — Пользовательская функция подготовки модели.
  • custom_megatron_datasets_provider_function (Optional, по умолчанию None) — Пользовательская функция-провайдер наборов данных megatron train_valid_test.
  • custom_get_batch_function (Optional, по умолчанию None) — Пользовательская функция получения батча.
  • custom_loss_function (Optional, по умолчанию None) — Пользовательская функция потерь.
  • other_megatron_args (Optional, по умолчанию None) — Другие аргументы Megatron-LM. См. документацию Megatron-LM.

Плагин для Megatron-LM, обеспечивающий тензорное, конвейерное, последовательное и данные параллелизм. Также позволяет использовать выборочный пересчёт активаций и оптимизированные слиянные ядра.

класс accelerate.utils.TorchDynamoPlugin

< >

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

Параметры

  • backend (DynamoBackend, по умолчанию None) — Допустимый бэкенд Dynamo. Подробнее см. https://pytorch.org/docs/stable/torch.compiler.html.
  • mode (str, по умолчанию None) — Допустимые значения: ‘default’, ‘reduce-overhead’ или ‘max-autotune’.
  • fullgraph (bool, по умолчанию None) — Допускается ли разбиение модели на несколько подграфов.
  • dynamic (bool, по умолчанию None) — Использовать ли динамическую форму при трассировке.
  • options (Any, по умолчанию None) — Словарь параметров для передачи в backend.
  • disable (bool, по умолчанию False) — Делает torch.compile() нетипичным (no-op) для тестирования
  • use_regional_compilation (bool, по умолчанию None) — Используйте этот параметр для сокращения времени компиляции при холодном старте torch.compile(), нацеливаясь на повторяющиеся блоки одного и того же класса и компилируя их последовательно, чтобы попадать в кэш компилятора. Например, в GPT2LMHeadModel повторяющимся блоком/классом является GPT2Block, к которому можно обратиться как model.transformer.h[0]. Остальная часть модели (например, model.lm_head) компилируется отдельно.

Это плагин используется для компиляции модели с PyTorch 2.0

Конфигурации

Это классы, которые можно настроить и передать в соответствующую интеграцию

класс accelerate.utils.BnbQuantizationConfig

< >

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

Параметры

  • load_in_8bit (bool, по умолчанию False) — Включает квантование 8bit.
  • llm_int8_threshold (float, по умолчанию 6.0) — Значение порога outliner. Актуально только при load_in_8bit=True.
  • load_in_4bit (bool, по умолчанию False) — Включает 4-битовое квантование.
  • bnb_4bit_quant_type (str, по умолчанию fp4) — Задаёт тип данных квантования в слоях bnb.nn.Linear4Bit. Доступные варианты: {‘fp4’,‘np4’}.
  • bnb_4bit_use_double_quant (bool, по умолчанию False) — Включает вложенную квантизацию, при которой константы квантизации из первого этапа квантизации квантуются повторно.
  • bnb_4bit_compute_dtype (bool, по умолчанию fp16) — Определяет тип вычислений, который может отличаться от типа входных данных. Например, входные данные могут быть fp32, но для ускорения вычисления можно установить bf16. Доступные варианты: {‘fp32’,‘fp16’,‘bf16’}.
  • torch_dtype (torch.dtype, по умолчанию None) — Определяет dtype для остальных не квантованных слоёв. Библиотека bitsandbytes рекомендует устанавливать значение torch.float16 для 8-битной модели и использовать тот же dtype, что и dtype вычислений, для 4-битной модели.
  • skip_modules (List[str], по умолчанию None) — Явный список модулей, которые не квантуются. Тип данных этих модулей будет torch_dtype.
  • keep_in_fp32_modules (List, по умолчанию None) — Явный список модулей, которые не квантуются. Они сохраняются в формате torch.float32.

Плагин для включения квантования BitsAndBytes в 4-битном и 8-битном форматах

класс 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 )

Параметры

  • split_batches (bool, по умолчанию False) — Определяет, должен ли акселератор распределять батчи, возвращаемые загрузчиками данных, между устройствами. Если True, фактический размер батча будет одинаковым для любого типа распределенных процессов, но он должен быть кратным num_processes, которые вы используете. Если False, фактический размер батча будет равен значению, заданному в вашем скрипте, умноженному на количество процессов.
  • dispatch_batches (bool, по умолчанию None) — Если установлено в True, даталоадер, подготовленный Accelerator, итерируется только в основном процессе, а затем батчи разделяются и транслируются каждому процессу. По умолчанию будет True для DataLoader, основанного на IterableDataset, и False в остальных случаях.
  • even_batches (bool, по умолчанию True) — Если установлено в True, то в случаях, когда общий размер батча во всех процессах не делится на размер датасета без остатка, образцы из начала датасета дублируются, чтобы батч можно было разделить поровну между всеми воркерами.
  • use_seedable_sampler (bool, по умолчанию False) — Использовать ли полностью воспроизводимый случайный сэмплер (data_loader.SeedableRandomSampler). Обеспечивает полную воспроизводимость результатов обучения с использованием другой техники выборки. Хотя результаты при разных значениях seed могут отличаться, в среднем различия пренебрежимо малы при сравнении нескольких разных seed. Для наилучших результатов также следует использовать set_seed().
  • data_seed (int, по умолчанию None) — Значение seed для базового генератора при использовании use_seedable_sampler. Если None, генератор будет использовать текущий seed по умолчанию из torch.
  • non_blocking (bool, по умолчанию False) — Если установлено в True, загрузчик данных, подготовленный Accelerator, будет использовать неблокирующие передачи данных с хоста на устройство, что позволяет лучше перекрывать коммуникацию загрузчика данных и вычисления. Рекомендуется, чтобы у подготовленного загрузчика данных параметр pin_memory был установлен в True для корректной работы.
  • use_stateful_dataloader (bool, по умолчанию False) — Если установлено в True, dataloader, подготовленный Accelerator, будет использовать torchdata.StatefulDataLoader в качестве основы. Для этого требуется установка версии torchdata 0.8.0 или выше, поддерживающей StatefulDataLoader.

Конфигурация для элементов, связанных с загрузчиком данных, при вызове accelerator.prepare.

класс accelerate.utils.ProjectConfiguration

< >

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

Параметры

  • project_dir (str, по умолчанию None) — Путь к каталогу для хранения данных.
  • logging_dir (str, по умолчанию None) — Путь к каталогу для хранения журналов локально-совместимых логгеров. Если значение равно None, по умолчанию используется project_dir.
  • automatic_checkpoint_naming (bool, по умолчанию False) — Определяет, следует ли автоматически присваивать сохраняемым состояниям итеративные имена.
  • total_limit (int, по умолчанию None) — Максимальное количество сохраняемых состояний, которое следует хранить.
  • iteration (int, по умолчанию 0) — Текущая итерация сохранения.
  • save_on_each_node (bool, по умолчанию False) — При распределённом обучении на нескольких узлах определяет, сохранять ли модели и контрольные точки на каждом узле или только на главном.

Конфигурация объекта Accelerator в соответствии с потребностями внутреннего проекта.

set_directories

< >

( project_dir: str | None = None )

Устанавливает self.project_dir и self.logging_dir в соответствующие значения.

Переменные окружения

Это переменные окружения, которые можно включить для различных сценариев использования

  • ACCELERATE_DEBUG_MODE (str): Запуск accelerate в режиме отладки. Подробнее — здесь.

Манипуляции с данными и операции

К ним относятся операции с данными, которые имитируют те же самые операции torch, но могут использоваться в распределённых процессах.

accelerate.utils.broadcast

< >

( tensorfrom_process: int = 0 )

Параметры

  • tensor (вложенный список/кортеж/словарь из torch.Tensor) — Данные для сбора.
  • from_process (int, необязательный, по умолчанию 0) — Процесс, от которого отправляются данные

Рекурсивно распространить тензор по всем устройствам в вложенном списке/кортеже/словаре тензоров.

accelerate.utils.broadcast_object_list

< >

( object_listfrom_process: int = 0 )

Параметры

  • object_list (список объектов, поддерживающих сериализацию) — Список объектов для рассылки. Этот список будет изменён на месте.
  • from_process (int, необязательный, по умолчанию 0) — Процесс, от которого отправляются данные.

Broadcast списка объектов, поддерживающих сериализацию, из одного процесса в остальные.

accelerate.utils.concatenate

< >

( datadim = 0 )

Параметры

  • data (вложенный список/кортеж/словарь списков тензоров torch.Tensor) — Данные для конкатенации.
  • dim (int, необязательный, по умолчанию 0) — Размерность, по которой выполняется конкатенация.

Рекурсивно конкатенирует тензоры в вложенном списке/кортеже/словаре списков тензоров с одинаковой формой. Если есть только одна партия данных, она возвращается без изменений.

accelerate.utils.convert_outputs_to_fp32

< >

( model_forward )

accelerate.utils.convert_to_fp32

< >

( tensor )

Параметры

  • tensor (вложенный список/кортеж/словарь из torch.Tensor) — Данные для преобразования из FP16/BF16 в FP32.

Рекурсивно преобразует элементы вложенных списков/кортежей/словарей тензоров с точностью FP16/BF16 в FP32.

accelerate.utils.gather

< >

( tensor )

Параметры

  • tensor (вложенный список/кортеж/словарь из torch.Tensor) — Данные для сбора.

Рекурсивно собрать тензор из вложенного списка/кортежа/словаря тензоров со всех устройств.

accelerate.utils.gather_object

< >

( object: Any )

Параметры

  • object (вложенный список/кортеж/словарь с объектами, поддерживающими сериализацию) — Данные, которые нужно собрать.

Рекурсивно собирает объект из вложенного списка/кортежа/словаря объектов со всех устройств.

accelerate.utils.get_grad_scaler

< >

( distributed_type: DistributedType = None**kwargs )

Параметры

  • distributed_type (DistributedType, необязательный, по умолчанию None) — Тип распределённой среды.
  • kwargs — Дополнительные аргументы для используемого конструктора GradScaler.

Универсальный вспомогательный метод, который инициализирует правильную реализацию GradScaler в зависимости от окружения и возвращает её.

accelerate.utils.get_mixed_precision_context_manager

< >

( native_amp: bool = Falseautocast_kwargs: AutocastKwargs = None )

Параметры

  • native_amp (bool, необязательный, по умолчанию False) — Указывает, включено ли смешанное прецизионное вычисление.

Возвращает менеджер контекста для автоматического приведения к смешанной точности

accelerate.utils.listify

< >

( data )

Параметры

  • data (вложенный список/кортеж/словарь из torch.Tensor) — данные, из которых выполняется преобразование в обычные числа.

Рекурсивно находит тензоры во вложенном списке/кортеже/словаре и преобразует их в список чисел.

accelerate.utils.pad_across_processes

< >

( tensordim = 0pad_index = 0pad_first = False )

Параметры

  • tensor (вложенный список/кортеж/словарь из torch.Tensor) — Данные для сбора.
  • dim (int, необязательный, по умолчанию 0) — Размерность, по которой выполняется дополнение.
  • pad_index (int, необязательный, по умолчанию 0) — Значение, используемое для дополнения.
  • pad_first (bool, необязательный, по умолчанию False) — Определяет, добавлять ли заполнители в начале или в конце.

Рекурсивно дополните тензоры в вложенном списке/кортеже/словаре тензоров со всех устройств до одинакового размера, чтобы их можно было безопасно собрать.

accelerate.utils.recursively_apply

< >

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

Параметры

  • func (callable) — Функция, которую нужно применить рекурсивно.
  • data (вложенный список/кортеж/словарь объектов, принимаемых test_type) — Данные, к которым применяется func
  • *args — Позиционные аргументы, которые будут переданы в func при применении к распакованным данным.
  • test_type (Callable[[Any], bool], необязательный, по умолчанию is_torch_tensor) — Предикат, определяющий, следует ли применять func к данному объекту-листу.
  • error_on_other_type (bool, необязательный, по умолчанию False) — Определяет, следует ли возвращать ошибку, если после распаковки data получается объект, для которого test_type возвращает False. Если False, функция оставляет такие объекты без изменений.
  • **kwargs (дополнительные именованные аргументы, необязательные) — Именованные аргументы, которые будут переданы в func при применении к распакованным данным.

Рекурсивно применяет функцию к структуре данных, представляющей собой вложенный список/кортеж/словарь заданного базового типа.

accelerate.utils.reduce

< >

( tensorreduction = 'mean'scale = 1.0 )

Параметры

  • tensor (вложенный список/кортеж/словарь из torch.Tensor) — Данные для агрегирования.
  • reduction (str, необязательный, по умолчанию "mean") — Метод агрегации. Может принимать значения “mean”, “sum”, “max” или “none”
  • scale (float, необязательный) — Значение масштабирования по умолчанию, применяемое после reduce. Действительно только для XLA.

Рекурсивно уменьшает тензоры в вложенном списке/кортеже/словаре списков тензоров по всем процессам, вычисляя среднее значение по заданной операции.

accelerate.utils.send_to_device

< >

( tensordevicenon_blocking = Falseskip_keys = None )

Параметры

  • tensor (вложенный список/кортеж/словарь из torch.Tensor) — Данные, которые нужно отправить на указанное устройство.
  • device (torch.device) — Устройство, на которое нужно отправить данные.
  • non_blocking (bool, необязательный, по умолчанию False) — Если True, передача на устройство выполняется асинхронно, что позволяет перекрывать перемещение данных с вычислениями. Действует только в том случае, если устройство это поддерживает (например, CUDA).
  • skip_keys (str или List[str], необязательный) — Ключ или список ключей в словаре tensor, значения которых не следует отправлять на указанное device. Записи с этими ключами остаются на исходном устройстве.

Рекурсивно отправляет элементы вложенного списка/кортежа/словаря тензоров на указанное устройство.

accelerate.utils.slice_tensors

< >

( datatensor_sliceprocess_index = Nonenum_processes = None )

Параметры

  • data (вложенный список/кортеж/словарь из torch.Tensor) — Данные для нарезки.
  • tensor_slice (slice) — Выбираемый срез.

Рекурсивно извлекает срез из вложенного списка/кортежа/словаря тензоров.

Проверки окружения

Эти функции проверяют состояние текущей рабочей среды, включая информацию о самой операционной системе, о том, что она поддерживает, и установлены ли определённые зависимости.

accelerate.utils.is_bf16_available

< >

( ignore_tpu = False )

Проверяет, поддерживается ли bf16, с возможностью игнорирования TPU

accelerate.utils.is_mps_available

< >

( min_version = '1.12' )

Проверяет, доступно ли устройство MPS. Минимальная требуемая версия — 1.12.

accelerate.utils.is_npu_available

( check_device = False )

Проверяет, установлен ли torch_npu и, при необходимости, присутствует ли NPU в окружении

accelerate.utils.is_torch_version

< >

( operation: strversion: str )

Параметры

  • operation (str) — Строковое представление оператора, например ">" или "<="
  • version (str) — Строковая версия PyTorch

Сравнивает текущую версию PyTorch с заданной эталонной с помощью операции.

accelerate.utils.is_torch_xla_available

( check_is_tpu = Falsecheck_is_gpu = False )

Проверьте, доступен ли torch_xla. Чтобы обучать нативную задачу pytorch в среде, где установлен torch xla, установите USE_TORCH_XLA в false.

accelerate.utils.is_xpu_available

( check_device = False )

Проверяет, доступна ли ускорение XPU через стандартный PyTorch (>=2.7) и, возможно, присутствует ли XPU в окружении

Управление окружением

accelerate.utils.patch_environment

< >

( **kwargs )

Контекстный менеджер, который добавляет каждый переданный аргумент с ключом в os.environ и удаляет их при выходе.

Преобразует значения в kwargs в строки и переводит все ключи в верхний регистр.

Пример:

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

< >

( )

Контекстный менеджер, который временно очищает переменные окружения.

При выходе из этого контекста предыдущие переменные окружения будут восстановлены.

Пример:

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

Параметры

  • mixed_precision (str, необязательный, по умолчанию “no”) — Режим смешанной точности. Должно быть одним из “no”, “fp16” или “bf16”
  • save_location (str, необязательный, по умолчанию default_json_config_file) — Необязательное пользовательское место сохранения. Должно передаваться в --config_file при использовании accelerate launch. По умолчанию файл находится в каталоге кэша huggingface (~/.cache/huggingface), но это можно изменить, задав переменную окружения HF_HOME, после чего используется путь accelerate/default_config.yaml.

Создаёт и сохраняет базовый конфигурационный файл кластера для использования на локальной машине, потенциально оснащённой несколькими GPU. Если машина работает только на CPU, будет настроен и CPU.

При первой настройке 🤗 Accelerate вместо запуска accelerate config в качестве альтернативы для быстрой конфигурации можно использовать [~utils.write_basic_config].

accelerate.utils.set_numa_affinity

( local_process_index: intverbose: bool | None = None )

Параметры

  • local_process_index (int) — Индекс текущего процесса на текущем сервере.
  • verbose (bool, необязательный) — Определяет, выводить ли новое распределение cpu-ядер для каждого процесса. Если ACCELERATE_DEBUG_MODE включен, значение по умолчанию — True.

Назначает текущий процесс на конкретный NUMA-узел. Наиболее эффективно, когда на каждом узле имеется как минимум 2 CPU.

Этот результат кэшируется между вызовами. Если вы хотите переопределить его, используйте accelerate.utils.environment.override_numa_afifnity.

accelerate.utils.environment.override_numa_affinity

< >

( local_process_index: intverbose: bool | None = None )

Параметры

  • local_process_index (int) — Индекс текущего процесса на текущем сервере.
  • verbose (bool, необязательный) — Определяет, выводить ли в журнал информацию о назначении каждого CPU. Если ACCELERATE_DEBUG_MODE включен, значение по умолчанию — True.

Переопределяет любую установленную NUMA-аффинность для текущего процесса. Это очень ресурсоёмкая операция, требующая пересчёта аффинности, которую необходимо установить; в идеале следует использовать utils.environment.set_numa_affinity.

accelerate.utils.purge_accelerate_environment

< >

( func_or_cls )

Декоратор для очистки переменных окружения accelerate, установленных декорируемым классом или функцией.

В некоторых обстоятельствах вызов определённых классов или функций может привести к установке переменных окружения accelerate, которые затем не удаляются. Например, при вызове:

TrainingArguments(fp16=True, …)

Будет установлена следующая переменная окружения:

ACCELERATE_MIXED_PRECISION=fp16

Это может повлиять на последующий код, поскольку переменная окружения имеет приоритет над TrainingArguments(fp16=False). Это особенно важно для модульного тестирования, где мы хотим избежать побочных эффектов отдельных тестов друг на друга. Используйте этот декоратор для функции модульного теста или всего класса, чтобы гарантировать, что после каждого теста переменные окружения будут очищены. Это работает как для unittest.TestCase, так и для обычных классов (pytest); также работает при декорировании родительского класса.

Память

accelerate.find_executable_batch_size

< >

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

Параметры

  • function (callable, optional) — Функция для обёртки
  • starting_batch_size (int, необязательный) — Размер батча, который следует попытаться уместить в памяти
  • reduce_batch_size_fn (callable, необязательный) — Функция для определения нового размера батча после ошибки нехватки памяти. Если не указана, размер батча умножается на 0.9 при каждой неудаче. Функция не принимает аргументов и должна возвращать новый (уменьшенный) размер батча в виде int.

Базовый декоратор, который пытается выполнить function. Если возникает исключение, связанное с нехваткой памяти или CUDNN, размер батча умножается на 0.9 и передаётся в function

function должен принимать параметр batch_size в качестве первого аргумента.

Пример:

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

Моделирование

Эти утилиты связаны с взаимодействием с моделями PyTorch

accelerate.utils.calculate_maximum_sizes

< >

( model: Module )

Вычисляет общий размер модели и её самого крупного слоя

accelerate.utils.compute_module_sizes

< >

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

Вычислите размер каждого подмодуля заданной модели.

accelerate.utils.extract_model_from_parallel

< >

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

Параметры

  • model (torch.nn.Module) — Модель, из которой выполняется извлечение.
  • keep_fp32_wrapper (bool, необязательный) — Указывает, следует ли удалять хуки смешанной точности из модели.
  • keep_torch_compile (bool, необязательный) — Следует ли развернуть скомпилированную модель.
  • recursive (bool, необязательный, по умолчанию False) — Определяет, следует ли рекурсивно извлекать все случаи module.module из model, а также рекурсивно разворачивать дочерние подслои, а не только распределённые контейнеры верхнего уровня.

Возвращает

torch.nn.Module

Извлеченная модель.

Извлечение модели из её распределённых контейнеров.

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 )

Параметры

  • model (torch.nn.Module) — Модель для анализа.
  • max_memory (Dict, необязательный) — Словарь, сопоставляющий идентификатор устройства с максимальным объёмом памяти. Если не задано, по умолчанию используется максимально доступная память. Пример: max_memory={0: "1GB"}.
  • no_split_module_classes (List[str], необязательный) — Список имён классов слоёв, которые никогда не следует разделять между устройствами (например, любой слой, имеющий остаточное соединение).
  • dtype (str или torch.dtype, необязательный) — Если указано, веса будут преобразованы в этот тип при загрузке.
  • special_dtypes (Dict[str, Union[str, torch.device]], необязательный) — Если указано, специальные dtypes, которые следует учитывать для некоторых конкретных весов (перекрывает dtype, используемый по умолчанию для всех весов).
  • low_zero (bool, необязательный) — Минимизирует количество весов на GPU 0, что удобно, когда она используется для других операций (например, для функции generate из Transformers).

Вычислите словарь max_memory для infer_auto_device_map(), который сбалансирует использование каждого доступного GPU.

Все вычисления выполняются на основе анализа размеров и dtypes параметров модели. В результате модель может находиться на meta-устройстве (как если бы она была инициализирована внутри контекстного менеджера init_empty_weights).

accelerate.utils.get_max_layer_size

< >

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

Параметры

  • modules (List[Tuple[str, torch.nn.Module]]) — Список именованных модулей, для которых требуется определить максимальный размер слоя.
  • module_sizes (Dict[str, int]) — Словарь, сопоставляющий каждому имени слоя его размер (сгенерированный с помощью compute_module_sizes).
  • no_split_module_classes (List[str]) — Список имён классов для слоёв, которые не следует разделять.

Возвращает

Tuple[int, List[str]]

Максимальный размер слоя со списком имён слоёв, реализующих этот максимальный размер.

Вспомогательная функция, которая просматривает список именованных модулей и возвращает максимальный размер, используемый одним полным слоем. Определение слоя:

  • модуль без прямых дочерних элементов (только параметры и буферы)
  • модуль, имя класса которого входит в список 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 )

Параметры

  • model (torch.nn.Module) — Модель для анализа.
  • max_memory (Dict, необязательный) — Словарь, сопоставляющий идентификатор устройства с максимальным объёмом памяти. Если не задано, по умолчанию используется максимально доступная память. Пример: max_memory={0: "1GB"}.
  • no_split_module_classes (List[str], необязательный) — Список имён классов слоёв, которые никогда не следует разделять между устройствами (например, любой слой, имеющий остаточное соединение).
  • dtype (str или torch.dtype, необязательный) — Если указано, веса будут преобразованы в этот тип при загрузке.
  • special_dtypes (Dict[str, Union[str, torch.device]], необязательный) — Если указано, специальные dtypes, которые следует учитывать для некоторых конкретных весов (перекрывает dtype, используемый по умолчанию для всех весов).
  • verbose (bool, необязательный, по умолчанию False) — Определяет, следует ли выводить отладочные сообщения при построении device_map функцией.
  • clean_result (bool, необязательный, по умолчанию True) — Очистить итоговый device_map, объединяя все подмодули, размещаемые на одном и том же устройстве.
  • offload_buffers (bool, необязательный, по умолчанию False) — Определяет, следует ли выгружать на CPU или диск буферы в дополнение к параметрам в тех слоях, которые выгружаются на CPU или диск.
  • fallback_allocation (bool, необязательный, по умолчанию False) — Если обычное выделение памяти не удаётся, попытаться выделить модуль, который укладывается в лимит размера, с помощью обхода в ширину (BFS).

Вычислите карту устройств для заданной модели, отдавая приоритет GPU, затем выгружая на CPU и, наконец, на диск, так чтобы:

  • мы не превышаем доступную память ни на одном из GPU.
  • если требуется offload на CPU, на GPU 0 всегда остаётся место для возврата на GPU слоя, выгруженного на CPU, с наибольшим размером.
  • если требуется offload на CPU, мы не превышаем доступный объём ОЗУ на CPU.
  • если требуется offload на диск, на CPU всегда остаётся место для возврата слоя, offload которого на диск выполнен, и который имеет наибольший размер.

Все вычисления выполняются на основе анализа размеров и dtypes параметров модели. В результате модель может находиться на meta-устройстве (как если бы она была инициализирована внутри контекстного менеджера 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 )

Параметры

  • model (torch.nn.Module) — Модель, в которую мы хотим загрузить контрольную точку.
  • checkpoint (str или os.PathLike) — Папка контрольной точки для загрузки. Она может быть:
    • путь к файлу, содержащему полный state dict модели
    • путь к файлу .json, содержащему индекс для шардированного контрольного пункта
    • путь к папке, содержащей уникальный файл .index.json и фрагменты контрольной точки.
    • путь к папке, содержащей уникальный файл pytorch_model.bin или model.safetensors.
  • device_map (Dict[str, Union[int, str, torch.device]], необязательный) — Карта, указывающая, на какое устройство следует поместить каждый подмодуль. Не требуется указывать её для каждого параметра/буфера по имени: как только имя модуля указано в карте, все его подмодули будут отправлены на то же устройство.
  • offload_folder (str или os.PathLike, необязательный) — Папка, в которую будут выгружаться веса, если device_map содержит значение "disk".
  • dtype (str или torch.dtype, необязательный) — Если указано, веса будут преобразованы в этот тип при загрузке.
  • offload_state_dict (bool, необязательный, по умолчанию False) — Если True, словарь состояния CPU будет временно выгружен на диск, чтобы избежать нехватки оперативной памяти CPU, если размер словаря состояния CPU и крупнейшего фрагмента не помещается в неё.
  • offload_buffers (bool, необязательный, по умолчанию False) — Включать ли буферы в веса, выгружаемые на диск.
  • keep_in_fp32_modules(List[str], необязательный) — Список модулей, которые мы сохраняем в типе данных torch.float32.
  • offload_8bit_bnb (bool, необязательный) — Включать ли offload 8-битных модулей на cpu/disk.
  • strict (bool, необязательный, по умолчанию False) — Определяет, следует ли строго требовать, чтобы ключи в state_dict контрольной точки совпадали с ключами state_dict модели.
  • full_state_dict (bool, необязательный, по умолчанию True) — если установлено значение True, все тензоры в загруженном state_dict будут собраны. В загруженном state_dict не будет ShardedTensor и DTensor.
  • broadcast_from_rank0 (False, необязательный, по умолчанию False) — если параметр установлен в True, необходимо инициализировать распределённую группу ProcessGroup. rank0 должен получить полный state_dict и последовательно рассылать тензоры из state_dict по одному на остальные ранги. Остальные ранги получают тензоры и, при необходимости, разбивают их на фрагменты в соответствии с локальными фрагментами в модели.

Загружает (возможно, разбитый на части) чекпоинт внутри модели, при необходимости отправляя веса на указанное устройство по мере их загрузки.

Once loaded across devices, you still need to call dispatch_model() on your model to make it able to run. To group the checkpoint loading and dispatch in one single call, use load_checkpoint_and_dispatch().

accelerate.utils.load_offloaded_weights

< >

( modelindexoffload_folder )

Параметры

  • model (torch.nn.Module) — Модель, в которую будут загружены веса.
  • index (dict) — Словарь, содержащий имя параметра и его метаданные для каждого параметра, выгруженного из модели.
  • offload_folder (str) — Папка, в которой хранятся выгруженные веса.

Загружает веса из папки offload в модель.

accelerate.utils.load_state_dict

< >

( checkpoint_filedevice_map = None )

Параметры

  • checkpoint_file (str) — Путь к контрольной точке для загрузки.
  • device_map (Dict[str, Union[int, str, torch.device]], необязательный) — Карта, указывающая, на какое устройство следует поместить каждый подмодуль. Не требуется указывать её для каждого параметра/буфера по имени: как только имя модуля указано в карте, все его подмодули будут отправлены на то же устройство.

Загрузить контрольную точку из указанного файла. Если контрольная точка в формате safetensors и передана карта устройств, веса можно быстро загрузить непосредственно на GPU.

accelerate.utils.offload_state_dict

< >

( save_dir: str | os.PathLikestate_dict: dict )

Параметры

  • save_dir (str или os.PathLike) — Каталог, в который выгружается state dict.
  • state_dict (Dict[str, torch.Tensor]) — Словарь тензоров для выгрузки.

Разместите state dict в указанной папке.

accelerate.utils.retie_parameters

< >

( modeltied_params )

Параметры

  • model (torch.nn.Module) — Модель, в которой необходимо перепривязать параметры.
  • tied_params (List[List[str]]) — Параметр отображения имени параметра на имя связанного с ним параметра, полученный с помощью find_tied_parameters.

Повторно связывает связанные параметры в указанной модели, если связь была нарушена (например, при добавлении хуков).

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 )

Параметры

  • module (torch.nn.Module) — Модуль, в котором находится тензор, который мы хотим переместить.
  • tensor_name (str) — Полное имя параметра/буфера.
  • device (int, str или torch.device) — Устройство, на котором следует разместить тензор.
  • value (torch.Tensor, необязательный) — Значение тензора (полезно при переходе с устройства meta на любое другое устройство).
  • dtype (torch.dtype, необязательный) — Если передано, значение параметра будет приведено к этому dtype. В противном случае value будет приведено к типу данных существующего параметра в модели.
  • fp16_statistics (torch.HalfTensor, необязательный) — Список статистики fp16 для установки на модуль, используется для сериализации модели в 8 бит.
  • tied_params_map (Dict[int, Dict[torch.device, torch.Tensor]], необязательный, по умолчанию None) — Сопоставление текущих указателей на данные со словарями устройств и уже распределённых связанных весов. Для данного устройства выполнения этот параметр полезен для повторного использования первого доступного указателя общего веса на устройстве для всех остальных, вместо дублирования памяти.
  • non_blocking (bool, необязательный, по умолчанию False) — Если True, передача на устройство выполняется асинхронно относительно хоста, если это возможно.
  • clear_cache (bool, необязательный, по умолчанию True) — Определяет, следует ли очищать кэш устройства после размещения тензора на устройстве.

Вспомогательная функция для перемещения заданного тензора (параметра или буфера) модуля на конкретное устройство (обратите внимание, что выполнение param.to(device) создает новый тензор, не связанный с параметром, поэтому эта функция необходима).

accelerate.utils.get_module_children_bottom_up

< >

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

Параметры

  • model (torch.nn.Module) — модель, для которой нужно получить дочерние элементы

Возвращает

list[torch.nn.Module]

список дочерних модулей model в порядке снизу вверх. Последний элемент — это model сам по себе.

Обходите модель в порядке снизу вверх и возвращайте дочерние модули в этом порядке.

Параллельно

К ним относятся общие утилиты, которые следует использовать при работе в параллельном режиме.

accelerate.utils.extract_model_from_parallel

< >

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

Параметры

  • model (torch.nn.Module) — Модель, из которой выполняется извлечение.
  • keep_fp32_wrapper (bool, необязательный) — Указывает, следует ли удалять хуки смешанной точности из модели.
  • keep_torch_compile (bool, необязательный) — Следует ли развернуть скомпилированную модель.
  • recursive (bool, необязательный, по умолчанию False) — Определяет, следует ли рекурсивно извлекать все случаи module.module из model, а также рекурсивно разворачивать дочерние подслои, а не только распределённые контейнеры верхнего уровня.

Возвращает

torch.nn.Module

Извлеченная модель.

Извлечение модели из её распределённых контейнеров.

accelerate.utils.save

< >

( objfsave_on_each_node: bool = Falsesafe_serialization: bool = False )

Параметры

  • obj — Данные для сохранения
  • f — Файл (или объект, похожий на файл), используемый для сохранения данных
  • save_on_each_node (bool, необязательный, по умолчанию False) — Сохранять ли данные только на глобальном главном процессе
  • safe_serialization (bool, необязательный, по умолчанию False) — Сохранять ли obj с помощью safetensors или традиционным способом PyTorch (с использованием pickle).

Сохраните данные на диск. Используйте вместо torch.save().

accelerate.utils.load

< >

( fmap_location = None**kwargs )

Параметры

  • f — Файл (или объект, похожий на файл), используемый для загрузки данных
  • map_location — функция, torch.device, строка или словарь, определяющие способ переназначения мест хранения
  • **kwargs — Дополнительные именованные аргументы для передачи в torch.load().

Совместимая замена torch.load(), позволяющая использовать weights_only, если версия torch равна 2.4.0 или выше. В противном случае этот аргумент будет проигнорирован.

Также будет добавлено (а затем удалено) исключение для массивов numpy

accelerate.utils.wait_for_everyone

< >

( )

Вводит точку блокировки в скрипте, гарантируя, что все процессы достигли этой точки перед продолжением выполнения.

Убедитесь, что все процессы дойдут до этой инструкции, иначе один из ваших процессов будет зависать навсегда.

Случайный

Эти утилиты связаны с установкой и синхронизацией всех случайных состояний.

accelerate.utils.set_seed

< >

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

Параметры

  • seed (int) — Значение seed для установки.
  • device_specific (bool, необязательный, по умолчанию False) — Определяет, следует ли слегка изменять seed на каждом устройстве с помощью self.process_index.
  • deterministic (bool, необязательный, по умолчанию False) — Использовать ли детерминированные алгоритмы, если они доступны. Может замедлить обучение.

Вспомогательная функция для воспроизводимого поведения: устанавливает seed в random, numpy, torch.

accelerate.utils.synchronize_rng_state

< >

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

accelerate.synchronize_rng_states

< >

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

PyTorch XLA

К ним относятся утилиты, полезные при использовании PyTorch с XLA.

accelerate.utils.install_xla

< >

( upgrade: bool = False )

Параметры

  • upgrade (bool, необязательный, по умолчанию False) — Указывает, следует ли обновить torch и установить последние колёса torch_xla.

Вспомогательная функция для установки соответствующих xla-колёс в зависимости от версии torch в Google Colaboratory.

Пример:

>>> from accelerate.utils import install_xla

>>> install_xla(upgrade=True)

Загрузка весов модели

Сюда входят утилиты, полезные для загрузки контрольных точек.

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 )

Параметры

  • model (torch.nn.Module) — Модель, в которую мы хотим загрузить контрольную точку.
  • checkpoint (str или os.PathLike) — Папка контрольной точки для загрузки. Она может быть:
    • путь к файлу, содержащему полный state dict модели
    • путь к файлу .json, содержащему индекс для шардированного контрольного пункта
    • путь к папке, содержащей уникальный файл .index.json и фрагменты контрольной точки.
    • путь к папке, содержащей уникальный файл pytorch_model.bin или model.safetensors.
  • device_map (Dict[str, Union[int, str, torch.device]], необязательный) — Карта, указывающая, на какое устройство следует поместить каждый подмодуль. Не требуется указывать её для каждого параметра/буфера по имени: как только имя модуля указано в карте, все его подмодули будут отправлены на то же устройство.
  • offload_folder (str или os.PathLike, необязательный) — Папка, в которую будут выгружаться веса, если device_map содержит значение "disk".
  • dtype (str или torch.dtype, необязательный) — Если указано, веса будут преобразованы в этот тип при загрузке.
  • offload_state_dict (bool, необязательный, по умолчанию False) — Если True, словарь состояния CPU будет временно выгружен на диск, чтобы избежать нехватки оперативной памяти CPU, если размер словаря состояния CPU и крупнейшего фрагмента не помещается в неё.
  • offload_buffers (bool, необязательный, по умолчанию False) — Включать ли буферы в веса, выгружаемые на диск.
  • keep_in_fp32_modules(List[str], необязательный) — Список модулей, которые мы сохраняем в типе данных torch.float32.
  • offload_8bit_bnb (bool, необязательный) — Включать ли offload 8-битных модулей на cpu/disk.
  • strict (bool, необязательный, по умолчанию False) — Определяет, следует ли строго требовать, чтобы ключи в state_dict контрольной точки совпадали с ключами state_dict модели.
  • full_state_dict (bool, необязательный, по умолчанию True) — если установлено значение True, все тензоры в загруженном state_dict будут собраны. В загруженном state_dict не будет ShardedTensor и DTensor.
  • broadcast_from_rank0 (False, необязательный, по умолчанию False) — если параметр установлен в True, необходимо инициализировать распределённую группу ProcessGroup. rank0 должен получить полный state_dict и последовательно рассылать тензоры из state_dict по одному на остальные ранги. Остальные ранги получают тензоры и, при необходимости, разбивают их на фрагменты в соответствии с локальными фрагментами в модели.

Загружает (возможно, разбитый на части) чекпоинт внутри модели, при необходимости отправляя веса на указанное устройство по мере их загрузки.

Once loaded across devices, you still need to call dispatch_model() on your model to make it able to run. To group the checkpoint loading and dispatch in one single call, use load_checkpoint_and_dispatch().

Квантование

Сюда входят утилиты, полезные для квантования модели.

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

Параметры

  • model (torch.nn.Module) — Входная модель. Модель может быть уже загружена или находиться на meta-устройстве
  • bnb_quantization_config (BnbQuantizationConfig) — Параметры квантования bitsandbytes
  • weights_location (str или os.PathLike) — Папка weights_location для загрузки. Она может быть:
    • путь к файлу, содержащему полный state dict модели
    • путь к файлу .json, содержащему индекс для шардированного контрольного пункта
    • путь к папке, содержащей уникальный файл .index.json и фрагменты контрольной точки.
    • путь к папке, содержащей уникальный файл pytorch_model.bin.
  • device_map (Dict[str, Union[int, str, torch.device]], необязательный) — Карта, указывающая, на какое устройство следует поместить каждый подмодуль. Не требуется указывать её для каждого параметра/буфера по имени: как только имя модуля указано в карте, все его подмодули будут отправлены на то же устройство.
  • no_split_module_classes (List[str], необязательный) — Список имён классов слоёв, которые никогда не следует разделять между устройствами (например, любой слой, имеющий остаточное соединение).
  • max_memory (Dict, необязательный) — Словарь, сопоставляющий идентификатор устройства с максимальным объёмом памяти. Если не задано, по умолчанию используется максимально доступная память.
  • offload_folder (str или os.PathLike, необязательный) — Папка, в которую будут выгружаться веса, если device_map содержит значение "disk".
  • offload_state_dict (bool, необязательный, по умолчанию False) — Если True, словарь состояния CPU будет временно выгружен на диск, чтобы избежать нехватки оперативной памяти CPU, если размер словаря состояния CPU и крупнейшего фрагмента не помещается в неё.

Возвращает

torch.nn.Module

Квантованная модель

Эта функция выполняет квантование входной модели с использованием связанной конфигурации, переданной в bnb_quantization_config. Если модель находится на мета-устройстве, мы загрузим и распределим веса в соответствии с переданным device_map. Если модель уже загружена, мы выполним её квантование и переместим модель на GPU,

Update on GitHub

←FP8 Утилиты Megatron-LM→