Accelerate documentation

가속기

Accelerate

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

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

가속기

Accelerator는 모든 유형의 학습 설정에서 분산 학습을 활성화하기 위한 주요 클래스입니다. 코드에 Accelerator 추가 튜토리얼을 읽고 스크립트에 Accelerator를 추가하는 방법에 대해 자세히 알아보세요.

가속기

class accelerate.Accelerator

( device_placement: bool = Truesplit_batches: bool = <object object at 0x7fe7459895c0>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) — accelerator가 객체를 device에 배치할지 여부입니다(dataloader가 생성하는 tensor, model 등…).
mixed_precision (str, 선택 사항) — 혼합 정밀도(mixed precision) 학습을 사용할지 여부입니다. ‘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, 선택 사항) — 분산 시나리오에서 dataloader를 처리하는 방법에 대한 구성입니다.
deepspeed_plugin (DeepSpeedPlugin 또는 str — DeepSpeedPlugin의 dict, 선택 사항): 이 인수를 사용하여 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) — 준비된 dataloader에서 각 반복의 시작 시점에 동기화할 난수 생성기 목록입니다. 다음 중 하나 또는 여러 개여야 합니다:
- "torch": 기본 torch 난수 생성기
- "cuda": CUDA 난수 생성기(GPU 전용)
- "xla": XLA 난수 생성기(TPU 전용)
- "generator": 기본 데이터셋이 해당 유형인 경우, 샘플러(또는 데이터로더에 샘플러가 없는 경우 배치 샘플러) 또는 반복 가능한 데이터셋(존재하는 경우)의 torch.Generator입니다.
PyTorch 버전 <=1.5.1의 경우 ["torch"]로, PyTorch 버전 >= 1.6의 경우 ["generator"]로 기본값이 설정됩니다.
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") — torch dynamo로 학습을 최적화하기 위해 가능한 dynamo 백엔드 중 하나로 설정합니다.
dynamo_plugin (TorchDynamoPlugin, 선택 사항) — backend 또는 mode만으로는 부족하고 더 세밀한 조정이 필요할 경우, torch dynamo를 처리하는 방식을 설정하는 구성입니다.
gradient_accumulation_plugin (GradientAccumulationPlugin, 선택 사항) — gradient_accumulation_steps만으로는 부족하고 더 세밀한 조정이 필요한 경우, 그라디언트 축적을 어떻게 처리할지에 대한 설정입니다.

분산 학습 또는 혼합 정밀도 학습을 위한 accelerator 인스턴스를 생성합니다.

사용 가능한 속성:

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

( *models )

매개변수

*models (torch.nn.Module의 목록) — Accelerator.prepare로 준비된 PyTorch 모듈입니다. accumulate()에 전달된 모델은 분산 학습 시 backward pass에서 gradient 동기화를 건너뜁니다.

…

예:

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

( autocast_handler: AutocastKwargs = None )

이 컨텍스트 매니저 내부의 블록에서 활성화된 경우, 자동 혼합 정밀도(Automatic Mixed-Precision)가 적용됩니다. 그렇지 않으면 아무런 차이가 없습니다.

autocast_handler에 다른 값을 전달하여 Accelerator 객체에 설정된 값을 덮어쓸 수 있습니다. 이는 autocast 블록 내에서 fp32로 되돌리고 싶은 경우에 유용합니다.

예:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator(mixed_precision="fp16")
>>> with accelerator.autocast():
...     train()

backward

( loss**kwargs )

GradientAccumulationPlugin에 따라 그라디언트를 스케일링하고 구성에 따라 올바른 backward()를 호출합니다.

loss.backward() 대신 사용해야 합니다.

예:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator(gradient_accumulation_steps=2)
>>> outputs = model(inputs)
>>> loss = loss_fn(outputs, labels)
>>> accelerator.backward(loss)

check_trigger

( )

각 프로세스에서 내부 트리거 텐서가 1로 설정되었는지 확인합니다. 해당 값이 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

clear

( *objects )

Accelerate.free_memory의 별칭으로, 내부에 저장된 객체에 대한 모든 참조를 해제하고 가비지 컬렉터를 호출합니다. 서로 다른 모델/옵티마이저로 두 번의 학습을 수행하는 사이에 이 메서드를 호출해야 합니다.

예:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> model, optimizer, scheduler = ...
>>> model, optimizer, scheduler = accelerator.prepare(model, optimizer, scheduler)
>>> model, optimizer, scheduler = accelerator.clear(model, optimizer, scheduler)

clip_grad_norm_

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

clip_grad_value_

( parametersclip_value )

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

deepspeed_ulysses_dl_adapter

( dlmodel )

prepare의 일부로 호출되는 것이 일반적이지만, dataloader가 모델과 별도로 준비된 경우(외부 accelerator.prepare 호출)에는 prepare(model) 이후에 이 추가 호출이 필요합니다(HF Trainer를 사용 사례로 참고).

end_training

( )

메인 프로세스에서만 트래커를 중지하거나 프로세스 그룹을 해제하는 등 특수한 학습 종료 동작을 실행합니다. 실험 추적을 사용하는 경우 스크립트 끝에서 항상 호출해야 합니다.

예:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator(log_with="tensorboard")
>>> accelerator.init_trackers("my_project")
>>> # Do training
>>> accelerator.end_training()

free_memory

( *objects )

저장된 내부 객체에 대한 모든 참조를 해제하고 가비지 컬렉터를 호출합니다. 서로 다른 모델/옵티마이저로 두 번의 학습을 수행하는 사이에 이 메서드를 호출해야 합니다. 또한 Accelerator.step을 0으로 초기화합니다.

예:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> model, optimizer, scheduler = ...
>>> model, optimizer, scheduler = accelerator.prepare(model, optimizer, scheduler)
>>> model, optimizer, scheduler = accelerator.free_memory(model, optimizer, scheduler)

gather

( tensor ) → torch.Tensor, or a nested tuple/list/dictionary of torch.Tensor

매개변수

tensor (torch.Tensor 또는 torch.Tensor의 중첩된 tuple/list/dictionary) — 모든 프로세스에 걸쳐 수집할 텐서입니다.

반환값

torch.Tensor 또는 torch.Tensor의 중첩된 tuple/list/dictionary

수집된 텐서입니다. 결과의 첫 번째 차원은 num_processes와 입력 텐서의 첫 번째 차원의 곱입니다.

모든 프로세스에 걸쳐 tensor의 값을 수집하고 첫 번째 차원 방향으로 연결합니다. 평가 시 모든 프로세스의 예측 결과를 다시 그룹화하는 데 유용합니다.

Note: 이 gather는 모든 프로세스에서 발생합니다.

예:

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

( input_datause_gather_object = False )

매개변수

input_data (torch.Tensor, object, torch.Tensor의 중첩 tuple/list/dictionary, 또는 object의 중첩 tuple/list/dictionary) — 모든 프로세스에 걸쳐 메트릭을 계산하기 위한 텐서 또는 객체
use_gather_object(bool) — gather 대신 gather_object를 강제로 사용할지 여부입니다. 전달된 모든 객체에 텐서가 포함되지 않는 경우 이미 이 방식으로 처리됩니다. 이 플래그는 패딩 및 첫 번째 차원 방향의 연결을 원하지 않는 서로 다른 크기의 텐서를 수집할 때 유용합니다. GPU 텐서와 함께 사용할 경우 텐서가 pickled되기 때문에 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)
9

get_state_dict

( modelunwrap = True ) → dict

매개변수

model (torch.nn.Module) — Accelerator.prepare()를 통해 전달된 PyTorch 모델
unwrap (bool, 선택 사항, 기본값 True) — model의 원래 기반 state_dict를 반환할지, 아니면 래핑된 state_dict를 반환할지를 결정합니다.

반환값

dict

전체 정밀도가 아닐 수 있는 모델의 상태 사전(state dictionary).

Accelerator.prepare()를 통해 전달된 모델의 상태 사전(state dictionary)을 반환합니다. 이 경우 완전한 정밀도(full precision)가 아닐 수 있습니다.

예:

>>> import torch
>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> net = torch.nn.Linear(2, 2)
>>> net = accelerator.prepare(net)
>>> state_dict = accelerator.get_state_dict(net)

get_tracker

( name: strunwrap: bool = False ) → GeneralTracker

매개변수

