Accelerate documentation

Bộ tăng tốc

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Bộ tăng tốc

Accelerator là lớp chính để kích hoạt huấn luyện phân tán trên bất kỳ cấu hình huấn luyện nào. Đọc hướng dẫn Thêm Accelerator vào mã của bạn để tìm hiểu cách thêm Accelerator vào script của bạn.

Bộ tăng tốc

lớp accelerate.Accelerator

< >

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

Tham số

  • device_placement (bool, tùy chọn, mặc định là True) — Xác định xem bộ tăng tốc có nên đặt các đối tượng lên thiết bị (các tensor do dataloader tạo ra, model, v.v…) hay không.
  • mixed_precision (str, tùy chọn) — Có sử dụng huấn luyện độ chính xác hỗn hợp hay không. Chọn từ ‘no’,‘fp16’,‘bf16’ hoặc ‘fp8’. Mặc định sẽ lấy giá trị từ biến môi trường ACCELERATE_MIXED_PRECISION, vốn sẽ sử dụng giá trị mặc định trong cấu hình accelerate của hệ thống hiện tại hoặc cờ được truyền với lệnh accelerate.launch. ‘fp8’ yêu cầu cài đặt transformers-engine.
  • gradient_accumulation_steps (int, tùy chọn, mặc định là 1) — Số bước cần trôi qua trước khi các gradient được tích lũy. Một số lớn hơn 1 nên được kết hợp với Accelerator.accumulate. Nếu không được truyền vào, giá trị mặc định sẽ là giá trị trong biến môi trường ACCELERATE_GRADIENT_ACCUMULATION_STEPS. Cũng có thể cấu hình thông qua GradientAccumulationPlugin.
  • cpu (bool, tùy chọn) — Có nên buộc kịch bản chạy trên CPU hay không. Nếu đặt thành True, GPU khả dụng sẽ bị bỏ qua và việc thực thi sẽ được ép buộc chỉ trên một tiến trình.
  • dataloader_config (DataLoaderConfiguration, tùy chọn) — Cấu hình cho cách xử lý các dataloader trong các kịch bản phân tán.
  • deepspeed_plugin (DeepSpeedPlugin hoặc dict của str — DeepSpeedPlugin, tuỳ chọn): Tinh chỉnh các đối số liên quan đến DeepSpeed của bạn bằng đối số này. Đối số này là tuỳ chọn và có thể được cấu hình trực tiếp bằng accelerate config. Nếu sử dụng nhiều plugin, hãy sử dụng thuộc tính key đã được cấu hình của từng plugin để truy cập chúng từ accelerator.state.get_deepspeed_plugin(key). Tên gọi khác của deepspeed_plugins.
  • fsdp_plugin (FullyShardedDataParallelPlugin, tùy chọn) — Tinh chỉnh các tham số liên quan đến FSDP bằng cách sử dụng tham số này. Tham số này là tùy chọn và có thể được cấu hình trực tiếp bằng accelerate config
  • torch_tp_plugin (TorchTensorParallelPlugin, tùy chọn) — Đã ngừng hỗ trợ: hãy dùng parallelism_config với tp_size thay thế.
  • megatron_lm_plugin (MegatronLMPlugin, tùy chọn) — Tinh chỉnh các đối số liên quan đến MegatronLM của bạn bằng đối số này. Đối số này là tùy chọn và có thể được cấu hình trực tiếp bằng accelerate config
  • rng_types (danh sách str hoặc RNGType) — Danh sách các bộ tạo số ngẫu nhiên cần đồng bộ hóa ở đầu mỗi lần lặp trong các dataloader đã được chuẩn bị của bạn. Phải là một hoặc nhiều trong số sau:
    • "torch": bộ tạo số ngẫu nhiên cơ bản của torch
    • "cuda": bộ tạo số ngẫu nhiên CUDA (chỉ dành cho GPU)
    • Loại thiết bị của bất kỳ bộ tăng tốc PyTorch nào đã được đăng ký: bộ tạo số ngẫu nhiên của thiết bị đó.
    • "xla": bộ tạo số ngẫu nhiên XLA (chỉ dành cho TPU)
    • "generator": torch.Generator của sampler (hoặc batch sampler nếu dataloader của bạn không có sampler) hoặc của iterable dataset (nếu có) nếu dataset cơ bản có kiểu đó.

    Mặc định sẽ là ["torch"] cho các phiên bản PyTorch <=1.5.1 và ["generator"] cho các phiên bản PyTorch >= 1.6.

  • log_with (danh sách str, LoggerType hoặc GeneralTracker, tuỳ chọn) — Danh sách các logger cần thiết lập để theo dõi thí nghiệm. Phải là một hoặc nhiều trong số:
    • "all"
    • "tensorboard"
    • "wandb"
    • "trackio"
    • "aim"
    • "comet_ml"
    • "mlflow"
    • "dvclive"
    • "swanlab" Nếu "all" được chọn, sẽ lấy tất cả các tracker khả dụng trong môi trường và khởi tạo chúng. Cũng có thể chấp nhận các cài đặt của GeneralTracker cho các tracker tùy chỉnh, và có thể kết hợp với "all".
  • project_config (ProjectConfiguration, tùy chọn) — Cấu hình cho cách xử lý việc lưu trạng thái.
  • project_dir (str, os.PathLike, tùy chọn) — Đường dẫn đến một thư mục để lưu trữ dữ liệu như nhật ký của các trình ghi nhật ký tương thích cục bộ và các checkpoint có thể đã được lưu.
  • step_scheduler_with_optimizer (bool, tùy chọn, mặc định là True) — Đặt True nếu trình lập lịch tốc độ học được bước tiến cùng lúc với trình tối ưu, False nếu chỉ thực hiện trong một số trường hợp nhất định (ví dụ: vào cuối mỗi epoch).
  • kwargs_handlers (list of KwargsHandler, optional) — Một danh sách các KwargsHandler để tùy chỉnh cách tạo các đối tượng liên quan đến huấn luyện phân tán, profiling hoặc mixed precision. Xem kwargs để biết thêm thông tin.
  • dynamo_backend (str hoặc DynamoBackend, tuỳ chọn, mặc định là "no") — Đặt thành một trong các dynamo backend khả dụng để tối ưu hóa việc huấn luyện của bạn bằng torch dynamo.
  • dynamo_plugin (TorchDynamoPlugin, tùy chọn) — Cấu hình cho cách xử lý torch dynamo, nếu cần tinh chỉnh nhiều hơn so với chỉ backend hoặc mode.
  • gradient_accumulation_plugin (GradientAccumulationPlugin, tùy chọn) — Một cấu hình cho cách xử lý tích lũy gradient, nếu cần tinh chỉnh nhiều hơn so với chỉ gradient_accumulation_steps.

