# Bộ tăng tốc

[Accelerator](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.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](../basic_tutorials/migration) để tìm hiểu cách thêm [Accelerator](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator) vào script của bạn.

## Accelerator[[api]][[accelerate.Accelerator]]

#### accelerate.Accelerator[[accelerate.Accelerator]]

```python
accelerate.Accelerator(device_placement: bool = True, split_batches: bool = <object object at 0x7f7bf6a755a0>, mixed_precision: PrecisionType | str | None = None, gradient_accumulation_steps: int = 1, cpu: bool = False, dataloader_config: DataLoaderConfiguration | None = None, deepspeed_plugin: DeepSpeedPlugin | dict[str, DeepSpeedPlugin] | None = None, fsdp_plugin: FullyShardedDataParallelPlugin | None = None, torch_tp_plugin: TorchTensorParallelPlugin | None = None, megatron_lm_plugin: MegatronLMPlugin | None = None, rng_types: list[str | RNGType] | None = None, log_with: str | LoggerType | GeneralTracker | list[str | LoggerType | GeneralTracker] | None = None, project_dir: str | os.PathLike | None = None, project_config: ProjectConfiguration | None = None, gradient_accumulation_plugin: GradientAccumulationPlugin | None = None, step_scheduler_with_optimizer: bool = True, kwargs_handlers: list[KwargsHandler] | None = None, dynamo_backend: DynamoBackend | str | None = None, dynamo_plugin: TorchDynamoPlugin | None = None, deepspeed_plugins: DeepSpeedPlugin | dict[str, DeepSpeedPlugin] | None = None, parallelism_config: ParallelismConfig | None = None)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L178)

**Tham số:**

device_placement (`bool`, *tùy chọn*, mặc định là `True`) : Xác định xem accelerator 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`, *optional*, mặc định là 1) : Số bước cần trôi qua trước khi tích lũy gradient. Một số > 1 nên được kết hợp với `Accelerator.accumulate`. Nếu không được truyền, 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 thực thi 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 trên một tiến trình duy nhất.

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](/docs/accelerate/v1.16.0/vi/package_reference/deepspeed#accelerate.DeepSpeedPlugin) hoặc dict của `str` : [DeepSpeedPlugin](/docs/accelerate/v1.16.0/vi/package_reference/deepspeed#accelerate.DeepSpeedPlugin), *tuỳ chọn*): Điều 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](/docs/accelerate/v1.16.0/vi/package_reference/fsdp#accelerate.FullyShardedDataParallelPlugin), *tùy chọn*) : Điều chỉnh các đối số liên quan đến FSDP 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*

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](/docs/accelerate/v1.16.0/vi/package_reference/megatron_lm#accelerate.utils.MegatronLMPlugin), *tùy chọn*) : Điều 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](/docs/accelerate/v1.16.0/vi/package_reference/utilities#accelerate.utils.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) - Bất kỳ loại thiết bị nào của bộ tăng tốc PyTorch đã đượ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 không có sampler trong dataloader của bạn) hoặc của tập dữ liệu dạng iterable (nếu có) nếu tập dữ liệu cơ sở 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](/docs/accelerate/v1.16.0/vi/package_reference/utilities#accelerate.utils.LoggerType) hoặc [GeneralTracker](/docs/accelerate/v1.16.0/vi/package_reference/tracking#accelerate.tracking.GeneralTracker), *tuỳ chọn*) : Một danh sách các logger để thiết lập cho việc 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ẽ nhận 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](/docs/accelerate/v1.16.0/vi/package_reference/utilities#accelerate.utils.ProjectConfiguration), *tuỳ chọn*) : Cấu hình cho cách xử lý việc lưu trạng thái.

project_dir (`str`, `os.PathLike`, *tuỳ 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 (stepped) cùng thời điểm 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 (danh sách [KwargsHandler](/docs/accelerate/v1.16.0/vi/package_reference/kwargs#accelerate.utils.KwargsHandler), *tùy chọn*) : Một danh sách các [KwargsHandler](/docs/accelerate/v1.16.0/vi/package_reference/kwargs#accelerate.utils.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, hồ sơ hóa hoặc độ chính xác hỗn hợp. Xem [kwargs](kwargs) để biết thêm thông tin.

dynamo_backend (`str` hoặc [DynamoBackend](/docs/accelerate/v1.16.0/vi/package_reference/utilities#accelerate.utils.DynamoBackend), *tuỳ chọn*, mặc định là `"no"`) : Đặt thành một trong các dynamo backends 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](/docs/accelerate/v1.16.0/vi/package_reference/utilities#accelerate.utils.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](/docs/accelerate/v1.16.0/vi/package_reference/utilities#accelerate.utils.GradientAccumulationPlugin), *tùy chọn*) : 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](/docs/accelerate/v1.16.0/vi/package_reference/utilities#accelerate.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í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](/docs/accelerate/v1.16.0/vi/package_reference/state#accelerate.state.AcceleratorState)) -- Trạng thái của 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[[accelerate.Accelerator.accumulate]]

```python
accumulate(*models)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L1215)

**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ụ:

```python
>>> 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[[accelerate.Accelerator.autocast]]

```python
autocast(autocast_handler: AutocastKwargs = None)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L4091)

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 tính năng này được bật. Không có gì khác sẽ xảy ra trong trường hợp ngược lại.

Bạn 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ụ:

```python
>>> from accelerate import Accelerator

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

#### backward[[accelerate.Accelerator.backward]]

```python
backward(loss, **kwargs)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L2735)

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

```python
>>> from accelerate import Accelerator

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

#### check_trigger[[accelerate.Accelerator.check_trigger]]

```python
check_trigger()
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L2795)

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

```python
>>> 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[[accelerate.Accelerator.clear]]

```python
clear(*objects)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L3864)

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 mô hình/bộ tối ưu hóa khác nhau.

Ví dụ:

```python
>>> 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_[[accelerate.Accelerator.clip_grad_norm_]]

```python
clip_grad_norm_(parameters, max_norm, norm_type = 2)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L2892)

**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ụ:

```python
>>> 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_[[accelerate.Accelerator.clip_grad_value_]]

```python
clip_grad_value_(parameters, clip_value)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L2953)

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

Ví dụ:

```python
>>> 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[[accelerate.Accelerator.deepspeed_ulysses_dl_adapter]]

```python
deepspeed_ulysses_dl_adapter(dl, model)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L2461)

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[[accelerate.Accelerator.end_training]]

```python
end_training()
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L3334)

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

```python
>>> from accelerate import Accelerator

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

#### free_memory[[accelerate.Accelerator.free_memory]]

```python
free_memory(*objects)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L3835)

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

```python
>>> 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[[accelerate.Accelerator.gather]]

```python
gather(tensor)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L2982)

**Tham số:**

tensor (`torch.Tensor`, hoặc một 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ụ:

```python
>>> # 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[[accelerate.Accelerator.gather_for_metrics]]

```python
gather_for_metrics(input_data, use_gather_object = False)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L3014)

**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`) : Có nên é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 việc 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 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ụ:

```python
>>> # 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[[accelerate.Accelerator.get_state_dict]]

```python
get_state_dict(model, unwrap = True)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L3916)

**Tham số:**

model (`torch.nn.Module`) : Một mô hình PyTorch được truyền qua [Accelerator.prepare()](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator.prepare)

unwrap (`bool`, *tùy 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()](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator.prepare), có thể không ở độ chính xác đầy đủ.

Ví dụ:

```python
>>> 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[[accelerate.Accelerator.get_tracker]]

```python
get_tracker(name: str, unwrap: bool = False)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L3270)

**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ề trình theo dõi đã được bọ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ụ:

```python
>>> from accelerate import Accelerator

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

#### join_uneven_inputs[[accelerate.Accelerator.join_uneven_inputs]]

```python
join_uneven_inputs(joinables, even_batches = None)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L1260)

**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ụ:

```python
>>> 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[[accelerate.Accelerator.load_state]]

```python
load_state(input_dir: str | None = None, load_kwargs: dict | None = None, **load_model_func_kwargs)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L3696)

**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 sử dụng `automatic_checkpoint_naming`, 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à bộ tối ưu hóa 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()](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator.save_state). Nếu một tệp không được đăng ký để lưu checkpoint, nó sẽ không được tải nếu được lưu trong thư mục.

Ví dụ:

```python
>>> 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[[accelerate.Accelerator.local_main_process_first]]

```python
local_main_process_first()
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L1070)

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

```python
>>> 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[[accelerate.Accelerator.lomo_backward]]

```python
lomo_backward(loss: torch.Tensor, learning_rate: float)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L4234)

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

#### main_process_first[[accelerate.Accelerator.main_process_first]]

```python
main_process_first()
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L1048)

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

```python
>>> 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[[accelerate.Accelerator.maybe_context_parallel]]

```python
maybe_context_parallel(buffers: list[torch.Tensor] | None = None, buffer_seq_dims: list[int] | None = None, no_restore_buffers: set[torch.Tensor] | None = None)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L4024)

**Tham số:**

buffers (`list[torch.Tensor]`, `optional`) : Các buffers sẽ được chia nhỏ dọc theo chiều sequence. Các ví dụ phổ biến là inputs, labels hoặc các buffers positional embedding. Context manager này sẽ sửa đổi các buffers này tại chỗ, và sau khi thoát khỏi context, các buffers 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 buffers 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 này phải là 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ù để bật ít
các thay đổi mã sẽ không gây ra Exception.

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

```python
>>> 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[[accelerate.Accelerator.no_sync]]

```python
no_sync(model)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L1092)