name (str) — .name 속성에 해당하는 트래커의 이름입니다.
unwrap (bool) — 내부 추적 메커니즘을 반환할지, 아니면 래핑된 트래커를 반환할지 여부(권장).

반환값

GeneralTracker

존재하는 경우 name에 해당하는 트래커입니다.

메인 프로세스에서만 name에 따라 self.trackers에서 tracker를 반환합니다.

예:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator(log_with="tensorboard")
>>> accelerator.init_trackers("my_project")
>>> tensorboard_tracker = accelerator.get_tracker("tensorboard")

join_uneven_inputs

( joinableseven_batches = None )

매개변수

joinables (list[torch.distributed.algorithms.Joinable]) — torch.distributed.algorithms.Joinable를 서브클래스로 하는 모델 또는 옵티마이저의 목록입니다. 가장 일반적인 경우, DistributedDataParallel 학습을 위해 Accelerator.prepare로 준비된 PyTorch Module입니다.
even_batches (bool, 선택 사항) — 설정된 경우, Accelerator에서 설정한 even_batches 값을 덮어씁니다. 제공되지 않으면 Accelerator의 기본 값이 사용됩니다.

torch.distributed.algorithms.join을 래퍼로 사용하여 불균형한 입력에 대한 분산 학습 또는 평가를 지원하는 컨텍스트 매니저입니다. 이는 전체 배치 크기가 데이터셋 길이를 균등하게 나누지 못할 때 유용합니다.

join_uneven_inputs는 여러 GPU에서 분산 데이터 병렬(Distributed Data Parallel) 학습에만 지원됩니다. 다른 구성에서는 이 메서드가 아무런 효과를 내지 않습니다.

even_batches를 재정의해도 iterable 스타일의 데이터 로더에는 영향을 주지 않습니다.

예:

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

( input_dir: str | None = Noneload_kwargs: dict | None = None**load_model_func_kwargs )

매개변수

input_dir (str 또는 os.PathLike) — 관련된 가중치와 상태가 저장된 폴더의 이름입니다. automatic_checkpoint_naming을 사용하는 경우 None으로 설정할 수 있으며, 이 경우 최신 체크포인트에서 가져옵니다.
load_kwargs (dict, 선택 사항) — state_dict와 optimizer에 대한 선택적 인자와 같은, 내부 load 함수에 전달할 추가 키워드 인자입니다.
load_model_func_kwargs (dict, 선택 사항) — 모델 로딩에 사용할 수 있는 추가 키워드 인수로, DeepSpeed의 load_checkpoint 함수의 선택 인자나 모델과 옵티마이저를 로드할 map_location과 같이 기본 로딩 함수에 전달할 수 있습니다.

모델, 옵티마이저, 스케일러, RNG 생성기 및 등록된 객체의 현재 상태를 로드합니다.

Accelerator.save_state()와 함께만 사용해야 합니다. 체크포인트 등록이 되지 않은 파일은 해당 디렉터리에 저장되어 있더라도 로드되지 않습니다.

예:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> model, optimizer, lr_scheduler = ...
>>> model, optimizer, lr_scheduler = accelerator.prepare(model, optimizer, lr_scheduler)
>>> accelerator.load_state("my_checkpoint")

local_main_process_first

( )

로컬 메인 프로세스가 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_backward

( loss: torch.Tensorlearning_rate: float )

LOMO 옵티마이저에서 역전파를 실행합니다.

main_process_first

( )

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

( buffers: list[torch.Tensor] | None = Nonebuffer_seq_dims: list[int] | None = Noneno_restore_buffers: set[torch.Tensor] | None = None )

매개변수

buffers (list[torch.Tensor], optional) — 시퀀스 차원을 따라 샤딩될 버퍼입니다. 일반적인 예로는 입력, 라벨 또는 위치 임베딩 버퍼가 있습니다. 이 컨텍스트 매니저는 이러한 버퍼를 인플레이스(in-place)로 수정하며, 컨텍스트를 종료한 후에는 버퍼가 원래 상태로 복원됩니다. 불필요한 복원을 피하려면 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 >

이 조건 중 하나라도 충족되지 않으면 이 컨텍스트 매니저는 아무 효과도 없으며, 코드 변경을 최소화하기 위해 Exception을 발생시키지 않습니다.

… 아래 예시와 같이, 이 컨텍스트 매니저는 각 학습 단계마다 다시 생성되어야 합니다.