Tạo một instance của accelerator cho huấn luyện phân tán hoặc huấn luyện độ chính xác hỗn hợp.

Các thuộc tính khả dụng:

  • device (torch.device) — Thiết bị cần sử dụng.
  • distributed_type (DistributedType) — Cấu hình huấn luyện phân tán.
  • local_process_index (int) — Chỉ số tiến trình trên máy hiện tại.
  • mixed_precision (str) — Chế độ chính xác hỗn hợp đã cấu hình.
  • num_processes (int) — Tổng số tiến trình được sử dụng cho huấn luyện.
  • optimizer_step_was_skipped (bool) — Cho biết việc cập nhật optimizer có bị bỏ qua hay không (do tràn gradient trong chế độ chính xác hỗn hợp), trong trường hợp đó tốc độ học không nên được thay đổi.
  • process_index (int) — Chỉ số tổng thể của tiến trình hiện tại trong số tất cả các tiến trình.
  • state (AcceleratorState) — Trạng thái cấu hình phân tán.
  • sync_gradients (bool) — Cho biết các gradient có đang được đồng bộ hóa trên tất cả các tiến trình hay không.
  • use_distributed (bool) — Xác định xem cấu hình hiện tại có dành cho huấn luyện phân tán hay không.

accumulate

< >

( *models )

Tham số

  • *models (list of torch.nn.Module) — Các PyTorch Module đã được chuẩn bị bằng Accelerator.prepare. Các model được truyền vào accumulate() sẽ bỏ qua việc đồng bộ gradient trong quá trình truyền ngược khi huấn luyện phân tán

Một trình quản lý ngữ cảnh sẽ bao bọc nhẹ nhàng và tự động thực hiện tích lũy gradient

Ví dụ:

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

Sẽ áp dụng độ chính xác hỗn hợp tự động bên trong khối bên trong trình quản lý ngữ cảnh này, nếu nó được bật. Không có gì khác sẽ xảy ra trong trường hợp ngược lại.

Có thể truyền vào một autocast_handler khác để ghi đè lên handler đã được thiết lập trong đối tượng Accelerator. Điều này hữu ích trong các khối nằm dưới autocast khi bạn muốn chuyển về fp32.

Ví dụ:

>>> from accelerate import Accelerator

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

backward

< >

( loss**kwargs )

Thang đo các gradient theo GradientAccumulationPlugin và gọi backward() tương ứng dựa trên cấu hình.

Nên được sử dụng thay cho loss.backward().

Ví dụ:

>>> from accelerate import Accelerator

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

check_trigger

< >

( )