**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ụ:

```python
>>> 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[[accelerate.Accelerator.on_last_process]]

```python
on_last_process(function: Callable[..., Any])
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L916)

**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ụ:
```python
# 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[[accelerate.Accelerator.on_local_main_process]]

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

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L874)

**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ụ:
```python
# 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[[accelerate.Accelerator.on_local_process]]

```python
on_local_process(function: Callable[..., Any] | None = None, local_process_index: int | None = None)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L1000)

**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ụ:
```python
# 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[[accelerate.Accelerator.on_main_process]]

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

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L835)

**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ụ:

```python
>>> 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[[accelerate.Accelerator.on_process]]

```python
on_process(function: Callable[..., Any] | None = None, process_index: int | None = None)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L955)

**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ụ:
```python
# 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[[accelerate.Accelerator.pad_across_processes]]

```python
pad_across_processes(tensor, dim = 0, pad_index = 0, pad_first = False)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L3124)

**Tham số:**

tensor (danh sách/bộ tuple/từ điển lồng nhau của `torch.Tensor`) : Dữ liệu cần thu thập.

dim (`int`, *optional*, mặc định là 0) : Chiều cần đệm.

pad_index (`int`, *tuỳ 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ụ:

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

#### chuẩn bị[[accelerate.Accelerator.prepare]]

```python
prepare(*args, device_placement = None)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L1375)

**Tham số:**

- ***args** (list of objects) : Một trong các loại đối tượng sau:  - `torch.utils.data.DataLoader`: PyTorch Dataloader - `torch.nn.Module`: PyTorch Module - `torch.optim.Optimizer`: PyTorch Optimizer - `torch.optim.lr_scheduler.LRScheduler`: PyTorch LR Scheduler

device_placement (`list[bool]`, *tùy chọn*) : Dùng để tùy chỉnh việc có thực hiện việc đặt thiết bị tự động cho từng đối tượng được truyền vào hay không. 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 thứ tự.

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

Ví dụ:

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

```python
>>> 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[[accelerate.Accelerator.prepare_data_loader]]

```python
prepare_data_loader(data_loader: torch.utils.data.DataLoader, device_placement = None, slice_fn_for_dispatch = None)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L2594)

**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 lô (batches) lên thiết bị phù hợp trong dataloader đã được chuẩn bị hay không. Mặc định sẽ 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/vi/package_reference/utilities#accelerate.utils.slice_tensors). This argument is used only when `dispatch_batches` is set to `True` 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()](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator.prepare) thay thế.

Ví dụ:

```python
>>> 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[[accelerate.Accelerator.prepare_model]]

```python
prepare_model(model: torch.nn.Module, device_placement: bool | None = None, evaluation_mode: bool = False)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L1737)

**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ỳ hình thức độ 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 sẽ là `self.device_placement`.

evaluation_mode (`bool`, *tùy chọn*, mặc định là `False`) : Có nên đặt mô hình chỉ ở 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()](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator.prepare) thay thế.

Ví dụ:

```python
>>> from accelerate import Accelerator

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

#### prepare_optimizer[[accelerate.Accelerator.prepare_optimizer]]

```python
prepare_optimizer(optimizer: torch.optim.Optimizer, device_placement = None)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L2653)

**Tham số:**

optimizer (`torch.optim.Optimizer`) : Một optimizer PyTorch thuần túy để 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 sẽ 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()](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator.prepare) thay thế.

Ví dụ:

```python
>>> import torch
>>> from accelerate import Accelerator

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

#### prepare_scheduler[[accelerate.Accelerator.prepare_scheduler]]

```python
prepare_scheduler(scheduler: LRScheduler)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L2694)

**Tham số:**

scheduler (`torch.optim.lr_scheduler.LRScheduler`) : Một trình lập lịch PyTorch cơ bản để 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()](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator.prepare) thay thế.

Ví dụ:

```python
>>> 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[[accelerate.Accelerator.print]]

```python
print(*args, **kwargs)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L1343)

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

Ví dụ:

```python
>>> from accelerate import Accelerator

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

#### profile[[accelerate.Accelerator.profile]]

```python
profile(profile_handler: ProfileKwargs | None = None)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L4116)

**Tham số:**

profile_handler (`ProfileKwargs`, *tùy chọn*) : Bộ xử lý hồ sơ (profile handler) cần sử dụng cho trình quản lý ngữ cảnh này. Nếu không được truyền vào, sẽ sử dụng bộ xử lý đã đượ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ụ:

```python
# 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[[accelerate.Accelerator.reduce]]

```python
reduce(tensor, reduction = 'sum', scale = 1.0)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L3087)

**Tham số:**

tensor (`torch.Tensor`, hoặc một 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`, *tùy chọn*, mặc định là "sum") : Một kiểu giảm (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`, *optional*, mặc định là 1.0) : Một giá trị tỷ lệ mặc định được áp dụng sau khi thực hiện reduce, chỉ có hiệu lực 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 đều nhận được giá trị đã giảm.

Ví dụ:

```python
>>> # 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[[accelerate.Accelerator.register_for_checkpointing]]

```python
register_for_checkpointing(*objects)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L3988)

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

```python
>>> 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[[accelerate.Accelerator.register_load_state_pre_hook]]

```python
register_load_state_pre_hook(hook: Callable[..., None])
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L3665)

**Tham số:**

hook (`Callable`) : Một hàm sẽ được gọi trong [Accelerator.load_state()](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator.load_state) trước `load_checkpoint`.

**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()](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.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()](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator.load_state).

Chỉ nên được sử dụng cùng với [Accelerator.register_save_state_pre_hook()](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.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[[accelerate.Accelerator.register_save_state_pre_hook]]

```python
register_save_state_pre_hook(hook: Callable[..., None])
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L3498)