예:

>>> for batch in dataloader:
...     with accelerator.maybe_context_parallel(
...         buffers=[batch["input_ids"], batch["attention_mask"]],
...         buffer_seq_dims=[1, 1],
...         no_restore_buffers={batch["input_ids"]},
...     ):
...         outputs = model(batch)
...         ...

no_sync

( model )

매개변수

model (torch.nn.Module) — Accelerator.prepare로 준비된 PyTorch Module

torch.nn.parallel.DistributedDataParallel.no_sync를 호출하여 DDP 프로세스 간 그래디언트 동기화를 비활성화하는 컨텍스트 매니저입니다.

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

( function: Callable[..., Any] )

매개변수

function (Callable) — 장식할 함수.

장식된 함수를 마지막 프로세스에서만 실행하는 데코레이터입니다. PartialState 클래스를 사용하여 호출할 수도 있습니다.

예:

# Assume we have 4 processes.
from accelerate import Accelerator

accelerator = Accelerator()


@accelerator.on_last_process
def print_something():
    print(f"Printed on process {accelerator.process_index}")


print_something()
"Printed on process 3"

on_local_main_process

( function: Callable[..., Any] | None = None )

매개변수

function (Callable) — 장식할 함수.

장식자(decorator)로, 장식된 함수를 로컬 메인 프로세스에서만 실행합니다. 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

( function: Callable[..., Any] | None = Nonelocal_process_index: int | None = None )

매개변수

function (Callable, 선택 사항) — 장식할 함수.
local_process_index (int, 선택 사항) — 함수를 실행할 로컬 프로세스의 인덱스입니다.

주어진 로컬 프로세스 인덱스에서만 장식된 함수를 실행하는 데코레이터입니다. 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

( function: Callable[..., Any] | None = None )

매개변수

function (Callable) — 장식할 함수.

장식된 함수를 메인 프로세스에서만 실행하는 데코레이터입니다. PartialState 클래스를 사용하여 호출할 수도 있습니다.

예:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()


>>> @accelerator.on_main_process
... def print_something():
...     print("This will be printed by process 0 only.")


>>> print_something()
"This will be printed by process 0 only"

on_process

( function: Callable[..., Any] | None = Noneprocess_index: int | None = None )

매개변수

function (Callable, optional) — 장식할 함수.
process_index (int, optional) — 함수를 실행할 프로세스의 인덱스입니다.

주어진 프로세스 인덱스에서만 장식된 함수를 실행하는 데코레이터입니다. PartialState 클래스를 사용하여 호출할 수도 있습니다.

예:

# Assume we have 4 processes.
from accelerate import Accelerator

accelerator = Accelerator()


@accelerator.on_process(process_index=2)
def print_something():
    print(f"Printed on process {accelerator.process_index}")


print_something()
"Printed on process 2"

pad_across_processes