Kiểm tra xem tensor kích hoạt nội bộ đã được đặt thành 1 trong bất kỳ tiến trình nào chưa. Nếu có, sẽ trả về True và đặt lại tensor kích hoạt về 0.

Lưu ý: Không yêu cầu wait_for_everyone()

Ví dụ:

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

xóa

< >

( *objects )

Biệt danh của Accelerate.free_memory, giải phóng tất cả các tham chiếu đến các đối tượng nội bộ được lưu trữ và gọi bộ thu gom rác. Bạn nên gọi phương thức này giữa hai lần huấn luyện với các model/optimizer khác nhau.

Ví dụ:

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

Trả về

torch.Tensor

Tổng chuẩn của các gradient tham số (được xem như một vector duy nhất).

Nên được sử dụng thay cho torch.nn.utils.clip_grad_norm_.

Ví dụ:

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

Nên được sử dụng thay cho torch.nn.utils.clip_grad_value_.

Ví dụ:

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

thông thường điều này được gọi như một phần của prepare nhưng khi dataloader được chuẩn bị riêng biệt với model (cho lời gọi accelerator.prepare bên ngoài) thì cần thực hiện thêm lời gọi này sau prepare(model) (xem HF Trainer như một trường hợp sử dụng)

end_training

< >

( )

Chạy các hành vi đặc biệt khi kết thúc huấn luyện, chẳng hạn như dừng các bộ theo dõi chỉ trên tiến trình chính hoặc hủy nhóm tiến trình. Luôn phải được gọi ở cuối script nếu bạn đang sử dụng theo dõi thí nghiệm.

Ví dụ:

>>> from accelerate import Accelerator

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

free_memory

< >

( *objects )

Sẽ giải phóng tất cả các tham chiếu đến các đối tượng nội bộ được lưu trữ và gọi bộ thu gom rác. Bạn nên gọi phương thức này giữa hai lần huấn luyện với các mô hình/bộ tối ưu hóa khác nhau. Đồng thời sẽ đặt lại Accelerator.step về 0.

Ví dụ:

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

Tham số

  • tensor (torch.Tensor, hoặc tuple/list/dictionary lồng nhau của torch.Tensor) — Các tensor cần thu thập trên tất cả các tiến trình.

Trả về

torch.Tensor, hoặc một tuple/list/dictionary lồng nhau của torch.Tensor

Tensor đã được thu thập. Lưu ý rằng chiều đầu tiên của kết quả là num_processes nhân với chiều đầu tiên của các tensor đầu vào.

Thu thập các giá trị trong tensor trên tất cả các tiến trình và nối chúng lại theo chiều thứ nhất. Hữu ích để nhóm lại các dự đoán từ tất cả các tiến trình khi thực hiện đánh giá.

Lưu ý: Thao tác thu thập này diễn ra trên tất cả các tiến trình.

Ví dụ:

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

Tham số

  • input_data (torch.Tensor, object, một tuple/list/dictionary lồng nhau của torch.Tensor, hoặc một tuple/list/dictionary lồng nhau của object) — Các tensor hoặc object để tính toán các chỉ số (metrics) trên tất cả các tiến trình
  • use_gather_object(bool) — Xác định có ép buộc sử dụng gather_object thay vì gather (điều này đã được thực hiện nếu tất cả các đối tượng truyền vào không chứa tensor). Cờ này có thể hữu ích để thu thập các tensor có kích thước khác nhau mà chúng ta không muốn đệm và nối theo chiều thứ nhất. Việc sử dụng nó với tensor GPU không được hỗ trợ tốt và kém hiệu quả vì nó gây ra chuyển dữ liệu GPU -> CPU do các tensor sẽ được pickle.

Thu thập input_data và có thể loại bỏ các phần tử trùng lặp trong batch cuối cùng nếu đang chạy trên hệ thống phân tán. Nên được sử dụng để thu thập các đầu vào và nhãn (targets) cho việc tính toán chỉ số (metric).

Ví dụ:

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

Tham số

  • model (torch.nn.Module) — Một mô hình PyTorch đã được xử lý qua Accelerator.prepare()
  • unwrap (bool, tuỳ chọn, mặc định là True) — Có nên trả về state_dict gốc của model hay trả về state_dict đã được bọc

Trả về

dict

Từ điển trạng thái của mô hình, có thể không ở độ chính xác đầy đủ.

Trả về từ điển trạng thái của một mô hình được gửi qua Accelerator.prepare(), có thể không ở độ chính xác đầy đủ.

Ví dụ:

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

Tham số

  • name (str) — Tên của một tracker, tương ứng với thuộc tính .name.
  • unwrap (bool) — Xác định việc trả về cơ chế theo dõi bên trong hay trả về bộ theo dõi đã bọc (được khuyến nghị).