**Tham số:**

hook (`Callable`) : Một hàm sẽ được gọi trong [Accelerator.save_state()](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator.save_state) trước `save_checkpoint`.

**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()](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.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()](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator.load_state).

Chỉ nên được sử dụng cùng với [Accelerator.register_load_state_pre_hook()](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator.register_load_state_pre_hook). Có thể hữu ích để lưu trữ 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[[accelerate.Accelerator.save]]

```python
save(obj, f, safe_serialization = False)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L3355)

**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ụ:

```python
>>> from accelerate import Accelerator

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

#### save_model[[accelerate.Accelerator.save_model]]

```python
save_model(model: torch.nn.Module, save_directory: Union[str, os.PathLike], max_shard_size: Union[int, str] = '10GB', safe_serialization: bool = True)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L3385)

**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`, *tùy chọn*, mặc định là `"10GB"`) : Kích thước tối đa của một checkpoint trước khi được chia nhỏ. Các checkpoint sau khi chia nhỏ 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ị (ví dụ `"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ó 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ụ:

```python
>>> from accelerate import Accelerator

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

#### save_state[[accelerate.Accelerator.save_state]]

```python
save_state(output_dir: str | None = None, safe_serialization: bool = True, **save_model_func_kwargs)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L3530)

**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ó 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ụ:

```python
>>> 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[[accelerate.Accelerator.set_trigger]]

```python
set_trigger()
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L2769)

Đặ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ụ:

```python
>>> 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[[accelerate.Accelerator.skip_first_batches]]

```python
skip_first_batches(dataloader, num_batches: int = 0)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L4187)

**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 lô (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ụ:

```python
>>> 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[[accelerate.Accelerator.split_between_processes]]

```python
split_between_processes(inputs: list | tuple | dict | torch.Tensor, apply_padding: bool = False)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L793)

**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`) : Xác định 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ụ:

```python
# 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[[accelerate.Accelerator.trigger_sync_in_backward]]

```python
trigger_sync_in_backward(model)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L1141)

**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ụ:

```python
>>> 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[[accelerate.Accelerator.unscale_gradients]]

```python
unscale_gradients(optimizer = None)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L2828)

**Tham số:**

optimizer (`torch.optim.Optimizer` hoặc `list[torch.optim.Optimizer]`, *tùy chọn*) : Bộ tối ưu hóa để khử tỷ lệ gradient. Nếu không được đặt, sẽ khử tỷ lệ gradient trên tất cả các bộ tối ưu hóa đã được truyền vào [prepare()](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator.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.clip_grad_norm_()](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator.clip_grad_norm_) hoặc [Accelerator.clip_grad_value_()](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator.clip_grad_value_)

Ví dụ:

```python
>>> 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[[accelerate.Accelerator.unwrap_model]]

```python
unwrap_model(model, keep_fp32_wrapper: bool = True, keep_torch_compile: bool = True)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L3159)

**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`) : Xác định có giữ lại hook độ chính xác hỗn hợp hay không nếu nó đã được thêm vào.

keep_torch_compile (`bool`, *tùy chọn*, mặc định là `True`) : Có nên không unwrap mô hình đã biên dịch nếu nó đã được biên dịch hay không.

**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()](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator.prepare). Hữu ích trước khi lưu model.

Ví dụ:

```python
>>> # 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[[accelerate.Accelerator.verify_device_map]]

```python
verify_device_map(model: torch.nn.Module)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L4223)

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[[accelerate.Accelerator.wait_for_everyone]]

```python
wait_for_everyone()
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/accelerator.py#L3193)

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 đó, hàm 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ụ:

```python
>>> # 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]]

#### accelerate.utils.gather_object[[accelerate.utils.gather_object]]

```python
accelerate.utils.gather_object(object: Any)
```

[Nguồn](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/operations.py#L495)

**Tham số:**

object (nested list/tuple/dictionary of picklable object) : Dữ liệu cần thu thập.

**Trả về:**

Cấu trúc dữ liệu giống như `object` với tất cả các đối tượng được gửi đến mọi thiết bị.

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

