# FSDP2

[Fully Sharded Data Parallel (FSDP2)](https://docs.pytorch.org/tutorials/intermediate/FSDP_tutorial.html) chia nhỏ (shard) mô hình, gradient và trạng thái optimizer trên các GPU. Trước khi tính toán, mỗi GPU thu thập một bộ tham số hoàn chỉnh từ tất cả các shard, sau đó giải phóng chúng. Việc chia nhỏ cho phép huấn luyện các mô hình lớn hơn bộ nhớ của một GPU đơn lẻ, với chi phí là lượng giao tiếp nhiều hơn so với [DDP](./ddp). Hãy dùng FSDP khi mô hình hoặc trạng thái optimizer của bạn không vừa với bộ nhớ của một GPU đơn lẻ.

```text
                      ┌─────────────────┐
                      │  training data  │
                      └────────┬────────┘
            ┌──────────────────┼──────────────────┐
            │ shard 0          │ shard 1          │ shard 2
            ▼                  ▼                  ▼
     ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
     │  param      │    │  param      │    │  param      │
     │  shard 0    │    │  shard 1    │    │  shard 2    │
     │  GPU 0      │    │  GPU 1      │    │  GPU 2      │
     └──────┬──────┘    └──────┬──────┘    └──────┬──────┘
            │                  │                  │
            └──────── all-gather (params) ────────┘
                               │
                    full params on each GPU
                               │
            ┌──────────────────┼──────────────────┐
            ▼                  ▼                  ▼
         forward             forward             forward
            │                  │                  │
            └───── reduce-scatter (grads) ────────┘
                               │
            ┌──────────────────┼──────────────────┐
            ▼                  ▼                  ▼
     grad shard 0       grad shard 1       grad shard 2
     optim shard 0      optim shard 1      optim shard 2
        step               step               step
```

## Chiến lược phân mảnh

FSDP2 kiểm soát việc chia shard bằng `~TrainingArguments.fsdp_config`. Đặt `fsdp=True` để bật FSDP, và đặt `reshard_after_forward` trong cấu hình FSDP để chọn mức đánh đổi giữa bộ nhớ và thông lượng.

| `reshard_after_forward` | hành vi |
|---|---|
| `true` | tái phân chia tham số sau bước truyền trực tiếp để tiết kiệm thêm bộ nhớ |
| `false` | giữ các tham số đã được thu thập giữa bước forward và backward để tránh việc thực hiện lại all-gather, với cái giá là bộ nhớ đỉnh cao hơn |

`auto_wrap_policy` kiểm soát cách các module được bọc thành các đơn vị FSDP. Mặc định là `"TRANSFORMER_BASED_WRAP"`, bọc các lớp transformer của mô hình. Nếu không bọc (`"NO_WRAP"`), toàn bộ mô hình sẽ là một đơn vị FSDP và bạn sẽ mất đi lợi ích về bộ nhớ từ việc chia nhỏ (sharding).

## Cấu hình FSDP

Các trường này kiểm soát cách FSDP2 bọc, chia nhỏ và tải mô hình. `reshard_after_forward` và `auto_wrap_policy` được đề cập trong [Các chiến lược chia nhỏ](#sharding-strategies).

- `cpu_offload` chuyển các tham số và gradient sang CPU khi chúng không được sử dụng để tiết kiệm bộ nhớ GPU.

- `transformer_layer_cls_to_wrap` xác định lớp transformer cần bọc thành một đơn vị FSDP khi `auto_wrap_policy` là `"TRANSFORMER_BASED_WRAP"`. Mỗi đơn vị tự quản lý các thao tác gather và scatter của riêng mình. Chỉ các tham số của đơn vị hiện tại được gather trong quá trình forward. Tham số của các đơn vị trước đó được giải phóng để tiết kiệm bộ nhớ.

  Việc chỉ bọc model cấp cao nhất sẽ không tiết kiệm được bộ nhớ GPU. Việc bọc từng lớp `Linear` riêng lẻ sẽ khiến chi phí liên lạc giữa các đơn vị rất cao. Để trống trường này và FSDP sẽ đọc giá trị từ định nghĩa model.

- `min_num_params` đặt số lượng tham số tối thiểu cho mỗi module để bọc dựa trên kích thước. Nó chỉ được sử dụng khi `auto_wrap_policy` là `"SIZE_BASED_WRAP"`.

- `state_dict_type` kiểm soát định dạng checkpoint. Mặc định là `"FULL_STATE_DICT"` cho một checkpoint tương thích với Transformers duy nhất. Sử dụng `"SHARDED_STATE_DICT"` để có một tệp checkpoint cho mỗi rank, nhanh hơn với các mô hình lớn. Checkpoint dạng sharded chỉ có thể nạp lại vào FSDP, vì vậy hãy lưu một `"FULL_STATE_DICT"` cho checkpoint cuối cùng mà bạn muốn chia sẻ hoặc nạp bên ngoài FSDP.

- `cpu_ram_efficient_loading` chỉ tải checkpoint từ đĩa trên rank 0. Các GPU khác khởi tạo một mô hình rỗng và nhận trọng số qua broadcast, tránh việc nhiều tiến trình tải một mô hình lớn vào RAM CPU.

- `activation_checkpointing` tính lại các activation trong quá trình backward thay vì lưu trữ chúng. Hãy dùng tính năng này thay vì [gradient checkpointing](./grad_checkpointing) trong [TrainingArguments](/docs/transformers/v5.23.0/vi/main_classes/trainer#transformers.TrainingArguments). Việc đặt cả hai sẽ gây ra lỗi.

Cấu hình huấn luyện FSDP bằng cách sử dụng một [tệp cấu hình Accelerate](./accelerate#accelerate-config-file) hoặc một tệp cấu hình FSDP được truyền vào `fsdp_config`.

Chạy lệnh [accelerate config](https://huggingface.co/docs/accelerate/en/package_reference/cli#accelerate-config) và trả lời các câu hỏi về phần cứng và cấu hình huấn luyện của bạn. Thao tác này sẽ tạo tệp `default_config.yaml` trong bộ nhớ đệm của bạn.

Chạy [accelerate launch](https://huggingface.co/docs/accelerate/en/package_reference/cli#accelerate-launch) với một script dựa trên [Trainer](/docs/transformers/v5.23.0/vi/main_classes/trainer#transformers.Trainer). `fsdp_config` là không cần thiết vì tệp cấu hình Accelerate đã bao gồm các cài đặt tương tự.

```cli
accelerate launch train.py
```

```json
{
  "version": 2,
  "reshard_after_forward": true,
  "cpu_offload": false,
  "auto_wrap_policy": "TRANSFORMER_BASED_WRAP",
  "transformer_layer_cls_to_wrap": ["LlamaDecoderLayer"],
  "state_dict_type": "FULL_STATE_DICT",
  "cpu_ram_efficient_loading": true,
  "activation_checkpointing": true
}
```

Đặt `fsdp=True` và truyền tệp cấu hình FSDP vào `fsdp_config`.

```py
from transformers import TrainingArguments

TrainingArguments(
    ...,
    fsdp=True,
    fsdp_config="path/to/fsdp.json",
)
```

> [!TIP]
> Đối với các mô hình mixture-of-experts, `fsdp_size` có thể được kết hợp với `tp_size` và `ep_size` để chia nhỏ các chuyên gia trên một chiều lưới và mọi thứ còn lại trên chiều kia. Xem [expert parallelism](./expert_parallelism#combining-with-fsdp2).

## Đánh giá với song song ngữ cảnh

Context parallelism (CP) với FSDP2 được cấu hình thông qua `ParallelismConfig` `cp_size` của Accelerate. Khi khởi chạy, hãy truyền cả `--use_parallelism_config` và `--parallelism_config_cp_size`. Một `parallelism_config` không rỗng trong file YAML của Accelerate cũng sẽ bật `use_parallelism_config`. Nếu chỉ truyền `--parallelism_config_cp_size` đơn lẻ, tham số này sẽ bị bỏ qua và giữ nguyên `cp_size=1`.

Dưới FSDP2, CP chia nhỏ (shard) chuỗi (sequence) trên các rank để mỗi GPU giữ một lát cắt của ngữ cảnh (`allgather` hoặc `alltoall`). Điều này khác với [Ulysses sequence parallelism](./deepspeed_alst), chạy thông qua DeepSpeed ALST và sử dụng `sp_size` trên cùng một cấu hình. Hãy chọn CP hoặc Ulysses SP. Không đặt cả `cp_size` và `sp_size` lớn hơn 1.

[evaluate()](/docs/transformers/v5.23.0/vi/main_classes/trainer#transformers.Trainer.evaluate) sử dụng ngữ cảnh song song ngữ cảnh (context-parallel) giống như [train()](/docs/transformers/v5.23.0/vi/main_classes/trainer#transformers.Trainer.train) thông qua [prediction_step()](/docs/transformers/v5.23.0/vi/main_classes/trainer#transformers.Trainer.prediction_step). Mỗi rank chạy shard chuỗi của nó trong khi ngữ cảnh đó đang hoạt động. `eval_loss` là loss chính xác (không bị nhân với `cp_size`). Early stopping và `load_best_model_at_end` sử dụng metric đó.

Logits vẫn được chia mảnh dọc theo chuỗi, và không có gì ghép chúng lại thành các dự đoán có độ dài đầy đủ. Dự đoán và `compute_metrics` trên logits không được hỗ trợ dưới CP.

Tái sử dụng lệnh khởi chạy FSDP2 + `cp_size` hiện có khi bạn cần `eval_loss`.

Nếu bạn tạo lớp con của [prediction_step()](/docs/transformers/v5.23.0/vi/main_classes/trainer#transformers.Trainer.prediction_step) và tự đếm token, hãy đếm `num_items_in_batch` trước khi vào ngữ cảnh context-parallel. Trong khi ngữ cảnh đó đang hoạt động, các bộ đệm chuỗi được chia nhỏ tại chỗ giữa các rank. Đếm sau đó sẽ dẫn đến việc đếm thiếu batch. [Trainer](/docs/transformers/v5.23.0/vi/main_classes/trainer#transformers.Trainer) mặc định đã đếm trước, và bạn chỉ cần điều này nếu bạn ghi đè `prediction_step`.

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

- Xem [DDP](./ddp) để huấn luyện song song dữ liệu khi mô hình của bạn vừa trên một GPU.
- Xem [DeepSpeed](./deepspeed) để tìm hiểu về tối ưu hóa ZeRO và offloading NVMe.
- Đối với FSDP trên TPU với PyTorch/XLA, hãy đặt `xla`, `xla_fsdp_settings` và `xla_fsdp_grad_ckpt` trong `~TrainingArguments.fsdp_config`.
- Đọc [chương FSDP](https://nanotron-ultrascale-playbook.static.hf.space/index.html#zero-3:_adding_parameter_partitioning_(fsdp)) trong The Ultra-Scale Playbook để biết thêm thông tin về cách FSDP hoạt động.