Trả về

GeneralTracker

Trình theo dõi tương ứng với name nếu nó tồn tại.

Trả về một tracker từ self.trackers dựa trên name chỉ trên tiến trình chính.

Ví dụ:

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

Tham số

  • joinables (list[torch.distributed.algorithms.Joinable]) — Một danh sách các model hoặc optimizer kế thừa từ torch.distributed.algorithms.Joinable. Phổ biến nhất là một PyTorch Module đã được chuẩn bị bằng Accelerator.prepare cho huấn luyện DistributedDataParallel.
  • even_batches (bool, tùy chọn) — Nếu được đặt, giá trị này sẽ ghi đè lên giá trị của even_batches được thiết lập trong Accelerator. Nếu không được cung cấp, giá trị mặc định của Accelerator sẽ được sử dụng.

Một context manager hỗ trợ huấn luyện hoặc đánh giá phân tán trên các đầu vào không đồng đều, đóng vai trò là một lớp bọc quanh torch.distributed.algorithms.join. Điều này hữu ích khi tổng kích thước batch không chia hết cho độ dài của tập dữ liệu.

join_uneven_inputs chỉ được hỗ trợ cho huấn luyện Distributed Data Parallel trên nhiều GPU. Với bất kỳ cấu hình nào khác, phương thức này sẽ không có tác dụng.

Việc ghi đè even_batches sẽ không ảnh hưởng đến trình tải dữ liệu theo kiểu lặp (iterable-style).

Ví dụ:

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

Tham số

  • input_dir (str hoặc os.PathLike) — Tên của thư mục chứa tất cả các trọng số và trạng thái liên quan đã được lưu. Có thể là None nếu automatic_checkpoint_naming được sử dụng, và sẽ lấy từ checkpoint mới nhất.
  • load_kwargs (dict, tùy chọn) — Các đối số từ khóa bổ sung cho hàm load bên dưới, chẳng hạn như các đối số tùy chọn cho state_dict và optimizer.
  • load_model_func_kwargs (dict, tùy chọn) — Các đối số từ khóa bổ sung để tải mô hình, có thể được truyền cho hàm tải bên dưới, chẳng hạn như các đối số tùy chọn cho hàm load_checkpoint của DeepSpeed hoặc một map_location để tải mô hình và optimizer lên.

Tải các trạng thái hiện tại của mô hình, bộ tối ưu hóa, bộ điều chỉnh tỷ lệ, các trình tạo RNG và các đối tượng đã đăng ký.

Chỉ nên được sử dụng cùng với Accelerator.save_state(). Nếu một tệp không được đăng ký để checkpoint, nó sẽ không được tải nếu được lưu trong thư mục.

Ví dụ:

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

< >

( )

Cho phép tiến trình chính cục bộ đi vào khối with.

Các tiến trình khác sẽ đi vào khối with sau khi tiến trình chính thoát.

Ví dụ:

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

Chạy bước truyền ngược trên các bộ tối ưu LOMO.

main_process_first

< >

( )

Cho phép tiến trình chính chạy trước bên trong khối with.

Các tiến trình khác sẽ đi vào khối with sau khi tiến trình chính thoát.

Ví dụ:

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

có thể song song ngữ cảnh

< >

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

Tham số

  • buffers (list[torch.Tensor], optional) — Các buffer sẽ được chia nhỏ dọc theo chiều sequence. Các ví dụ phổ biến là inputs, labels hoặc các buffer positional embedding. Context manager này sẽ sửa đổi các buffer này tại chỗ, và sau khi thoát khỏi context, các buffer sẽ được khôi phục về trạng thái ban đầu. Để tránh việc khôi phục không cần thiết, bạn có thể sử dụng no_restore_buffers để chỉ định các buffer không cần được khôi phục.
  • buffer_seq_dims (list[int], optional) — Các chiều của chuỗi cho buffers.
  • no_restore_buffers (set[torch.Tensor], optional) — Tập hợp này phải là một tập con của buffers. Chỉ định các buffer từ đối số buffers sẽ không được khôi phục sau khi thoát khỏi ngữ cảnh. Các buffer này sau đó sẽ được giữ ở trạng thái phân mảnh (sharded).

Một trình quản lý ngữ cảnh cho phép huấn luyện song song ngữ cảnh.

context_parallel hiện được hỗ trợ với FSDP2 và yêu cầu parallelism_config.cp_size >

  1. Nếu một trong hai điều kiện này không được đáp ứng, trình quản lý ngữ cảnh này sẽ không có tác dụng, mặc dù để giảm thiểu các thay đổi mã, nó sẽ không gây ra ngoại lệ.

