Accelerate documentation
Ускоритель
Ускоритель
Класс Accelerator является основным для организации распределённого обучения на любом типе конфигурации обучения. Прочитайте учебник Добавление Accelerator в ваш код, чтобы узнать, как добавить Accelerator в ваш скрипт.
Ускоритель
класс accelerate.Accelerator
< source >( device_placement: bool = Truesplit_batches: bool = <object object at 0x7f7bf6a755a0>mixed_precision: PrecisionType | str | None = Nonegradient_accumulation_steps: int = 1cpu: bool = Falsedataloader_config: DataLoaderConfiguration | None = Nonedeepspeed_plugin: DeepSpeedPlugin | dict[str, DeepSpeedPlugin] | None = Nonefsdp_plugin: FullyShardedDataParallelPlugin | None = Nonetorch_tp_plugin: TorchTensorParallelPlugin | None = Nonemegatron_lm_plugin: MegatronLMPlugin | None = Nonerng_types: list[str | RNGType] | None = Nonelog_with: str | LoggerType | GeneralTracker | list[str | LoggerType | GeneralTracker] | None = Noneproject_dir: str | os.PathLike | None = Noneproject_config: ProjectConfiguration | None = Nonegradient_accumulation_plugin: GradientAccumulationPlugin | None = Nonestep_scheduler_with_optimizer: bool = Truekwargs_handlers: list[KwargsHandler] | None = Nonedynamo_backend: DynamoBackend | str | None = Nonedynamo_plugin: TorchDynamoPlugin | None = Nonedeepspeed_plugins: DeepSpeedPlugin | dict[str, DeepSpeedPlugin] | None = Noneparallelism_config: ParallelismConfig | None = None )
Параметры
- device_placement (
bool, необязательный, по умолчаниюTrue) — Определяет, должен ли акселератор размещать объекты на устройстве (тензоры, возвращаемые загрузчиком данных, модель и т. д.). - mixed_precision (
str, необязательный) — Использовать ли обучение с смешанной точностью. Выберите ‘no’, ‘fp16’, ‘bf16’ или ‘fp8’. По умолчанию используется значение переменной окруженияACCELERATE_MIXED_PRECISION, которое использует значение по умолчанию в конфигурации accelerate текущей системы или флаг, переданный с командойaccelerate.launch. Для ‘fp8’ требуется установка transformers-engine. - gradient_accumulation_steps (
int, необязательный, по умолчанию 1) — Количество шагов, которое должно пройти до накопления градиентов. Значение > 1 следует использовать в сочетании сAccelerator.accumulate. Если не передано, будет использовано значение из переменной окруженияACCELERATE_GRADIENT_ACCUMULATION_STEPS. Также можно настроить черезGradientAccumulationPlugin. - cpu (
bool, необязательный) — Указывает, следует ли принудительно выполнять скрипт на CPU. Если установлено вTrue, доступный GPU будет игнорироваться, а выполнение будет ограничено одним процессом. - dataloader_config (
DataLoaderConfiguration, необязательный) — Конфигурация, определяющая, как следует обрабатывать загрузчики данных в распределённых сценариях. - deepspeed_plugin (DeepSpeedPlugin или словарь
str— DeepSpeedPlugin, необязательный): Настройте аргументы, связанные с DeepSpeed, с помощью этого параметра. Этот параметр необязательный и может быть настроен напрямую с помощью accelerate config. При использовании нескольких плагинов используйте настроенное свойствоkeyкаждого плагина для доступа к ним черезaccelerator.state.get_deepspeed_plugin(key). Псевдоним дляdeepspeed_plugins. - fsdp_plugin (FullyShardedDataParallelPlugin, необязательный) — Настройте аргументы, связанные с FSDP, с помощью этого параметра. Этот параметр необязателен и может быть настроен напрямую с помощью accelerate config
- torch_tp_plugin (
TorchTensorParallelPlugin, необязательный) — Устарело: используйтеparallelism_configсtp_size. - megatron_lm_plugin (MegatronLMPlugin, необязательный) — Настройте аргументы, связанные с MegatronLM, с помощью этого параметра. Этот параметр необязательный и может быть настроен напрямую с помощью accelerate config
- rng_types (список
strили RNGType) — Список генераторов случайных чисел, которые необходимо синхронизировать в начале каждой итерации в подготовленных вами загрузчиках данных. Должен содержать один или несколько из следующих элементов:"torch": базовый генератор случайных чисел torch"cuda": генератор случайных чисел CUDA (только GPU)- Тип устройства любого зарегистрированного ускорителя PyTorch: его генератор случайных чисел для устройства.
"xla": генератор случайных чисел XLA (только TPU)"generator":torch.Generatorсэмплера (или батч-сэмплера, если в вашем dataloader нет сэмплера) или итерируемого датасета (если он существует), если базовый датасет имеет соответствующий тип.
По умолчанию будет
["torch"]для версий PyTorch <=1.5.1 и["generator"]для версий PyTorch >= 1.6. - log_with (список
str, LoggerType или GeneralTracker, необязательный) — Список логгеров для настройки отслеживания экспериментов. Должен содержать один или несколько из:"all""tensorboard""wandb""trackio""aim""comet_ml""mlflow""dvclive""swanlab"Если выбрано значение"all", будут обнаружены и инициализированы все доступные в окружении трекеры. Также можно передавать реализацииGeneralTrackerдля пользовательских трекеров, и это можно комбинировать с"all".
- project_config (ProjectConfiguration, необязательный) — Конфигурация, определяющая способ обработки сохранения состояния.
- project_dir (
str,os.PathLike, необязательный) — Путь к каталогу для хранения данных, таких как журналы локально-совместимых логгеров и потенциально сохранённые контрольные точки. - step_scheduler_with_optimizer (
bool, необязательный, по умолчаниюTrue) — УстановитеTrue, если планировщик скорости обучения обновляется одновременно с оптимизатором, иFalse, если это происходит только в определённых обстоятельствах (например, в конце каждой эпохи). - kwargs_handlers (список KwargsHandler, необязательный) — Список KwargsHandler для настройки создания объектов, связанных с распределённым обучением, профилированием или смешанной точностью. Подробнее см. kwargs.
- dynamo_backend (
strили DynamoBackend, необязательный, по умолчанию"no") — Укажите один из доступных dynamo backends для оптимизации обучения с помощью torch dynamo. - dynamo_plugin (TorchDynamoPlugin, необязательный) —
Настройка того, как следует обрабатывать torch dynamo, если требуется более тонкая настройка, чем просто
backendилиmode. - gradient_accumulation_plugin (GradientAccumulationPlugin, необязательный) —
Настройка того, как следует обрабатывать накопление градиентов, если требуется более тонкая настройка, чем просто
gradient_accumulation_steps.
Создаёт экземпляр ускорителя для распределённого обучения или обучения с смешанной точностью.
Доступные атрибуты:
- device (
torch.device) — Устройство, которое будет использоваться. - distributed_type (DistributedType) — конфигурация распределённого обучения.
- local_process_index (
int) — Индекс процесса на текущей машине. - mixed_precision (
str) — Настроенный режим смешанной точности. - num_processes (
int) — Общее количество процессов, используемых для обучения. - optimizer_step_was_skipped (
bool) — Указывает, был ли пропущен шаг обновления оптимизатора (из-за переполнения градиентов при смешанной точности), в этом случае скорость обучения не должна изменяться. - process_index (
int) — Общий индекс текущего процесса среди всех процессов. - state (AcceleratorState) — Состояние распределённой конфигурации.
- sync_gradients (
bool) — Указывает, синхронизируются ли градиенты между всеми процессами в данный момент. - use_distributed (
bool) — Указывает, настроена ли текущая конфигурация для распределённого обучения.
accumulate
< source >( *models )
Контекстный менеджер, который автоматически выполняет накопление градиентов
Пример:
>>> from accelerate import Accelerator
>>> accelerator = Accelerator(gradient_accumulation_steps=1)
>>> dataloader, model, optimizer, scheduler = accelerator.prepare(dataloader, model, optimizer, scheduler)
>>> for input, output in dataloader:
... with accelerator.accumulate(model):
... outputs = model(input)
... loss = loss_func(outputs)
... loss.backward()
... optimizer.step()
... scheduler.step()
... optimizer.zero_grad()Если включено, внутри этого контекстного менеджера в блоке будет применяться автоматическое смешанное разрешение. В противном случае ничего не изменится.
В качестве autocast_handler можно передать другой, чтобы переопределить тот, что задан в объекте Accelerator. Это полезно в блоках под autocast, где требуется вернуться к fp32.
Масштабирует градиенты в соответствии с GradientAccumulationPlugin и вызывает правильный backward() на основе конфигурации.
Должно использоваться вместо loss.backward().
Проверяет, установлен ли внутренний тензор триггера в 1 в каком-либо из процессов. Если да, возвращает True и сбрасывает тензор триггера в 0.
Примечание:
Не требует wait_for_everyone()
Пример:
>>> from accelerate import Accelerator
>>> accelerator = Accelerator()
>>> # Assume later in the training script
>>> # `should_do_breakpoint` is a custom function to monitor when to break,
>>> # e.g. when the loss is NaN
>>> if should_do_breakpoint(loss):
... accelerator.set_trigger()
>>> # Assume later in the training script
>>> if accelerator.check_trigger():
... breakПсевдоним для Accelerate.free_memory, освобождает все ссылки на внутренние объекты и вызывает сборщик мусора. Вы должны вызывать этот метод между двумя тренировками с разными моделями/оптимизаторами.
clip_grad_norm_
< source >( parametersmax_normnorm_type = 2 ) → torch.Tensor
Возвращает
torch.Tensor
Суммарная норма градиентов параметров (рассматриваемых как единый вектор).
Должен использоваться вместо torch.nn.utils.clip_grad_norm_.
Пример:
>>> from accelerate import Accelerator
>>> accelerator = Accelerator(gradient_accumulation_steps=2)
>>> dataloader, model, optimizer, scheduler = accelerator.prepare(dataloader, model, optimizer, scheduler)
>>> for input, target in dataloader:
... optimizer.zero_grad()
... output = model(input)
... loss = loss_func(output, target)
... accelerator.backward(loss)
... if accelerator.sync_gradients:
... accelerator.clip_grad_norm_(model.parameters(), max_grad_norm)
... optimizer.step()Должен использоваться вместо torch.nn.utils.clip_grad_value_.
Пример:
>>> from accelerate import Accelerator
>>> accelerator = Accelerator(gradient_accumulation_steps=2)
>>> dataloader, model, optimizer, scheduler = accelerator.prepare(dataloader, model, optimizer, scheduler)
>>> for input, target in dataloader:
... optimizer.zero_grad()
... output = model(input)
... loss = loss_func(output, target)
... accelerator.backward(loss)
... if accelerator.sync_gradients:
... accelerator.clip_grad_value_(model.parameters(), clip_value)
... optimizer.step()обычно это вызывается как часть prepare, но когда dataloader был подготовлен отдельно от модели (для внешнего вызова accelerator.prepare), этот дополнительный вызов необходимо выполнить после prepare(model) (см. HF Trainer в качестве примера использования)
Выполняет специальные действия в конце обучения, например, остановку трекеров только в основном процессе или уничтожение группы процессов. Всегда следует вызывать в конце вашего скрипта при использовании отслеживания экспериментов.
Отпустит все ссылки на внутренние объекты и вызовет сборщик мусора. Этот метод следует вызывать между двумя тренировками с разными моделями/оптимизаторами. Также сбросит Accelerator.step до 0.
gather
< source >( tensor ) → torch.Tensor, or a nested tuple/list/dictionary of torch.Tensor
Параметры
- tensor (
torch.Tensorили вложенный кортеж/список/словарь изtorch.Tensor) — Тензоры, которые нужно собрать со всех процессов.
Возвращает
torch.Tensor или вложенный кортеж/список/словарь из torch.Tensor
Собранный тензор (тензоры). Обратите внимание, что первое измерение результата равно num_processes, умноженному на первое измерение входных тензоров.
Собирает значения из tensor со всех процессов и конкатенирует их по первому измерению. Полезно для группировки предсказаний со всех процессов при выполнении оценки.
Примечание: Эта операция сбора выполняется во всех процессах.
Пример:
>>> # Assuming four processes
>>> import torch
>>> from accelerate import Accelerator
>>> accelerator = Accelerator()
>>> process_tensor = torch.tensor([accelerator.process_index], device=accelerator.device)
>>> gathered_tensor = accelerator.gather(process_tensor)
>>> gathered_tensor
tensor([0, 1, 2, 3])gather_for_metrics
< source >( input_datause_gather_object = False )
Параметры
- input_data (
torch.Tensor,object, вложенный кортеж/список/словарь изtorch.Tensorили вложенный кортеж/список/словарь изobject) — Тензоры или объекты для вычисления метрик во всех процессах - use_gather_object(
bool) — Следует ли принудительно использовать gather_object вместо gather (что уже выполняется, если все переданные объекты не содержат тензоров). Этот флаг может быть полезен для сбора тензоров разного размера, которые мы не хотим дополнять нулями и конкатенировать по первому измерению. Использование с тензорами на GPU поддерживается плохо и неэффективно, так как требует передачи GPU -> CPU, поскольку тензоры будут сериализованы.
Собирает input_data и при необходимости удаляет дубликаты в последней партии, если система распределённая. Следует использовать для сбора входных данных и целевых значений для вычисления метрик.
Пример:
>>> # Assuming two processes, with a batch size of 5 on a dataset with 9 samples
>>> import torch
>>> from accelerate import Accelerator
>>> accelerator = Accelerator()
>>> dataloader = torch.utils.data.DataLoader(range(9), batch_size=5)
>>> dataloader = accelerator.prepare(dataloader)
>>> batch = next(iter(dataloader))
>>> gathered_items = accelerator.gather_for_metrics(batch)
>>> len(gathered_items)
9get_state_dict
< source >( modelunwrap = True ) → dict
Параметры
- model (
torch.nn.Module) — Модель PyTorch, переданная через Accelerator.prepare() - unwrap (
bool, необязательный, по умолчаниюTrue) — Определяет, следует ли вернуть исходный базовый state_dict объектаmodelили вернуть обёрнутый state_dict
Возвращает
dict
Словарь состояний модели, потенциально без полной точности.
Возвращает словарь состояния модели, переданной через Accelerator.prepare(), возможно, без полного разрешения.
get_tracker
< source >( name: strunwrap: bool = False ) → GeneralTracker
Возвращает tracker из self.trackers на основе name только в основном процессе.
join_uneven_inputs
< source >( joinableseven_batches = None )
Параметры
- joinables (
list[torch.distributed.algorithms.Joinable]) — Список моделей или оптимизаторов, являющихся подклассамиtorch.distributed.algorithms.Joinable. Как правило, это PyTorch Module, подготовленный с помощьюAccelerator.prepareдля обучения в режиме DistributedDataParallel. - even_batches (
bool, необязательный) — Если задано, это значение переопределяет параметрeven_batches, установленный вAccelerator. Если не указано, будет использовано значение по умолчаниюAccelerator.
Контекстный менеджер, облегчающий распределённое обучение или оценку на неравномерных входных данных, который выступает в роли обёртки вокруг torch.distributed.algorithms.join. Это полезно, когда общий размер батча не делится нацело на длину набора данных.
join_uneven_inputsподдерживается только для обучения с распределённым параллелизмом данных (Distributed Data Parallel) на нескольких GPU. При любой другой конфигурации этот метод не будет иметь эффекта.
Переопределение
even_batchesне повлияет на загрузчики данных итеративного типа.
Пример:
>>> from accelerate import Accelerator
>>> accelerator = Accelerator(even_batches=True)
>>> ddp_model, optimizer, dataloader = accelerator.prepare(model, optimizer, dataloader)
>>> with accelerator.join_uneven_inputs([ddp_model], even_batches=False):
... for input, output in dataloader:
... outputs = model(input)
... loss = loss_func(outputs)
... loss.backward()
... optimizer.step()
... optimizer.zero_grad()load_state
< source >( input_dir: str | None = Noneload_kwargs: dict | None = None**load_model_func_kwargs )
Параметры
- input_dir (
strилиos.PathLike) — Имя папки, в которой были сохранены все соответствующие веса и состояния. Может бытьNone, если используетсяautomatic_checkpoint_naming, в этом случае будут загружены данные из последней контрольной точки. - load_kwargs (
dict, необязательный) — Дополнительные именованные аргументы для внутренней функцииload, например, необязательные аргументы для state_dict и optimizer. - load_model_func_kwargs (
dict, необязательный) — Дополнительные именованные аргументы для загрузки модели, которые могут быть переданы в базовую функцию загрузки, например, необязательные аргументы для функцииload_checkpointDeepSpeed илиmap_locationдля загрузки модели и оптимизатора.
Загружает текущие состояния модели, оптимизатора, масштабирующего коэффициента, генераторов случайных чисел и зарегистрированных объектов.
Должно использоваться только в связке с Accelerator.save_state(). Если файл не зарегистрирован для создания контрольных точек, он не будет загружен, даже если хранится в каталоге.
Позволяет локальному основному процессу войти в блок with.
Остальные процессы войдут в блок with после завершения основного процесса.
Пример:
>>> from accelerate import Accelerator
>>> accelerator = Accelerator()
>>> with accelerator.local_main_process_first():
... # This will be printed first by local process 0 then in a seemingly
... # random order by the other processes.
... print(f"This will be printed by process {accelerator.local_process_index}")Выполняет обратный проход для оптимизаторов LOMO.
Позволяет основному процессу выполняться первым внутри блока with.
Остальные процессы войдут в блок with после завершения основного процесса.
Пример:
>>> from accelerate import Accelerator
>>> accelerator = Accelerator()
>>> with accelerator.main_process_first():
... # This will be printed first by process 0 then in a seemingly
... # random order by the other processes.
... print(f"This will be printed by process {accelerator.process_index}")maybe_context_parallel
< source >( buffers: list[torch.Tensor] | None = Nonebuffer_seq_dims: list[int] | None = Noneno_restore_buffers: set[torch.Tensor] | None = None )
Параметры
- buffers (
list[torch.Tensor],optional) — Буферы, которые будут разбиты на части вдоль измерения последовательности. Типичные примеры — входные данные, метки или буферы позиционных эмбеддингов. Этот контекстный менеджер будет изменять эти буферы на месте, а после выхода из контекста буферы будут восстановлены в исходное состояние. Чтобы избежать ненужных восстановлений, можно использоватьno_restore_buffers, чтобы указать, какие буферы не нужно восстанавливать. - buffer_seq_dims (
list[int],optional) — Размерности последовательности дляbuffers. - no_restore_buffers (
set[torch.Tensor],optional) — Этот набор должен быть подмножествомbuffers. Указывает, какие буферы из аргументаbuffersне будут восстановлены после выхода из контекста. Эти буферы будут оставаться в шардированном состоянии.
Контекстный менеджер, обеспечивающий обучение с параллелизмом контекста.
context_parallelв настоящее время поддерживается с FSDP2 и требуетparallelism_config.cp_size>
- Если ни одно из этих условий не выполняется, этот менеджер контекста не будет иметь эффекта, однако, чтобы минимизировать изменения в коде, он не будет вызывать исключение.
Этот контекстный менеджер необходимо создавать заново на каждом шаге обучения, как показано в примере ниже.
no_sync
< source >( model )
Контекстный менеджер для отключения синхронизации градиентов между процессами DDP с помощью вызова torch.nn.parallel.DistributedDataParallel.no_sync.
Если model не находится в DDP, этот контекстный менеджер ничего не делает
Пример:
>>> from accelerate import Accelerator
>>> accelerator = Accelerator()
>>> dataloader, model, optimizer = accelerator.prepare(dataloader, model, optimizer)
>>> input_a = next(iter(dataloader))
>>> input_b = next(iter(dataloader))
>>> with accelerator.no_sync():
... outputs = model(input_a)
... loss = loss_func(outputs)
... accelerator.backward(loss)
... # No synchronization across processes, only accumulate gradients
>>> outputs = model(input_b)
>>> accelerator.backward(loss)
>>> # Synchronization across all processes
>>> optimizer.step()
>>> optimizer.zero_grad()on_last_process
< source >( function: Callable[..., Any] )
Декоратор, который выполняет декорируемую функцию только на последнем процессе. Также может быть вызван с использованием класса PartialState.
on_local_main_process
< source >( function: Callable[..., Any] | None = None )
Декоратор, который выполняет декорируемую функцию только в локальном главном процессе. Также может вызываться с помощью класса PartialState.
Пример:
# Assume we have 2 servers with 4 processes each.
from accelerate import Accelerator
accelerator = Accelerator()
@accelerator.on_local_main_process
def print_something():
print("This will be printed by process 0 only on each server.")
print_something()
# On server 1:
"This will be printed by process 0 only"
# On server 2:
"This will be printed by process 0 only"on_local_process
< source >( function: Callable[..., Any] | None = Nonelocal_process_index: int | None = None )
Декоратор, который выполняет декорируемую функцию только на указанном локальном индексе процесса. Также может вызываться с помощью класса PartialState.
Пример:
# Assume we have 2 servers with 4 processes each.
from accelerate import Accelerator
accelerator = Accelerator()
@accelerator.on_local_process(local_process_index=2)
def print_something():
print(f"Printed on process {accelerator.local_process_index}")
print_something()
# On server 1:
"Printed on process 2"
# On server 2:
"Printed on process 2"on_main_process
< source >( function: Callable[..., Any] | None = None )
Декоратор, который выполняет декорируемую функцию только в основном процессе. Также может вызываться с помощью класса PartialState.
on_process
< source >( function: Callable[..., Any] | None = Noneprocess_index: int | None = None )
Декоратор, который выполняет декорируемую функцию только на процессе с указанным индексом. Также может вызываться с помощью класса PartialState.
pad_across_processes
< source >( tensordim = 0pad_index = 0pad_first = False ) → torch.Tensor, or a nested tuple/list/dictionary of torch.Tensor
Параметры
- tensor (вложенный список/кортеж/словарь из
torch.Tensor) — Данные для сбора. - dim (
int, необязательный, по умолчанию 0) — Размерность, по которой выполняется дополнение. - pad_index (
int, необязательный, по умолчанию 0) — Значение, используемое для дополнения. - pad_first (
bool, необязательный, по умолчаниюFalse) — Определяет, добавлять ли заполнители в начале или в конце.
Возвращает
torch.Tensor или вложенный кортеж/список/словарь из torch.Tensor
Тензор(ы) с дополнением (padding).
Рекурсивно дополните тензоры в вложенном списке/кортеже/словаре тензоров со всех устройств до одинакового размера, чтобы их можно было безопасно собрать.
Пример:
>>> # Assuming two processes, with the first processes having a tensor of size 1 and the second of size 2
>>> import torch
>>> from accelerate import Accelerator
>>> accelerator = Accelerator()
>>> process_tensor = torch.arange(accelerator.process_index + 1).to(accelerator.device)
>>> padded_tensor = accelerator.pad_across_processes(process_tensor)
>>> padded_tensor.shape
torch.Size([2])prepare
< source >( *argsdevice_placement = None )
Параметры
- *args (список объектов) —
Любой из следующих типов объектов:
torch.utils.data.DataLoader: загрузчик данных PyTorchtorch.nn.Module: модуль PyTorchtorch.optim.Optimizer: Оптимизатор PyTorchtorch.optim.lr_scheduler.LRScheduler: планировщик LR в PyTorch
- device_placement (
list[bool], необязательный) — Используется для настройки того, следует ли выполнять автоматическое размещение на устройстве для каждого переданного объекта. Должен представлять собой список той же длины, что иargs. Не совместим с DeepSpeed или FSDP.
Подготовьте все объекты, переданные в args, для распределённого обучения и смешанной точности, затем верните их в том же порядке.
Вам не нужно готовить модель, если вы используете её только для инференса без какого-либо смешанного точности
Примеры:
>>> from accelerate import Accelerator
>>> accelerator = Accelerator()
>>> # Assume a model, optimizer, data_loader and scheduler are defined
>>> model, optimizer, data_loader, scheduler = accelerator.prepare(model, optimizer, data_loader, scheduler)>>> from accelerate import Accelerator
>>> accelerator = Accelerator()
>>> # Assume a model, optimizer, data_loader and scheduler are defined
>>> device_placement = [True, True, False, False]
>>> # Will place the first two items passed in automatically to the right device but not the last two.
>>> model, optimizer, data_loader, scheduler = accelerator.prepare(
... model, optimizer, data_loader, scheduler, device_placement=device_placement
... )prepare_data_loader
< source >( data_loader: torch.utils.data.DataLoaderdevice_placement = Noneslice_fn_for_dispatch = None )
Параметры
- data_loader (
torch.utils.data.DataLoader) — обычный PyTorch DataLoader для подготовки - device_placement (
bool, необязательный) — Определяет, следует ли размещать батчи на соответствующем устройстве в подготовленном загрузчике данных. По умолчанию используется значениеself.device_placement. - slice_fn_for_dispatch (
Callable, optional) -- If passed, this function will be used to slice tensors acrossnum_processes. Will default to [slice_tensors()](/docs/accelerate/v1.16.0/en/package_reference/utilities#accelerate.utils.slice_tensors). This argument is used only whendispatch_batchesis set toTrue` and will be ignored otherwise.
Готовит PyTorch DataLoader для обучения в любом распределённом окружении. Рекомендуется использовать Accelerator.prepare().
prepare_model
< source >( model: torch.nn.Moduledevice_placement: bool | None = Noneevaluation_mode: bool = False )
Параметры
- model (
torch.nn.Module) — Модель PyTorch, которую нужно подготовить. Подготавливать модель не нужно, если она используется только для инференса без какого-либо смешанного точности - device_placement (
bool, необязательный) — Определяет, следует ли размещать модель на соответствующем устройстве. По умолчанию используется значениеself.device_placement. - evaluation_mode (
bool, необязательный, по умолчаниюFalse) — Определяет, следует ли переводить модель только в режим оценки, применяя смешанную точность иtorch.compile(если это настроено в объектеAccelerator).
Готовит модель PyTorch для обучения в любом распределённом окружении. Рекомендуется использовать Accelerator.prepare() вместо этого.
prepare_optimizer
< source >( optimizer: torch.optim.Optimizerdevice_placement = None )
Подготавливает оптимизатор PyTorch для обучения в любом распределённом окружении. Рекомендуется использовать Accelerator.prepare().
prepare_scheduler
< source >( scheduler: LRScheduler )
Готовит планировщик PyTorch для обучения в любом распределённом окружении. Рекомендуется использовать Accelerator.prepare().
Замена print(), чтобы печатать только один раз на сервер.
профиль
< source >( profile_handler: ProfileKwargs | None = None )
Профилирует код внутри контекстного менеджера. Профиль сохраняется в файл Chrome Trace, если задан profile_handler.output_trace_dir.
Можно передать другой profile_handler, чтобы переопределить тот, что установлен в объекте Accelerator.
Пример:
# Profile with default settings
from accelerate import Accelerator
from accelerate.utils import ProfileKwargs
accelerator = Accelerator()
with accelerator.profile() as prof:
train()
accelerator.print(prof.key_averages().table())
# Profile with the custom handler
def custom_handler(prof):
print(prof.key_averages().table(sort_by="self_cpu_time_total", row_limit=10))
kwargs = ProfileKwargs(schedule_option=dict(wait=1, warmup=1, active=1), on_trace_ready=custom_handler)
accelerator = Accelerator(kwarg_handler=[kwargs])
with accelerator.profile() as prof:
for _ in range(10):
train_iteration()
prof.step()
# Profile and export to Chrome Trace
kwargs = ProfileKwargs(output_trace_dir="output_trace")
accelerator = Accelerator(kwarg_handler=[kwargs])
with accelerator.profile():
train()reduce
< source >( tensorreduction = 'sum'scale = 1.0 ) → torch.Tensor, or a nested tuple/list/dictionary of torch.Tensor
Параметры
- tensor (
torch.Tensorили вложенный кортеж/список/словарь изtorch.Tensor) — Тензоры, которые нужно свести по всем процессам. - reduction (
str, необязательный, по умолчанию “sum”) — Тип агрегации, может быть одним из ‘sum’, ‘mean’, ‘max’ или ‘none’. Если указано ‘none’, никакие операции не выполняются. - scale (
float, необязательный, по умолчанию 1.0) — Значение масштабирования по умолчанию, применяемое после reduce; действует только на XLA.
Возвращает
torch.Tensor или вложенный кортеж/список/словарь из torch.Tensor
Сокращенный тензор(ы).
Суммируйте значения в tensor по всем процессам на основе reduction.
Примечание: Все процессы получают уменьшенное значение.
Пример:
>>> # Assuming two processes
>>> import torch
>>> from accelerate import Accelerator
>>> accelerator = Accelerator()
>>> process_tensor = torch.arange(accelerator.num_processes) + 1 + (2 * accelerator.process_index)
>>> process_tensor = process_tensor.to(accelerator.device)
>>> reduced_tensor = accelerator.reduce(process_tensor, reduction="sum")
>>> reduced_tensor
tensor([4, 6])Делает запись об объектах objects и сохраняет или загружает их во время вызова save_state или load_state.
Их следует использовать при загрузке или сохранении состояния в том же скрипте. Они не предназначены для использования в разных скриптах.
Каждый
objectдолжен иметь функцииload_state_dictиstate_dictдля сохранения.
register_load_state_pre_hook
< source >( hook: Callable[..., None] ) → torch.utils.hooks.RemovableHandle
Параметры
- hook (
Callable) — Функция, вызываемая в Accelerator.load_state() передload_checkpoint.
Возвращает
torch.utils.hooks.RemovableHandle
обработчик, с помощью которого можно удалить добавленный хук, вызвав
handle.remove()
Регистрирует предварительный хук, который выполняется перед вызовом load_checkpoint в Accelerator.load_state().
Хук должен иметь следующую сигнатуру:
hook(models: list[torch.nn.Module], input_dir: str) -> None
Аргумент models — это модели, сохранённые в состоянии акселератора под ключом accelerator._models, а аргумент input_dir — это аргумент input_dir, переданный в Accelerator.load_state().
Должно использоваться только в связке с Accelerator.register_save_state_pre_hook(). Может быть полезно для загрузки конфигураций в дополнение к весам модели. Также можно использовать для переопределения загрузки модели с помощью кастомизированного метода. В этом случае убедитесь, что удалили уже загруженные модели из списка моделей.
register_save_state_pre_hook
< source >( hook: Callable[..., None] ) → torch.utils.hooks.RemovableHandle
Параметры
- hook (
Callable) — Функция, вызываемая в Accelerator.save_state() передsave_checkpoint.
Возвращает
torch.utils.hooks.RemovableHandle
обработчик, с помощью которого можно удалить добавленный хук, вызвав
handle.remove()
Регистрирует предварительный хук, который выполняется перед вызовом save_checkpoint в Accelerator.save_state().
Хук должен иметь следующую сигнатуру:
hook(models: list[torch.nn.Module], weights: list[dict[str, torch.Tensor]], input_dir: str) -> None
Аргумент models — это модели, сохранённые в состоянии акселератора под ключом accelerator._models, аргумент weights — это словари состояний для models, а аргумент input_dir — это аргумент input_dir, переданный в Accelerator.load_state().
Должен использоваться только в связке с Accelerator.register_load_state_pre_hook(). Может быть полезен для сохранения конфигураций в дополнение к весам модели. Также можно использовать для переопределения сохранения модели с помощью кастомного метода. В этом случае убедитесь, что удалили уже загруженные веса из списка весов.
сохранить
< source >( objfsafe_serialization = False )
Сохраняйте объект, переданный на диск, один раз на машину. Используйте вместо torch.save.
Примечание:
Если save_on_each_node был передан в качестве ProjectConfiguration, объект будет сохраняться один раз на каждом узле, а не только один раз на основном узле.
save_model
< source >( model: torch.nn.Modulesave_directory: Union[str, os.PathLike]max_shard_size: Union[int, str] = '10GB'safe_serialization: bool = True )
Параметры
- model — (
torch.nn.Module): Модель, которую нужно сохранить. Модель может быть обёрнута или не обёрнута. - save_directory (
strилиos.PathLike) — Каталог для сохранения. Будет создан, если не существует. - max_shard_size (
intилиstr, необязательный, по умолчанию"10GB") — Максимальный размер чекпоинта перед его разбиением на части. Каждая часть чекпоинта будет иметь размер, меньший этого значения. Если значение указано в виде строки, оно должно состоять из цифр и единицы измерения (например,"5MB").Если вес модели превышает
max_shard_size, он будет размещен в отдельном фрагменте контрольной точки, размер которого превыситmax_shard_size. - safe_serialization (
bool, необязательный, по умолчаниюTrue) — Определяет, сохранять ли модель с помощьюsafetensorsили традиционным способом PyTorch (с использованиемpickle).
Сохраните модель так, чтобы её можно было загрузить с помощью load_checkpoint_in_model
save_state
< source >( output_dir: str | None = Nonesafe_serialization: bool = True**save_model_func_kwargs )
Параметры
- output_dir (
strилиos.PathLike) — Имя папки, в которой будут сохранены все соответствующие веса и состояния. - safe_serialization (
bool, необязательный, по умолчаниюTrue) — Определяет, сохранять ли модель с помощьюsafetensorsили традиционным способом PyTorch (с использованиемpickle). - save_model_func_kwargs (
dict, необязательный) — Дополнительные именованные аргументы для сохранения модели, которые могут быть переданы в базовую функцию сохранения, например необязательные аргументы для функцииsave_checkpointDeepSpeed.
Сохраняет текущие состояния модели, оптимизатора, масштабирующего коэффициента, генераторов случайных чисел и зарегистрированных объектов в папку.
Если объект Accelerator был передан с ProjectConfiguration, в котором включён automatic_checkpoint_naming,
то контрольные точки сохраняются в self.project_dir/checkpoints. Если количество текущих сохранений превышает
total_limit, самое старое сохранение удаляется. Каждая контрольная точка сохраняется в отдельной папке с именем checkpoint_<iteration>.
В противном случае они просто сохраняются в output_dir.
Должно использоваться только в том случае, если требуется сохранить контрольную точку во время обучения и восстановить состояние в той же среде.
Устанавливает внутреннее тензорное значение триггера в 1 на текущем процессе. За этим должно последовать проверка с использованием этого значения, которая будет выполнена на всех процессах.
Примечание:
Не требует wait_for_everyone()
Пример:
>>> from accelerate import Accelerator
>>> accelerator = Accelerator()
>>> # Assume later in the training script
>>> # `should_do_breakpoint` is a custom function to monitor when to break,
>>> # e.g. when the loss is NaN
>>> if should_do_breakpoint(loss):
... accelerator.set_trigger()
>>> # Assume later in the training script
>>> if accelerator.check_breakpoint():
... breakskip_first_batches
< source >( dataloadernum_batches: int = 0 )
Создаёт новый torch.utils.data.DataLoader, который эффективно пропускает первые num_batches.
Пример:
>>> from accelerate import Accelerator
>>> accelerator = Accelerator()
>>> dataloader, model, optimizer, scheduler = accelerator.prepare(dataloader, model, optimizer, scheduler)
>>> skipped_dataloader = accelerator.skip_first_batches(dataloader, num_batches=2)
>>> # for the first epoch only
>>> for input, target in skipped_dataloader:
... optimizer.zero_grad()
... output = model(input)
... loss = loss_func(output, target)
... accelerator.backward(loss)
... optimizer.step()
>>> # subsequent epochs
>>> for input, target in dataloader:
... optimizer.zero_grad()
... ...split_between_processes
< source >( inputs: list | tuple | dict | torch.Tensorapply_padding: bool = False )
Параметры
- inputs (
list,tuple,torch.Tensorилиdictизlist/tuple/torch.Tensor) — Входные данные для распределения между процессами. - apply_padding (
bool,optional, по умолчаниюFalse) — Следует ли применять выравнивание путём повторения последнего элемента входных данных, чтобы все процессы имели одинаковое количество элементов. Полезно при выполнении таких действий, какAccelerator.gather()над результатами или при передаче меньшего количества входных данных, чем количество процессов. Если это необходимо, не забудьте удалить дополненные элементы после завершения операции.
Разбивает input между self.num_processes быстро, после чего может использоваться на соответствующем процессе. Полезно при распределённом выводе, например, с разными промптами.
Обратите внимание, что при использовании dict все ключи должны содержать одинаковое количество элементов.
Пример:
# Assume there are two processes
from accelerate import Accelerator
accelerator = Accelerator()
with accelerator.split_between_processes(["A", "B", "C"]) as inputs:
print(inputs)
# Process 0
["A", "B"]
# Process 1
["C"]
with accelerator.split_between_processes(["A", "B", "C"], apply_padding=True) as inputs:
print(inputs)
# Process 0
["A", "B"]
# Process 1
["C", "C"]trigger_sync_in_backward
< source >( model )
Запустите синхронизацию градиентов в следующем обратном проходе модели после нескольких прямых проходов в режиме Accelerator.no_sync (применимо только в сценариях с несколькими GPU).
Если скрипт не запущен в распределённом режиме, этот менеджер контекста ничего не делает.
Пример:
>>> from accelerate import Accelerator
>>> accelerator = Accelerator()
>>> dataloader, model, optimizer = accelerator.prepare(dataloader, model, optimizer)
>>> with accelerator.no_sync():
... loss_a = loss_func(model(input_a)) # first forward pass
... loss_b = loss_func(model(input_b)) # second forward pass
>>> accelerator.backward(loss_a) # No synchronization across processes, only accumulate gradients
>>> with accelerator.trigger_sync_in_backward(model):
... accelerator.backward(loss_b) # Synchronization across all processes
>>> optimizer.step()
>>> optimizer.zero_grad()unscale_gradients
< source >( optimizer = None )
Параметры
- optimizer (
torch.optim.Optimizerилиlist[torch.optim.Optimizer], необязательный) — Оптимизатор(ы), для которых необходимо снять масштабирование градиентов. Если не задан, снимет масштабирование градиентов для всех оптимизаторов, переданных в prepare().
Убирает масштабирование градиентов при обучении с смешанной точностью с AMP. Во всех остальных режимах это операция без эффекта.
Скорее всего, следует вызывать через Accelerator.clipgrad_norm() или Accelerator.clipgrad_value()
unwrap_model
< source >( modelkeep_fp32_wrapper: bool = Truekeep_torch_compile: bool = True ) → torch.nn.Module
Параметры
- model (
torch.nn.Module) — Модель, которую нужно развернуть. - keep_fp32_wrapper (
bool, необязательный, по умолчаниюTrue) — Определяет, следует ли не удалять хук смешанной точности, если он был добавлен. - keep_torch_compile (
bool, необязательный, по умолчаниюTrue) — Определяет, следует ли не разворачивать скомпилированную модель, если она была скомпилирована.
Возвращает
torch.nn.Module
Развернутая модель.
Убирает model из дополнительного слоя, который мог быть добавлен методом prepare(). Полезно перед сохранением модели.
Пример:
>>> # Assuming two GPU processes
>>> from torch.nn.parallel import DistributedDataParallel
>>> from accelerate import Accelerator
>>> accelerator = Accelerator()
>>> model = accelerator.prepare(MyModel())
>>> print(model.__class__.__name__)
DistributedDataParallel
>>> model = accelerator.unwrap_model(model)
>>> print(model.__class__.__name__)
MyModelПроверяет, что model не была подготовлена для инференса больших моделей с device-map, похожим на auto.
Останавливает выполнение текущего процесса, пока все остальные процессы не достигнут этой точки (поэтому при запуске скрипта в одном процессе этот метод ничего не делает). Полезно вызывать перед сохранением модели.
Пример:
>>> # Assuming two GPU processes
>>> import time
>>> from accelerate import Accelerator
>>> accelerator = Accelerator()
>>> if accelerator.is_main_process:
... time.sleep(2)
>>> else:
... print("I'm waiting for the main process to finish its sleep...")
>>> accelerator.wait_for_everyone()
>>> # Should print on every process at the same time
>>> print("Everyone is here")Утилиты
accelerate.utils.gather_object
< source >( object: Any )
Рекурсивно собирает объект из вложенного списка/кортежа/словаря объектов со всех устройств.