( 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의 중첩된 tuple/list/dictionary

패딩된 텐서입니다.

모든 디바이스의 중첩된 리스트/튜플/딕셔너리 내 텐서를 재귀적으로 패딩하여 동일한 크기로 맞춘 후 안전하게 수집할 수 있도록 합니다.

예:

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

( *argsdevice_placement = None )

매개변수

*args (다음 중 하나의 유형의 객체:
- torch.utils.data.DataLoader: PyTorch Dataloader
- torch.nn.Module: PyTorch 모듈
- torch.optim.Optimizer: PyTorch 옵티마이저
- torch.optim.lr_scheduler.LRScheduler: 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

( data_loader: torch.utils.data.DataLoaderdevice_placement = Noneslice_fn_for_dispatch = None )

매개변수

data_loader (torch.utils.data.DataLoader) — 준비하기 위한 일반 PyTorch DataLoader
device_placement (bool, 선택 사항) — 준비된 dataloader에서 배치(batches)를 올바른 device에 배치할지 여부입니다. 기본값은 self.device_placement입니다.
slice_fn_for_dispatch (Callable, optional) -- If passed, this function will be used to slice tensors across num_processes. Will default to [slice_tensors()](/docs/accelerate/main/en/package_reference/utilities#accelerate.utils.slice_tensors). This argument is used only when dispatch_batchesis set toTrue` and will be ignored otherwise.

분산 환경에서 PyTorch DataLoader를 학습용으로 준비합니다. 대신 Accelerator.prepare() 사용을 권장합니다.

예:

>>> import torch
>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> data_loader = torch.utils.data.DataLoader(...)
>>> data_loader = accelerator.prepare_data_loader(data_loader, device_placement=True)

prepare_model

( model: torch.nn.Moduledevice_placement: bool | None = Noneevaluation_mode: bool = False )

매개변수

model (torch.nn.Module) — 준비할 PyTorch 모델입니다. 어떤 형태의 혼합 정밀도(mixed precision)도 없이 추론에만 사용되는 경우 모델을 준비할 필요가 없습니다.
device_placement (bool, 선택 사항) — 모델을 올바른 장치에 배치할지 여부입니다. 기본값은 self.device_placement입니다.
evaluation_mode (bool, 선택 사항, 기본값 False) — 혼합 정밀도와 torch.compile만 적용하여(Accelerator 객체에 구성된 경우) 모델을 평가 전용으로 설정할지 여부.

분산 환경에서 PyTorch 모델을 학습하도록 준비합니다. 대신 Accelerator.prepare() 사용을 권장합니다.

예:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> # Assume a model is defined
>>> model = accelerator.prepare_model(model)

prepare_optimizer

( optimizer: torch.optim.Optimizerdevice_placement = None )

매개변수

optimizer (torch.optim.Optimizer) — 준비할 기본 PyTorch 옵티마이저
device_placement (bool, 선택 사항) — 옵티마이저를 올바른 장치에 배치할지 여부입니다. 기본값은 self.device_placement입니다.

분산 환경에서 PyTorch Optimizer를 학습에 맞게 준비합니다. 대신 Accelerator.prepare() 사용을 권장합니다.

예:

>>> import torch
>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> optimizer = torch.optim.Adam(...)
>>> optimizer = accelerator.prepare_optimizer(optimizer, device_placement=True)

prepare_scheduler

( scheduler: LRScheduler )

매개변수

scheduler (torch.optim.lr_scheduler.LRScheduler) — 준비를 위한 일반 PyTorch 스케줄러

분산 환경에서 PyTorch Scheduler를 학습용으로 준비합니다. 대신 Accelerator.prepare() 사용을 권장합니다.

예:

>>> import torch
>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> optimizer = torch.optim.Adam(...)
>>> scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, ...)
>>> scheduler = accelerator.prepare_scheduler(scheduler)

print

( *args**kwargs )

서버당 한 번만 출력하도록 print()를 대체하는 드롭인 리플레이스먼트입니다.

예:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> accelerator.print("Hello world!")

프로필

( profile_handler: ProfileKwargs | None = None )

매개변수

profile_handler (ProfileKwargs, 선택) — 이 context manager에 사용할 profile handler입니다. 전달되지 않으면 Accelerator 객체에 설정된 것을 사용합니다.

컨텍스트 매니저 내부의 코드를 프로파일링합니다. profile_handler.output_trace_dir가 설정된 경우, 프로파일은 Chrome Trace 파일로 저장됩니다.

Accelerator 객체에 설정된 값을 덮어쓰기 위해 다른 profile_handler를 전달할 수 있습니다.

예:

# 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

( tensorreduction = 'sum'scale = 1.0 ) → torch.Tensor, or a nested tuple/list/dictionary of torch.Tensor

매개변수

tensor (torch.Tensor 또는 torch.Tensor의 중첩된 tuple/list/dictionary) — 모든 프로세스에 걸쳐 축소할 텐서입니다.
reduction (str, 선택 사항, 기본값 “sum”) — 리덕션 유형으로, ‘sum’, ‘mean’, ‘max’, ‘none’ 중 하나를 사용할 수 있습니다. ‘none’인 경우 어떤 연산도 수행하지 않습니다.
scale (float, 선택 사항, 기본값 1.0) — reduce 이후에 적용할 기본 스케일링 값입니다. XLA에서만 유효합니다.

반환값

torch.Tensor 또는 torch.Tensor의 중첩된 tuple/list/dictionary

축소된 텐서입니다.

reduction에 따라 모든 프로세스에 걸쳐 tensor의 값을 감소시킵니다.

Note: 모든 프로세스가 축소된 값을 수신합니다.

예:

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

register_for_checkpointing

( *objects )

objects를 기록하고 save_state 또는 load_state 중에 저장하거나 로드합니다.

이것은 상태가 동일한 스크립트 내에서 로드되거나 저장될 때 사용해야 합니다. 다른 스크립트에서 사용하도록 설계되지 않았습니다.

저장하려면 모든 object에는 load_state_dict 및 state_dict 함수가 있어야 합니다.

예:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> # Assume `CustomObject` has a `state_dict` and `load_state_dict` function.
>>> obj = CustomObject()
>>> accelerator.register_for_checkpointing(obj)
>>> accelerator.save_state("checkpoint.pt")

register_load_state_pre_hook

( hook: Callable[..., None] ) → torch.utils.hooks.RemovableHandle

매개변수

hook (Callable) — load_checkpoint를 호출하기 전에 Accelerator.load_state()에서 호출할 함수.

반환값

torch.utils.hooks.RemovableHandle

handle.remove()를 호출하여 추가된 훅을 제거하는 데 사용할 수 있는 핸들

load_checkpoint이 Accelerator.load_state()에서 호출되기 전에 실행될 pre hook을 등록합니다.

훅은 다음 서명을 가져야 합니다:

hook(models: list[torch.nn.Module], input_dir: str) -> None

models 인수는 accelerator._models 아래에 accelerator state로 저장된 모델이며, input_dir 인수는 Accelerator.load_state()에 전달된 input_dir 인수입니다.

Accelerator.register_save_state_pre_hook()와 함께만 사용해야 합니다. 모델 가중치 외에도 구성을 로드하는 데 유용할 수 있습니다. 커스터마이징된 메서드로 모델 로딩을 덮어쓰는 데에도 사용할 수 있습니다. 이 경우, 이미 로드된 모델을 models 목록에서 제거했는지 확인하세요.

register_save_state_pre_hook

( hook: Callable[..., None] ) → torch.utils.hooks.RemovableHandle

매개변수

hook (Callable) — save_checkpoint를 호출하기 전에 Accelerator.save_state()에서 호출할 함수.

반환값

torch.utils.hooks.RemovableHandle

handle.remove()를 호출하여 추가된 훅을 제거하는 데 사용할 수 있는 핸들

save_checkpoint이 Accelerator.save_state()에서 호출되기 전에 실행될 pre hook을 등록합니다.

훅은 다음 서명을 가져야 합니다:

hook(models: list[torch.nn.Module], weights: list[dict[str, torch.Tensor]], input_dir: str) -> None

models 인수는 accelerator._models 아래에 accelerator state로 저장된 모델이며, weights 인수는 models의 state dict이고, input_dir 인수는 Accelerator.load_state()에 전달된 input_dir 인수입니다.

Accelerator.register_load_state_pre_hook()와 함께만 사용해야 합니다. 모델 가중치 외에도 구성을 저장하는 데 유용할 수 있습니다. 커스터마이징된 메서드로 모델 저장을 덮어쓰는 데에도 사용할 수 있습니다. 이 경우, 이미 로드된 가중치를 가중치 목록에서 제거했는지 확인하세요.

저장

( objfsafe_serialization = False )

매개변수

obj (object) — 저장할 객체.
f (str 또는 os.PathLike) — obj의 내용을 저장할 위치.
safe_serialization (bool, 선택 사항, 기본값 False) — safetensors를 사용하여 obj를 저장할지 여부

torch.save 대신에, 전달된 객체를 머신당 한 번씩 디스크에 저장합니다.

Note: save_on_each_node가 ProjectConfiguration로 전달된 경우, 메인 노드에서 한 번만 저장하는 대신 각 노드별로 한 번씩 객체를 저장합니다.

예:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> arr = [0, 1, 2, 3]
>>> accelerator.save(arr, "array.pkl")

save_model

( 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를 사용하여 모델을 저장할지, 아니면 pickle을 사용하는 전통적인 PyTorch 방식으로 저장할지를 결정합니다.

load_checkpoint_in_model을 사용하여 다시 로드할 수 있도록 모델을 저장합니다

예:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> model = ...
>>> accelerator.save_model(model, save_directory)

save_state

( output_dir: str | None = Nonesafe_serialization: bool = True**save_model_func_kwargs )

매개변수

output_dir (str 또는 os.PathLike) — 모든 관련 가중치와 상태를 저장할 폴더의 이름입니다.
safe_serialization (bool, 선택 사항, 기본값 True) — safetensors를 사용하여 모델을 저장할지, 아니면 pickle을 사용하는 전통적인 PyTorch 방식으로 저장할지를 결정합니다.
save_model_func_kwargs (dict, 선택) — DeepSpeed의 save_checkpoint 함수와 같은 기본 저장 함수에 전달할 수 있는 모델 저장용 추가 키워드 인자입니다.

모델, 옵티마이저, 스케일러, RNG 생성기, 등록된 객체의 현재 상태를 폴더에 저장합니다.

automatic_checkpoint_naming가 활성화된 ProjectConfiguration가 Accelerator 객체에 전달된 경우, 체크포인트는 self.project_dir/checkpoints에 저장됩니다. 현재 저장된 체크포인트의 수가 total_limit보다 크면 가장 오래된 저장본이 삭제됩니다. 각 체크포인트는 checkpoint_<iteration>이라는 이름의 개별 폴더에 저장됩니다.

그렇지 않으면 output_dir에 저장됩니다.

…

예:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> model, optimizer, lr_scheduler = ...
>>> model, optimizer, lr_scheduler = accelerator.prepare(model, optimizer, lr_scheduler)
>>> accelerator.save_state(output_dir="my_checkpoint")

set_trigger

( )

현재 프로세스에서 내부 트리거 텐서를 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():
...     break

skip_first_batches

( dataloadernum_batches: int = 0 )

매개변수

dataloader (torch.utils.data.DataLoader) — 배치 건너뛰기를 수행할 데이터 로더.
num_batches (int, 선택 사항, 기본값 0) — 건너뛸 배치의 수

torch.utils.data.DataLoader의 첫 num_batches개를 효율적으로 건너뛰는 새로운 torch.utils.data.DataLoader를 생성합니다.

예:

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

( inputs: list | tuple | dict | torch.Tensorapply_padding: bool = False )

매개변수

inputs (list, tuple, torch.Tensor, 또는 list/tuple/torch.Tensor의 dict) — 프로세스 간에 분할할 입력입니다.
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

( model )

매개변수

model (torch.nn.Module) — 그라디언트 동기화를 트리거할 모델입니다.

Accelerator.no_sync 아래에서 여러 번의 forward pass가 실행된 후, 모델의 다음 backward pass에서 gradient 동기화를 트리거합니다(멀티 GPU 환경에서만 적용 가능).

script가 분산 모드에서 실행되지 않으면, 이 컨텍스트 매니저는 아무 동작도 하지 않습니다.

예:

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

( optimizer = None )

매개변수

optimizer (torch.optim.Optimizer 또는 list[torch.optim.Optimizer], 선택 사항) — 그라디언트 스케일링을 해제할 옵티마이저입니다. 설정하지 않으면 prepare()에 전달된 모든 옵티마이저의 그라디언트 스케일링을 해제합니다.

AMP를 사용한 혼합 정밀도 학습에서 그래디언트를 언스케일합니다. 다른 모든 설정에서는 no-op입니다.

Accelerator.clipgrad_norm() 또는 Accelerator.clipgrad_value()를 통해 호출해야 합니다.

예:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> model, optimizer = accelerator.prepare(model, optimizer)
>>> outputs = model(inputs)
>>> loss = loss_fn(outputs, labels)
>>> accelerator.backward(loss)
>>> accelerator.unscale_gradients(optimizer=optimizer)

unwrap_model

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

매개변수

model (torch.nn.Module) — unwrap할 모델.
keep_fp32_wrapper (bool, 선택 사항, 기본값 True) — 추가된 mixed precision hook를 제거하지 않을지 여부.
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

verify_device_map

( model: torch.nn.Module )

model이 auto와 유사한 device-map을 가진 big model inference로 준비되지 않았는지 확인합니다.

wait_for_everyone

( )

…

예:

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

( object: Any )

매개변수

object (pickle 가능한 객체의 중첩된 list/tuple/dictionary) — 수집할 데이터.

…

Update on GitHub

←TPU에서 학습 상태ful 클래스→