Context manager này phải được tạo lại ở mỗi bước huấn luyện, như minh họa trong ví dụ bên dưới.

Ví dụ:

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

Tham số

  • model (torch.nn.Module) — Module PyTorch đã được chuẩn bị bằng Accelerator.prepare

Một trình quản lý ngữ cảnh để vô hiệu hóa đồng bộ hóa gradient giữa các tiến trình DDP bằng cách gọi torch.nn.parallel.DistributedDataParallel.no_sync.

Nếu model không nằm trong DDP, trình quản lý ngữ cảnh này sẽ không thực hiện gì

Ví dụ:

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

Tham số

  • function (Callable) — Hàm cần trang trí.

Một decorator sẽ chạy hàm được trang trí chỉ trên tiến trình cuối cùng. Cũng có thể được gọi bằng cách sử dụng lớp PartialState.

Ví dụ:

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

Tham số

  • function (Callable) — Hàm cần trang trí.

Một decorator sẽ chạy hàm được trang trí chỉ trên tiến trình chính cục bộ. Cũng có thể được gọi bằng cách sử dụng lớp PartialState.

Ví dụ:

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

Tham số

  • function (Callable, tùy chọn) — Hàm cần trang trí.
  • local_process_index (int, tùy chọn) — Chỉ số của tiến trình cục bộ mà trên đó hàm sẽ được thực thi.

Một decorator sẽ chạy hàm được trang trí chỉ trên chỉ số tiến trình cục bộ đã cho. Cũng có thể được gọi bằng cách sử dụng lớp PartialState.

Ví dụ:

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

Tham số

  • function (Callable) — Hàm cần trang trí.

Một decorator sẽ chạy hàm được trang trí chỉ trên tiến trình chính. Cũng có thể được gọi bằng cách sử dụng lớp PartialState.

Ví dụ:

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

Tham số

  • function (Callable, optional) — Hàm cần trang trí.
  • process_index (int, optional) — Chỉ số của tiến trình mà hàm sẽ được thực thi trên đó.

Một decorator sẽ chạy hàm được trang trí chỉ trên một chỉ số tiến trình cho trước. Cũng có thể được gọi bằng cách sử dụng lớp PartialState.

Ví dụ:

# 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

Tham số

  • tensor (danh sách/bộ/dictionary lồng nhau của torch.Tensor) — Dữ liệu cần thu thập.
  • dim (int, tùy chọn, mặc định là 0) — Chiều cần đệm.
  • pad_index (int, tùy chọn, mặc định là 0) — Giá trị dùng để đệm.
  • pad_first (bool, tùy chọn, mặc định là False) — Có nên đệm ở đầu hay ở cuối không.

Trả về

torch.Tensor, hoặc một tuple/list/dictionary lồng nhau của torch.Tensor

Tensor đã được đệm.

Đệm đệ quy các tensor trong danh sách/bộ/bộ từ điển lồng nhau của các tensor từ tất cả các thiết bị để chúng có cùng kích thước, nhằm có thể thu thập chúng một cách an toàn.

Ví dụ:

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

Tham số

  • *args (danh sách các đối tượng) — Bất kỳ đối tượng nào thuộc các loại sau:
    • torch.utils.data.DataLoader: Dataloader của PyTorch
    • torch.nn.Module: Module của PyTorch
    • torch.optim.Optimizer: Optimizer của PyTorch
    • torch.optim.lr_scheduler.LRScheduler: Bộ điều chỉnh tốc độ học PyTorch
  • device_placement (list[bool], tùy chọn) — Được sử dụng để tùy chỉnh việc có thực hiện bố trí thiết bị tự động cho từng đối tượng được truyền vào hay không. Cần phải là một danh sách có cùng độ dài với args. Không tương thích với DeepSpeed hoặc FSDP.

Chuẩn bị tất cả các đối tượng được truyền vào args cho huấn luyện phân tán và độ chính xác hỗn hợp, sau đó trả về chúng theo cùng một thứ tự.

Bạn không cần chuẩn bị mô hình nếu chỉ sử dụng nó để suy luận mà không dùng bất kỳ dạng độ chính xác hỗn hợp nào

Ví dụ:

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

Tham số

  • data_loader (torch.utils.data.DataLoader) — Một DataLoader PyTorch thông thường để chuẩn bị
  • device_placement (bool, tùy chọn) — Có đặt các batch lên đúng thiết bị trong dataloader đã được chuẩn bị hay không. Mặc định là 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/v1.16.0/en/package_reference/utilities#accelerate.utils.slice_tensors). This argument is used only when dispatch_batchesis set toTrue` and will be ignored otherwise.

