# Song song dữ liệu phân mảnh hoàn toàn

Để tăng tốc độ huấn luyện các mô hình lớn trên kích thước lô (batch size) lớn hơn, chúng ta có thể sử dụng mô hình song song dữ liệu phân mảnh hoàn toàn (fully sharded data parallel). Kiểu hệ thống song song dữ liệu này cho phép nạp thêm dữ liệu và các mô hình lớn hơn bằng cách phân mảnh trạng thái tối ưu hóa, gradient và tham số. Để tìm hiểu thêm về nó và các lợi ích, hãy xem [bài viết trên blog về Fully Sharded Data Parallel](https://pytorch.org/blog/introducing-pytorch-fully-sharded-data-parallel-api/). Chúng tôi đã tích hợp tính năng huấn luyện Fully Sharded Data Parallel (FSDP) mới nhất của PyTorch. Tất cả những gì bạn cần làm là bật nó thông qua cấu hình.

## Cách hoạt động ngay khi cài đặt

Trên máy của bạn, chỉ cần chạy:

```bash
accelerate config
```

và trả lời các câu hỏi được đưa ra. Thao tác này sẽ tạo ra một tệp cấu hình, được sử dụng tự động để thiết lập đúng các tùy chọn mặc định khi thực hiện

```bash
accelerate launch my_script.py --args_to_my_script
```

Ví dụ, đây là cách bạn chạy `examples/nlp_example.py` (từ thư mục gốc của repo) với FSDP được bật:

```bash
compute_environment: LOCAL_MACHINE
debug: false
distributed_type: FSDP
downcast_bf16: 'no'
fsdp_config:
  fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
  fsdp_backward_prefetch_policy: BACKWARD_PRE
  fsdp_forward_prefetch: false
  fsdp_cpu_ram_efficient_loading: true
  fsdp_offload_params: false
  fsdp_sharding_strategy: FULL_SHARD
  fsdp_state_dict_type: SHARDED_STATE_DICT
  fsdp_sync_module_states: true
  fsdp_transformer_layer_cls_to_wrap: BertLayer
  fsdp_use_orig_params: true
machine_rank: 0
main_training_function: main
mixed_precision: bf16
num_machines: 1
num_processes: 2
rdzv_backend: static
same_network: true
tpu_env: []
tpu_use_cluster: false
tpu_use_sudo: false
use_cpu: false
```

```bash
accelerate launch examples/nlp_example.py
```

Hiện tại, `Accelerate` hỗ trợ các cấu hình sau thông qua CLI:

`fsdp_sharding_strategy`: [1] FULL_SHARD (chia nhỏ trạng thái optimizer, gradient và tham số), [2] SHARD_GRAD_OP (chia nhỏ trạng thái optimizer và gradient), [3] NO_SHARD (DDP), [4] HYBRID_SHARD (chia nhỏ trạng thái optimizer, gradient và tham số trong mỗi node trong khi mỗi node có bản sao đầy đủ), [5] HYBRID_SHARD_ZERO2 (chia nhỏ trạng thái optimizer và gradient trong mỗi node trong khi mỗi node có bản sao đầy đủ). Để biết thêm thông tin, vui lòng tham khảo [tài liệu chính thức của PyTorch](https://pytorch.org/docs/stable/fsdp.html#torch.distributed.fsdp.ShardingStrategy).

`fsdp_offload_params` : Quyết định việc có offload tham số và gradient sang CPU hay không

`fsdp_auto_wrap_policy`: [1] TRANSFORMER_BASED_WRAP, [2] SIZE_BASED_WRAP, [3] NO_WRAP

`fsdp_transformer_layer_cls_to_wrap`: Chỉ áp dụng cho Transformers. Khi sử dụng `fsdp_auto_wrap_policy=TRANSFORMER_BASED_WRAP`, người dùng có thể cung cấp một chuỗi các tên lớp transformer layer cách nhau bằng dấu phẩy (phân biệt hoa thường) để bọc, ví dụ: `BertLayer`, `GPTJBlock`, `T5Block`, `BertLayer,BertEmbeddings,BertSelfOutput`. Điều này quan trọng vì các submodule chia sẻ trọng số (ví dụ: các lớp embedding) không nên nằm trong các đơn vị FSDP bọc khác nhau. Khi sử dụng chính sách này, việc bọc sẽ diễn ra cho mỗi khối chứa Multi-Head Attention tiếp theo là một vài lớp MLP. Các lớp còn lại, bao gồm các embedding được chia sẻ, sẽ được bọc một cách thuận tiện trong cùng một đơn vị FSDP ngoài cùng. Do đó, hãy sử dụng chính sách này cho các mô hình dựa trên transformer. Bạn có thể sử dụng `model._no_split_modules` cho các mô hình Transformer bằng cách trả lời `yes` cho `Do you want to use the model's `_no_split_modules` to wrap. It will try to use `model._no_split_modules` when possible.

`fsdp_min_num_params`: số lượng tham số tối thiểu khi sử dụng `fsdp_auto_wrap_policy=SIZE_BASED_WRAP`.

`fsdp_backward_prefetch_policy`: [1] BACKWARD_PRE, [2] BACKWARD_POST, [3] NO_PREFETCH

`fsdp_forward_prefetch`: nếu là True, FSDP sẽ chủ động tải trước (prefetch) thao tác all-gather tiếp theo trong khi thực hiện bước forward. Chỉ nên sử dụng cho các mô hình có đồ thị tĩnh vì quá trình tải trước tuân theo thứ tự thực thi của lần lặp đầu tiên. Ví dụ, nếu thứ tự của các module con thay đổi động trong quá trình mô hình chạy, hãy tắt tính năng này.

`fsdp_state_dict_type`: [1] FULL_STATE_DICT, [2] LOCAL_STATE_DICT, [3] SHARDED_STATE_DICT

`fsdp_use_orig_params`: Nếu là True, cho phép `requires_grad` không đồng nhất trong quá trình khởi tạo, nghĩa là hỗ trợ các tham số đóng băng và tham số có thể huấn luyện xen kẽ. Cài đặt này hữu ích trong các trường hợp như tinh chỉnh hiệu quả tham số như đã thảo luận trong [bài đăng này](https://dev-discuss.pytorch.org/t/rethinking-pytorch-fully-sharded-data-parallel-fsdp-from-first-principles/1019). Tùy chọn này cũng cho phép có nhiều nhóm tham số tối ưu hóa. Nên đặt thành `True` khi tạo bộ tối ưu hóa trước khi chuẩn bị/bọc mô hình bằng FSDP.

`fsdp_cpu_ram_efficient_loading`: Chỉ áp dụng cho các mô hình Transformers. Nếu đặt là True, chỉ tiến trình đầu tiên tải checkpoint mô hình được huấn luyện trước, trong khi tất cả các tiến trình khác có trọng số rỗng. Bạn nên đặt giá trị này thành False nếu gặp lỗi khi tải mô hình Transformers được huấn luyện trước bằng phương thức `from_pretrained`. Khi cài đặt này là True, `fsdp_sync_module_states` cũng phải được đặt thành True, nếu không tất cả các tiến trình ngoại trừ tiến trình chính sẽ có trọng số ngẫu nhiên, dẫn đến hành vi không mong muốn trong quá trình huấn luyện. Để hoạt động, hãy đảm bảo nhóm tiến trình phân tán được khởi tạo trước khi gọi phương thức `from_pretrained` của Transformers. Khi sử dụng API Trainer, nhóm tiến trình phân tán được khởi tạo khi bạn tạo một instance của lớp `TrainingArguments`.

`fsdp_sync_module_states`: Nếu là True, mỗi đơn vị FSDP được bọc riêng lẻ sẽ phát trực tiếp (broadcast) các tham số module từ rank 0.

Để có thêm quyền kiểm soát chi tiết và tinh tế hơn, bạn có thể chỉ định các tham số FSDP khác thông qua `FullyShardedDataParallelPlugin`. Khi tạo đối tượng `FullyShardedDataParallelPlugin`, hãy truyền vào các tham số không có trong cấu hình accelerate hoặc nếu bạn muốn ghi đè lên chúng. Các tham số FSDP sẽ được chọn dựa trên tệp cấu hình accelerate hoặc các đối số của lệnh khởi chạy, và các tham số khác mà bạn truyền trực tiếp thông qua đối tượng `FullyShardedDataParallelPlugin` sẽ thiết lập/ghi đè lên chúng.

Dưới đây là một ví dụ:

```py
from accelerate import FullyShardedDataParallelPlugin
from torch.distributed.fsdp.fully_sharded_data_parallel import FullOptimStateDictConfig, FullStateDictConfig

fsdp_plugin = FullyShardedDataParallelPlugin(
    state_dict_config=FullStateDictConfig(offload_to_cpu=False, rank0_only=False),
    optim_state_dict_config=FullOptimStateDictConfig(offload_to_cpu=False, rank0_only=False),
)

accelerator = Accelerator(fsdp_plugin=fsdp_plugin)
```

## Lưu và tải

Cách được khuyến nghị mới để lưu checkpoint khi sử dụng mô hình FSDP là dùng `SHARDED_STATE_DICT` làm `StateDictType` khi thiết lập cấu hình accelerate. Dưới đây là đoạn mã để lưu bằng tiện ích `save_state` của accelerate.

```py
accelerator.save_state("ckpt")
```

Kiểm tra thư mục checkpoint để xem mô hình và optimizer dưới dạng các shard cho mỗi tiến trình:
```
ls ckpt
# optimizer_0  pytorch_model_0  random_states_0.pkl  random_states_1.pkl  scheduler.bin

cd ckpt

ls optimizer_0
# __0_0.distcp  __1_0.distcp

ls pytorch_model_0
# __0_0.distcp  __1_0.distcp
```

Để tải chúng lại nhằm tiếp tục quá trình huấn luyện, hãy sử dụng tiện ích `load_state` của accelerate

```py
accelerator.load_state("ckpt")
```

Khi sử dụng `save_pretrained` của transformers, hãy truyền `state_dict=accelerator.get_state_dict(model)` để lưu state dict của model. Dưới đây là một ví dụ:

```diff
  unwrapped_model.save_pretrained(
      args.output_dir,
      is_main_process=accelerator.is_main_process,
      save_function=accelerator.save,
+     state_dict=accelerator.get_state_dict(model),
)
```

### State Dict

`accelerator.get_state_dict` sẽ gọi triển khai `model.state_dict` bên dưới bằng trình quản lý ngữ cảnh `FullStateDictConfig(offload_to_cpu=True, rank0_only=True)` để lấy state dict chỉ cho rank 0 và nó sẽ được offload sang CPU.

Sau đó, bạn có thể truyền `state` vào phương thức `save_pretrained`. Có một số chế độ cho `StateDictType` và `FullStateDictConfig` mà bạn có thể sử dụng để kiểm soát hành vi của `state_dict`. Để biết thêm thông tin, hãy xem [tài liệu PyTorch](https://pytorch.org/docs/stable/fsdp.html).

Nếu bạn chọn sử dụng `StateDictType.SHARDED_STATE_DICT`, trọng số của mô hình trong quá trình `Accelerator.save_state` sẽ được tách thành `n` tệp cho mỗi phần chia nhỏ trên mô hình. Để gộp chúng lại thành một từ điển duy nhất nhằm nạp lại vào mô hình sau khi huấn luyện, bạn có thể sử dụng tiện ích `merge_weights`:

```py
from accelerate.utils import merge_fsdp_weights

# Our weights are saved usually in a `pytorch_model_fsdp_{model_number}` folder
merge_fsdp_weights("pytorch_model_fsdp_0", "output_path", safe_serialization=True)
```
Đầu ra cuối cùng sau đó sẽ được lưu vào `model.safetensors` hoặc `pytorch_model.bin` (nếu `safe_serialization=False` được truyền vào).

Bạn cũng có thể gọi điều này bằng CLI:
```bash
accelerate merge-weights pytorch_model_fsdp_0/ output_path
```

## Ánh xạ giữa các chiến lược chia nhỏ của FSDP và các giai đoạn ZeRO của DeepSpeed
* `FULL_SHARD` tương ứng với `ZeRO Stage-3` của DeepSpeed. Chia nhỏ trạng thái optimizer, gradient và tham số.
* `SHARD_GRAD_OP` tương ứng với `ZeRO Stage-2` của DeepSpeed. Chia nhỏ trạng thái optimizer và gradient.
* `NO_SHARD` tương ứng với `ZeRO Stage-0`. Không có sharding, trong đó mỗi GPU có bản sao đầy đủ của model, optimizer states và gradients.
* `HYBRID_SHARD` tương ứng với `ZeRO++ Stage-3` trong đó `zero_hpz_partition_size=<num_gpus_per_node>`. Ở đây, các trạng thái optimizer, gradient và tham số sẽ được chia nhỏ (shard) trong mỗi node, trong khi mỗi node giữ một bản sao đầy đủ.

## Một số lưu ý cần biết

- Trong trường hợp có nhiều mô hình, hãy truyền các optimizer vào lệnh gọi prepare theo cùng thứ tự với các mô hình tương ứng, nếu không `accelerator.save_state()` và `accelerator.load_state()` sẽ dẫn đến hành vi sai/không mong muốn.
- Tính năng này không tương thích với `--predict_with_generate` trong script `run_translation.py` của thư viện `Transformers`.

Để có nhiều quyền kiểm soát hơn, người dùng có thể tận dụng `FullyShardedDataParallelPlugin`. Sau khi tạo một instance của class này, người dùng có thể truyền nó vào quá trình khởi tạo class Accelerator. Để biết thêm thông tin về các tùy chọn này, vui lòng tham khảo mã nguồn [FullyShardedDataParallel](https://github.com/pytorch/pytorch/blob/0df2e863fbd5993a7b9e652910792bd21a516ff3/torch/distributed/fsdp/fully_sharded_data_parallel.py#L236) của PyTorch.

    Nếu bạn quan tâm đến những điểm tương đồng và khác biệt giữa FSDP và DeepSpeed, hãy xem [hướng dẫn về khái niệm tại đây](../concept_guides/fsdp_and_deepspeed)!
    

