# Tham quan nhanh

Có nhiều cách để khởi chạy và chạy mã của bạn tùy thuộc vào môi trường huấn luyện ([torchrun](https://pytorch.org/docs/stable/elastic/run.html), [DeepSpeed](https://www.deepspeed.ai/), v.v.) và phần cứng khả dụng. Accelerate cung cấp một giao diện thống nhất để khởi chạy và huấn luyện trên các cấu hình phân tán khác nhau, cho phép bạn tập trung vào mã huấn luyện PyTorch của mình thay vì các chi tiết phức tạp khi điều chỉnh mã để phù hợp với những cấu hình này. Điều này cho phép bạn dễ dàng mở rộng mã PyTorch của mình để huấn luyện và suy luận trên các cấu hình phân tán với phần cứng như GPU và TPU. Accelerate cũng cung cấp Big Model Inference để việc tải và chạy suy luận với các mô hình thực sự lớn, thường không vừa trong bộ nhớ, trở nên dễ tiếp cận hơn.

Buổi giới thiệu nhanh này trình bày ba tính năng chính của Accelerate:

* giao diện khởi chạy dòng lệnh thống nhất cho các script huấn luyện phân tán
* một thư viện huấn luyện để điều chỉnh mã huấn luyện PyTorch chạy trên các cấu hình phân tán khác nhau
* Suy luận Mô hình Lớn

## Giao diện khởi động thống nhất

Accelerate tự động chọn các giá trị cấu hình phù hợp cho bất kỳ framework huấn luyện phân tán nào (DeepSpeed, FSDP, v.v.) thông qua một tệp cấu hình thống nhất được tạo từ lệnh [`accelerate config`](package_reference/cli#accelerate-config). Bạn cũng có thể truyền các giá trị cấu hình một cách tường minh vào dòng lệnh, điều này hữu ích trong một số tình huống nhất định, chẳng hạn như khi bạn đang sử dụng SLURM.

Nhưng trong hầu hết các trường hợp, bạn luôn nên chạy [`accelerate config`](package_reference/cli#accelerate-config) trước tiên để giúp Accelerate tìm hiểu về cấu hình huấn luyện của bạn.

```bash
accelerate config
```

Lệnh [`accelerate config`](package_reference/cli#accelerate-config) tạo và lưu tệp default_config.yaml trong thư mục cache của Accelerate. Tệp này lưu trữ cấu hình cho môi trường huấn luyện của bạn, giúp Accelerate khởi chạy chính xác script huấn luyện dựa trên máy của bạn.

Sau khi bạn đã cấu hình môi trường, bạn có thể kiểm tra cài đặt của mình bằng [`accelerate test`](package_reference/cli#accelerate-test), lệnh này sẽ khởi chạy một script ngắn để kiểm tra môi trường phân tán.

```bash
accelerate test
```

> [!TIP]
> Thêm `--config_file` vào lệnh `accelerate test` hoặc `accelerate launch` để chỉ định vị trí của tệp cấu hình nếu tệp được lưu ở vị trí không mặc định như thư mục cache.

Khi môi trường đã được thiết lập, hãy chạy script huấn luyện của bạn bằng [`accelerate launch`](package_reference/cli#accelerate-launch)!

```bash
accelerate launch path_to_script.py --args_for_the_script
```

Để tìm hiểu thêm, hãy xem hướng dẫn [Khởi chạy mã phân tán](basic_tutorials/launch) để biết thêm thông tin về việc khởi chạy các script của bạn.

Chúng tôi cũng có một [kho cấu hình](https://github.com/huggingface/accelerate/blob/main/examples/config_yaml_templates) giới thiệu một số cấu hình ví dụ **tối giản** được tạo sẵn cho nhiều thiết lập khác nhau mà bạn có thể chạy.

## Điều chỉnh mã huấn luyện

Tính năng chính tiếp theo của Accelerate là lớp [Accelerator](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator), giúp điều chỉnh mã PyTorch của bạn để chạy trên các cấu hình phân tán khác nhau.

Bạn chỉ cần thêm vài dòng mã vào script huấn luyện để cho phép nó chạy trên nhiều GPU hoặc TPU.

```diff
+ from accelerate import Accelerator
+ accelerator = Accelerator()

+ device = accelerator.device
+ model, optimizer, training_dataloader, scheduler = accelerator.prepare(
+     model, optimizer, training_dataloader, scheduler
+ )

  for batch in training_dataloader:
      optimizer.zero_grad()
      inputs, targets = batch
-     inputs = inputs.to(device)
-     targets = targets.to(device)
      outputs = model(inputs)
      loss = loss_function(outputs, targets)
+     accelerator.backward(loss)
      optimizer.step()
      scheduler.step()
```

1. Nhập và khởi tạo lớp [Accelerator](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator) ở đầu script huấn luyện của bạn. Lớp [Accelerator](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator) khởi tạo mọi thứ cần thiết cho huấn luyện phân tán và tự động phát hiện môi trường huấn luyện của bạn (một máy có GPU, một máy có nhiều GPU, nhiều máy có nhiều GPU hoặc TPU, v.v.) dựa trên cách mã được khởi chạy.

```python
from accelerate import Accelerator

accelerator = Accelerator()
```

2. Xóa các lệnh gọi như `.cuda()` trên mô hình và dữ liệu đầu vào của bạn. Lớp [Accelerator](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator) sẽ tự động đặt các đối tượng này lên thiết bị phù hợp cho bạn.

> [!WARNING]
> Bước này là *tùy chọn* nhưng được coi là thực hành tốt nhất để cho phép Accelerate xử lý việc đặt thiết bị. Bạn cũng có thể vô hiệu hóa việc đặt thiết bị tự động bằng cách truyền `device_placement=False` khi khởi tạo [Accelerator](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator). Nếu bạn muốn đặt rõ ràng các đối tượng lên một thiết bị bằng `.to(device)`, hãy đảm bảo sử dụng `accelerator.device` thay thế. Ví dụ, nếu bạn tạo một optimizer trước khi đặt model lên `accelerator.device`, quá trình huấn luyện sẽ thất bại trên TPU.

> [!WARNING]
> Accelerate không sử dụng chuyển dữ liệu không chặn (non-blocking transfers) theo mặc định cho việc đặt thiết bị tự động, điều này có thể dẫn đến các đồng bộ hóa CUDA không mong muốn. Bạn có thể bật chuyển dữ liệu không chặn bằng cách truyền một [DataLoaderConfiguration](/docs/accelerate/v1.16.0/vi/package_reference/utilities#accelerate.DataLoaderConfiguration) với `non_blocking=True` được đặt làm `dataloader_config` khi khởi tạo [Accelerator](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator). Như thường lệ, chuyển dữ liệu không chặn chỉ hoạt động nếu dataloader cũng được đặt `pin_memory=True`. Hãy lưu ý rằng việc sử dụng chuyển dữ liệu không chặn từ GPU sang CPU có thể gây ra kết quả không chính xác nếu điều này dẫn đến các thao tác CPU được thực hiện trên các tensor chưa sẵn sàng.

```py
device = accelerator.device
```

3. Truyền tất cả các đối tượng PyTorch liên quan đến huấn luyện (optimizer, model, dataloader(s), learning rate scheduler) vào phương thức [prepare()](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator.prepare) ngay khi chúng được tạo ra. Phương thức này bọc model trong một container được tối ưu hóa cho cấu hình phân tán của bạn, sử dụng phiên bản optimizer và scheduler của Accelerate, và tạo ra một phiên bản sharded của dataloader để phân phối trên các GPU hoặc TPU.

```python
model, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
    model, optimizer, train_dataloader, lr_scheduler
)
```

4. Thay thế `loss.backward()` bằng [backward()](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator.backward) để sử dụng phương thức `backward()` chính xác cho cấu hình huấn luyện của bạn.

```py
accelerator.backward(loss)
```

Đọc hướng dẫn [cơ chế bên trong của Accelerate](concept_guides/internal_mechanism) để tìm hiểu thêm chi tiết về cách Accelerate điều chỉnh mã của bạn.

### Đánh giá phân tán

Để thực hiện đánh giá phân tán, hãy truyền dataloader xác thực của bạn vào phương thức [prepare()](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator.prepare):

```python
validation_dataloader = accelerator.prepare(validation_dataloader)
```

Mỗi thiết bị trong cấu hình phân tán của bạn chỉ nhận được một phần dữ liệu đánh giá, điều này có nghĩa là bạn nên nhóm các dự đoán lại với nhau bằng phương thức [gather_for_metrics()](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator.gather_for_metrics). Phương thức này yêu cầu tất cả các tensor phải có cùng kích thước trên mỗi tiến trình, vì vậy nếu tensor của bạn có kích thước khác nhau trên mỗi tiến trình (ví dụ khi đệm động đến độ dài tối đa trong một lô), bạn nên sử dụng phương thức [pad_across_processes()](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator.pad_across_processes) để đệm tensor của bạn đến kích thước lớn nhất giữa các tiến trình. Lưu ý rằng các tensor cần phải là 1 chiều và chúng ta sẽ nối các tensor dọc theo chiều thứ nhất.

```python
for inputs, targets in validation_dataloader:
    predictions = model(inputs)
    # Gather all predictions and targets
    all_predictions, all_targets = accelerator.gather_for_metrics((predictions, targets))
    # Example of use with a *Datasets.Metric*
    metric.add_batch(all_predictions, all_targets)
```

Đối với các trường hợp phức tạp hơn (ví dụ: tensor 2D, không muốn nối các tensor, dict của các tensor 3D), bạn có thể truyền `use_gather_object=True` vào `gather_for_metrics`. Thao tác này sẽ trả về danh sách các đối tượng sau khi thu thập. Lưu ý rằng việc sử dụng nó với các tensor GPU không được hỗ trợ tốt và kém hiệu quả.

> [!TIP]
> Dữ liệu ở cuối một tập dữ liệu có thể bị nhân bản để lô (batch) có thể được chia đều cho tất cả các worker. Phương thức [gather_for_metrics()](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator.gather_for_metrics) tự động loại bỏ dữ liệu bị nhân bản để tính toán chỉ số chính xác hơn.

## Suy luận Mô hình Lớn

Big Model Inference của Accelerate có hai tính năng chính, [init_empty_weights()](/docs/accelerate/v1.16.0/vi/package_reference/big_modeling#accelerate.init_empty_weights) và [load_checkpoint_and_dispatch()](/docs/accelerate/v1.16.0/vi/package_reference/big_modeling#accelerate.load_checkpoint_and_dispatch), để nạp các mô hình lớn cho suy luận, vốn thường không vừa trong bộ nhớ.

> [!TIP]
> Xem hướng dẫn [Xử lý các mô hình lớn cho suy luận](concept_guides/big_model_inference) để hiểu rõ hơn về cách Big Model Inference hoạt động bên trong.

### Khởi tạo trọng số rỗng

Trình quản lý ngữ cảnh [init_empty_weights()](/docs/accelerate/v1.16.0/vi/package_reference/big_modeling#accelerate.init_empty_weights) khởi tạo các mô hình có kích thước bất kỳ bằng cách tạo ra *khung mô hình* và di chuyển, đặt các tham số vào thiết bị [**meta**](https://pytorch.org/docs/main/meta.html) của PyTorch mỗi khi chúng được tạo. Nhờ đó, không phải tất cả trọng số đều được nạp ngay lập tức mà chỉ một phần nhỏ của mô hình được nạp vào bộ nhớ tại một thời điểm.

Ví dụ, việc nạp một mô hình [Mixtral-8x7B](https://huggingface.co/mistralai/Mixtral-8x7B-Instruct-v0.1) rỗng sẽ tốn ít bộ nhớ hơn đáng kể so với việc nạp đầy đủ các mô hình và trọng số trên CPU.

```py
from accelerate import init_empty_weights
from transformers import AutoConfig, AutoModelForCausalLM

config = AutoConfig.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1")
with init_empty_weights():
    model = AutoModelForCausalLM.from_config(config)
```

### Tải và phân phối trọng số

Hàm [load_checkpoint_and_dispatch()](/docs/accelerate/v1.16.0/vi/package_reference/big_modeling#accelerate.load_checkpoint_and_dispatch) nạp checkpoint đầy đủ hoặc phân mảnh vào mô hình trống, và tự động phân phối trọng số trên tất cả các thiết bị khả dụng.

Tham số `device_map` xác định vị trí đặt từng lớp của mô hình, và việc chỉ định `"auto"` sẽ đặt chúng lên GPU trước, sau đó là CPU, và cuối cùng là ổ cứng dưới dạng tensor ánh xạ bộ nhớ nếu vẫn còn thiếu bộ nhớ. Sử dụng tham số `no_split_module_classes` để chỉ định các module không nên được chia tách giữa các thiết bị (thường là những module có kết nối dư).

```py
from accelerate import load_checkpoint_and_dispatch

model_checkpoint = "your-local-model-folder"
model = load_checkpoint_and_dispatch(
    model, checkpoint=model_checkpoint, device_map="auto", no_split_module_classes=['Block']
)
```

## Các bước tiếp theo

Giờ đây, khi bạn đã được giới thiệu các tính năng chính của Accelerate, các bước tiếp theo của bạn có thể bao gồm:

* Xem qua các [tutorials](basic_tutorials/overview) để có cái nhìn tổng quan nhẹ nhàng về Accelerate. Điều này đặc biệt hữu ích nếu bạn mới bắt đầu với huấn luyện phân tán và thư viện này.
* Tìm hiểu các [hướng dẫn](usage_guides/explore) để xem cách sử dụng Accelerate cho các trường hợp sử dụng cụ thể.
* Sâu hơn về mặt khái niệm về cách Accelerate hoạt động bên trong bằng cách đọc các [hướng dẫn khái niệm](concept_guides/internal_mechanism).
* Tra cứu các lớp và lệnh trong [tham chiếu API](package_reference/accelerator) để xem các tham số và tùy chọn khả dụng.