Chuẩn bị một PyTorch DataLoader để huấn luyện trong bất kỳ cấu hình phân tán nào. Khuyến nghị sử dụng Accelerator.prepare() thay thế.

Ví dụ:

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

Tham số

  • model (torch.nn.Module) — Một mô hình PyTorch cần chuẩn bị. Bạn không cần chuẩn bị mô hình nếu nó chỉ được sử dụng để suy luận mà không có bất kỳ loại độ chính xác hỗn hợp nào
  • device_placement (bool, tùy chọn) — Có đặt mô hình lên thiết bị phù hợp hay không. Mặc định là self.device_placement.
  • evaluation_mode (bool, tùy chọn, mặc định là False) — Có nên đặt model ở chế độ đánh giá hay không, bằng cách chỉ áp dụng độ chính xác hỗn hợp và torch.compile (nếu được cấu hình trong đối tượng Accelerator).

Chuẩn bị một mô hình PyTorch để huấn luyện trong bất kỳ cấu hình phân tán nào. Khuyến nghị sử dụng Accelerator.prepare() thay thế.

Ví dụ:

>>> from accelerate import Accelerator

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

prepare_optimizer

< >

( optimizer: torch.optim.Optimizerdevice_placement = None )

Tham số

  • optimizer (torch.optim.Optimizer) — Một optimizer PyTorch thông thường để chuẩn bị
  • device_placement (bool, tùy chọn) — Có đặt optimizer trên thiết bị phù hợp hay không. Mặc định là self.device_placement.

Chuẩn bị một Optimizer của PyTorch để huấn luyện trong bất kỳ cấu hình phân tán nào. Khuyến nghị sử dụng Accelerator.prepare() thay thế.

Ví dụ:

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

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

prepare_scheduler

< >

( scheduler: LRScheduler )

Tham số

  • scheduler (torch.optim.lr_scheduler.LRScheduler) — Một scheduler PyTorch thông thường để chuẩn bị

Chuẩn bị một PyTorch Scheduler để huấn luyện trong bất kỳ cấu hình phân tán nào. Khuyến nghị sử dụng Accelerator.prepare() thay thế.

Ví dụ:

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

Thay thế trực tiếp cho print() để chỉ in ra một lần trên mỗi máy chủ.

Ví dụ:

>>> from accelerate import Accelerator

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

hồ sơ

< >

( profile_handler: ProfileKwargs | None = None )

Tham số

  • profile_handler (ProfileKwargs, tùy chọn) — Profile handler được sử dụng cho context manager này. Nếu không được truyền vào, sẽ sử dụng profile handler được thiết lập trong đối tượng Accelerator.

Sẽ tạo hồ sơ cho mã bên trong trình quản lý ngữ cảnh. Hồ sơ sẽ được lưu vào tệp Chrome Trace nếu profile_handler.output_trace_dir được đặt.

Có thể truyền vào một profile_handler khác để ghi đè lên giá trị đã được thiết lập trong đối tượng Accelerator.

Ví dụ:

# 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

Tham số

  • tensor (torch.Tensor, hoặc tuple/list/dictionary lồng nhau của torch.Tensor) — Các tensor cần giảm (reduce) trên tất cả các tiến trình.
  • reduction (str, tuỳ chọn, mặc định là “sum”) — Loại reduction, có thể là một trong ‘sum’, ‘mean’, ‘max’ hoặc ‘none’. Nếu là ‘none’, sẽ không thực hiện bất kỳ thao tác nào.
  • scale (float, tuỳ chọn, mặc định là 1.0) — Giá trị tỷ lệ mặc định được áp dụng sau khi thực hiện reduce, chỉ hợp lệ trên XLA.

Trả về

torch.Tensor, hoặc một tuple/list/dictionary lồng nhau của torch.Tensor

Tensor đã được giảm.

Giảm các giá trị trong tensor trên tất cả các tiến trình dựa trên reduction.

Lưu ý: Tất cả các tiến trình nhận được giá trị đã giảm.

Ví dụ:

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

Ghi chú về objects và sẽ lưu hoặc tải chúng trong save_state hoặc load_state.

Các đối tượng này nên được sử dụng khi trạng thái đang được tải hoặc lưu trong cùng một script. Chúng không được thiết kế để sử dụng trong các script khác nhau.

Mọi object phải có hàm load_state_dict và state_dict để được lưu trữ.

Ví dụ:

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

Tham số

Trả về

torch.utils.hooks.RemovableHandle

một handle có thể được sử dụng để gỡ hook đã thêm bằng cách gọi handle.remove()

Đăng ký một pre hook để chạy trước khi load_checkpoint được gọi trong Accelerator.load_state().

Hook phải có chữ ký sau:

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

Tham số models là các mô hình được lưu trong trạng thái accelerator dưới accelerator._models, và tham số input_dir là tham số input_dir được truyền vào Accelerator.load_state().

Chỉ nên được sử dụng cùng với Accelerator.register_save_state_pre_hook(). Có thể hữu ích để nạp cấu hình bên cạnh trọng số mô hình. Cũng có thể được sử dụng để ghi đè việc nạp mô hình bằng một phương pháp tùy chỉnh. Trong trường hợp này, hãy đảm bảo xóa các mô hình đã được nạp khỏi danh sách models.

register_save_state_pre_hook

< >

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

Tham số

Trả về

torch.utils.hooks.RemovableHandle

một handle có thể được sử dụng để gỡ hook đã thêm bằng cách gọi handle.remove()

Đăng ký một pre hook để chạy trước khi save_checkpoint được gọi trong Accelerator.save_state().

Hook phải có chữ ký sau:

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

Tham số models là các mô hình được lưu trong trạng thái accelerator dưới accelerator._models, tham số weights là các state dict của models, và tham số input_dir là tham số input_dir được truyền vào Accelerator.load_state().

Chỉ nên được sử dụng cùng với Accelerator.register_load_state_pre_hook(). Có thể hữu ích để lưu trữ các cấu hình bên cạnh trọng số mô hình. Cũng có thể được sử dụng để ghi đè việc lưu mô hình bằng một phương pháp tùy chỉnh. Trong trường hợp này, hãy đảm bảo loại bỏ các trọng số đã được tải khỏi danh sách trọng số.

lưu

< >

( objfsafe_serialization = False )

Tham số

  • obj (object) — Đối tượng cần lưu.
  • f (str hoặc os.PathLike) — Nơi lưu trữ nội dung của obj.
  • safe_serialization (bool, tùy chọn, mặc định là False) — Có lưu obj bằng safetensors hay không

Lưu đối tượng được truyền vào đĩa một lần cho mỗi máy. Sử dụng thay cho torch.save.

Lưu ý: Nếu save_on_each_node được truyền vào dưới dạng ProjectConfiguration, đối tượng sẽ được lưu một lần trên mỗi node, thay vì chỉ lưu một lần trên node chính.

Ví dụ:

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

Tham số

  • model — (torch.nn.Module): Mô hình cần được lưu. Mô hình có thể được bọc hoặc không bọc.
  • save_directory (str hoặc os.PathLike) — Thư mục để lưu. Sẽ được tạo nếu chưa tồn tại.
  • max_shard_size (int hoặc str, tuỳ chọn, mặc định là "10GB") — Kích thước tối đa của một checkpoint trước khi được chia shard. Các checkpoint sau khi chia shard sẽ có kích thước nhỏ hơn mức này. Nếu được biểu diễn dưới dạng chuỗi, cần là các chữ số theo sau bởi một đơn vị (như "5MB").

    Nếu một trọng số đơn lẻ của mô hình lớn hơn max_shard_size, nó sẽ nằm trong một shard checkpoint riêng, có kích thước lớn hơn max_shard_size.

  • safe_serialization (bool, tùy chọn, mặc định là True) — Có nên lưu mô hình bằng safetensors hay theo cách truyền thống của PyTorch (sử dụng pickle) hay không.

Lưu một mô hình để có thể nạp lại bằng load_checkpoint_in_model

Ví dụ:

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

Tham số

  • output_dir (str hoặc os.PathLike) — Tên của thư mục để lưu tất cả các trọng số và trạng thái liên quan.
  • safe_serialization (bool, tùy chọn, mặc định là True) — Có nên lưu mô hình bằng safetensors hay theo cách truyền thống của PyTorch (sử dụng pickle) hay không.
  • save_model_func_kwargs (dict, tùy chọn) — Các đối số từ khóa bổ sung để lưu mô hình, có thể được truyền cho hàm lưu cơ bản, chẳng hạn như các đối số tùy chọn cho hàm save_checkpoint của DeepSpeed.

Lưu các trạng thái hiện tại của mô hình, bộ tối ưu hóa, bộ điều chỉnh tỷ lệ, bộ tạo RNG và các đối tượng đã đăng ký vào một thư mục.

Nếu một ProjectConfiguration được truyền vào đối tượng Accelerator với automatic_checkpoint_naming được bật thì các checkpoint sẽ được lưu vào self.project_dir/checkpoints. Nếu số lần lưu hiện tại lớn hơn total_limit thì bản lưu cũ nhất sẽ bị xóa. Mỗi checkpoint được lưu trong các thư mục riêng biệt có tên checkpoint_<iteration>.

Ngược lại, chúng chỉ được lưu vào output_dir.

Chỉ nên được sử dụng khi muốn lưu checkpoint trong quá trình huấn luyện và khôi phục trạng thái trong cùng một môi trường.

Ví dụ:

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

< >

( )

Đặt tensor kích hoạt nội bộ thành 1 trên tiến trình hiện tại. Một bước kiểm tra sau đó nên được thực hiện bằng cách sử dụng điều này, sẽ kiểm tra trên tất cả các tiến trình.

Lưu ý: Không yêu cầu wait_for_everyone()

Ví dụ:

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

bỏ qua các lô đầu tiên

< >

( dataloadernum_batches: int = 0 )

Tham số

  • dataloader (torch.utils.data.DataLoader) — Trình tải dữ liệu mà bạn muốn bỏ qua các lô (batch).
  • num_batches (int, tùy chọn, mặc định là 0) — Số lượng batch cần bỏ qua

Tạo một torch.utils.data.DataLoader mới sẽ bỏ qua hiệu quả num_batches đầu tiên.

Ví dụ:

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

Tham số

  • inputs (list, tuple, torch.Tensor, hoặc dict của list/tuple/torch.Tensor) — Đầu vào cần chia giữa các tiến trình.
  • apply_padding (bool, optional, mặc định là False) — Có áp dụng padding bằng cách lặp lại phần tử cuối cùng của đầu vào để tất cả các tiến trình có cùng số lượng phần tử hay không. Hữu ích khi thực hiện các thao tác như Accelerator.gather() trên các đầu ra hoặc khi truyền vào ít đầu vào hơn số lượng tiến trình. Nếu áp dụng, hãy nhớ loại bỏ các phần tử đã được padding sau đó.

Tách input giữa self.num_processes một cách nhanh chóng và sau đó có thể được sử dụng trên tiến trình đó. Hữu ích khi thực hiện suy luận phân tán, chẳng hạn như với các prompt khác nhau.

Lưu ý rằng khi sử dụng dict, tất cả các khóa cần có cùng số lượng phần tử.

Ví dụ:

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

Tham số

  • model (torch.nn.Module) — Mô hình cần kích hoạt đồng bộ hóa gradient.

Kích hoạt việc đồng bộ hóa gradient trong bước truyền ngược tiếp theo của mô hình sau nhiều lần truyền thuận dưới Accelerator.no_sync (chỉ áp dụng trong các kịch bản đa GPU).

Nếu script không được khởi chạy ở chế độ phân tán, trình quản lý ngữ cảnh này sẽ không thực hiện gì.

Ví dụ:

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

Tham số

  • optimizer (torch.optim.Optimizer hoặc list[torch.optim.Optimizer], không bắt buộc) — Bộ tối ưu hóa (optimizer) mà bạn muốn thực hiện việc khử tỷ lệ (unscale) cho các gradient. Nếu không được đặt, hệ thống sẽ khử tỷ lệ gradient trên tất cả các optimizer đã được truyền vào prepare().

Hủy chuẩn hóa gradient trong huấn luyện độ chính xác hỗn hợp với AMP. Đây là một thao tác không làm gì (noop) trong tất cả các cài đặt khác.

Có lẽ nên được gọi thông qua Accelerator.clipgrad_norm() hoặc Accelerator.clipgrad_value()

Ví dụ:

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

Tham số

  • model (torch.nn.Module) — Mô hình cần tách lớp bọc.
  • keep_fp32_wrapper (bool, tùy chọn, mặc định là True) — Có nên giữ lại hook mixed precision nếu nó đã được thêm vào hay không.
  • keep_torch_compile (bool, tùy chọn, mặc định là True) — Có nên giữ nguyên mô hình đã được biên dịch hay không nếu nó đã được biên dịch.

Trả về

torch.nn.Module

Mô hình đã được giải bọc.

Bỏ lớp bổ sung có thể đã được thêm vào model bởi prepare(). Hữu ích trước khi lưu model.

Ví dụ:

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

Kiểm tra rằng model chưa được chuẩn bị cho suy luận mô hình lớn với device-map giống auto.

wait_for_everyone

< >

( )

Sẽ dừng việc thực thi của tiến trình hiện tại cho đến khi mọi tiến trình khác đều đã đạt đến điểm đó (do đó, điều này không làm gì khi script chỉ được chạy trong một tiến trình). Hữu ích để thực hiện trước khi lưu một mô hình.

Ví dụ:

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

Công cụ tiện ích

accelerate.utils.gather_object

< >

( object: Any )

Tham số

  • object (danh sách/bộ/dictionary lồng nhau của các object có thể picklable) — Dữ liệu cần thu thập.

Thu thập đệ quy đối tượng trong danh sách/bộ/bộ từ điển lồng nhau của các đối tượng từ tất cả các thiết bị.

Update on GitHub