# DeepSpeed

[DeepSpeed](https://github.com/deepspeedai/DeepSpeed) triển khai mọi nội dung được mô tả trong [bài báo ZeRO](https://huggingface.co/papers/1910.02054). Một số tối ưu hóa nổi bật là:

1. Phân vùng trạng thái tối ưu hóa (ZeRO stage 1)
2. Phân chia gradient (ZeRO stage 2)
3. Phân chia tham số (ZeRO stage 3)
4. Xử lý huấn luyện độ chính xác hỗn hợp tùy chỉnh
5. Một loạt các bộ tối ưu hóa nhanh dựa trên CUDA-extension
6. ZeRO-Offload sang CPU và Disk/NVMe
7. Phân cấp các tham số của mô hình (ZeRO++)

ZeRO-Offload có một bài báo riêng: [ZeRO-Offload: Democratizing Billion-Scale Model Training](https://huggingface.co/papers/2101.06840). Và hỗ trợ NVMe được mô tả trong bài báo [ZeRO-Infinity: Breaking the GPU Memory Wall for Extreme Scale Deep Learning](https://huggingface.co/papers/2104.07857).

DeepSpeed ZeRO-2 chủ yếu chỉ được sử dụng cho huấn luyện, vì các tính năng của nó không hữu ích cho suy luận.

DeepSpeed ZeRO-3 cũng có thể được sử dụng cho suy luận vì nó cho phép nạp các mô hình rất lớn lên nhiều GPU, điều mà một GPU đơn lẻ không thể thực hiện được.

Accelerate tích hợp [DeepSpeed](https://github.com/deepspeedai/DeepSpeed) thông qua 2 tùy chọn:

1. Tích hợp các tính năng của DeepSpeed thông qua việc chỉ định `deepspeed config file` trong `accelerate config`. Bạn chỉ cần cung cấp tệp cấu hình tùy chỉnh của mình hoặc sử dụng mẫu của chúng tôi. Phần lớn tài liệu này tập trung vào tính năng này. Tính năng này hỗ trợ tất cả các tính năng cốt lõi của DeepSpeed và mang lại cho người dùng nhiều sự linh hoạt. Người dùng có thể phải thay đổi một vài dòng mã tùy thuộc vào cấu hình.
2. Tích hợp thông qua `deepspeed_plugin`. Cách này hỗ trợ một tập con các tính năng của DeepSpeed và sử dụng các tùy chọn mặc định cho phần còn lại của cấu hình. Người dùng không cần thay đổi bất kỳ mã nào và đây là lựa chọn phù hợp cho những ai hài lòng với hầu hết các cài đặt mặc định của DeepSpeed.

## Những gì được tích hợp?

Huấn luyện:

1. Accelerate tích hợp tất cả các tính năng của DeepSpeed ZeRO. Điều này bao gồm tất cả các giai đoạn ZeRO 1, 2 và 3 cũng như ZeRO-Offload, ZeRO-Infinity (có thể offload sang disk/NVMe) và ZeRO++.
Dưới đây là mô tả ngắn về Data Parallelism sử dụng ZeRO - Zero Redundancy Optimizer cùng với sơ đồ từ [bài đăng trên blog](https://www.microsoft.com/en-us/research/blog/zero-deepspeed-new-system-optimizations-enable-training-models-with-over-100-billion-parameters/) này ![ZeRO Data Parallelism](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/parallelism-zero.png)

(Nguồn: [liên kết](https://www.microsoft.com/en-us/research/blog/zero-deepspeed-new-system-optimizations-enable-training-models-with-over-100-billion-parameters/))

 a. **Giai đoạn 1** : Phân tán trạng thái tối ưu hóa trên các worker/GPU song song dữ liệu

 b. **Giai đoạn 2** : Chia nhỏ trạng thái optimizer + gradient trên các worker/GPU song song dữ liệu

 c. **Giai đoạn 3**: Chia nhỏ trạng thái optimizer + gradient + tham số mô hình trên các worker/GPU song song dữ liệu

 d. **Optimizer Offload**: Chuyển các gradient + trạng thái optimizer sang CPU/Disk, xây dựng trên nền tảng của ZERO Stage 2

 e. **Param Offload**: Chuyển các tham số mô hình sang CPU/Đĩa, xây dựng trên nền tảng của ZERO Stage 3

 f. **Phân vùng phân cấp**: Cho phép huấn luyện đa nút hiệu quả với huấn luyện song song dữ liệu giữa các nút và chia nhỏ ZeRO-3 trong một nút, được xây dựng dựa trên ZeRO Stage 3.

Lưu ý: Đối với Disk Offload, ổ đĩa nên là NVME để đạt tốc độ hợp lý, nhưng về mặt kỹ thuật nó hoạt động trên bất kỳ ổ đĩa nào

Suy luận:

1. DeepSpeed ZeRO Inference hỗ trợ ZeRO stage 3 với ZeRO-Infinity. Nó sử dụng cùng giao thức ZeRO như khi huấn luyện, nhưng không dùng optimizer và lr scheduler, và chỉ stage 3 là liên quan. Để biết thêm chi tiết, xem: [ZeRO Inference](#zero-inference).

## Nó hoạt động như thế nào?

**Điều kiện tiên quyết**: Cài đặt phiên bản DeepSpeed >=0.6.5. Vui lòng tham khảo [Chi tiết cài đặt DeepSpeed](https://github.com/deepspeedai/DeepSpeed#installation) để biết thêm thông tin.

Trước tiên, chúng ta sẽ xem xét tích hợp dễ sử dụng thông qua `accelerate config`. Tiếp theo là tích hợp `deepspeed config file` linh hoạt và giàu tính năng hơn.

### Plugin DeepSpeed của Accelerate
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. Hệ thống sẽ hỏi liệu bạn có muốn sử dụng tệp cấu hình cho DeepSpeed hay không, và bạn nên trả lời là không. Sau đó, hãy trả lời các câu hỏi sau để tạo một cấu hình cơ bản cho DeepSpeed. 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 ví dụ NLP `examples/nlp_example.py` (từ thư mục gốc của repo) với DeepSpeed Plugin:

**Ví dụ về Plugin DeepSpeed ZeRO Stage-2**
```bash
compute_environment: LOCAL_MACHINE
deepspeed_config:
 gradient_accumulation_steps: 1
 gradient_clipping: 1.0
 offload_optimizer_device: none
 offload_param_device: none
 zero3_init_flag: true
 zero_stage: 2
distributed_type: DEEPSPEED
fsdp_config: {}
machine_rank: 0
main_process_ip: null
main_process_port: null
main_training_function: main
mixed_precision: fp16
num_machines: 1
num_processes: 2
use_cpu: false
```

```bash
accelerate launch examples/nlp_example.py --mixed_precision fp16
```

**Ví dụ về DeepSpeed Plugin với ZeRO Stage-3 và CPU Offload**
```bash
compute_environment: LOCAL_MACHINE
deepspeed_config:
  gradient_accumulation_steps: 1
  gradient_clipping: 1.0
  offload_optimizer_device: cpu
  offload_param_device: cpu
  zero3_init_flag: true
  zero3_save_16bit_model: true
  zero_stage: 3
distributed_type: DEEPSPEED
fsdp_config: {}
machine_rank: 0
main_process_ip: null
main_process_port: null
main_training_function: main
mixed_precision: fp16
num_machines: 1
num_processes: 2
use_cpu: false
```

```bash
accelerate launch examples/nlp_example.py --mixed_precision fp16
```

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

```bash
`zero_stage`: [0] Disabled, [1] optimizer state partitioning, [2] optimizer+gradient state partitioning and [3] optimizer+gradient+parameter partitioning
`gradient_accumulation_steps`: Number of training steps to accumulate gradients before averaging and applying them.
`gradient_clipping`: Enable gradient clipping with value.
`offload_optimizer_device`: [none] Disable optimizer offloading, [cpu] offload optimizer to CPU, [nvme] offload optimizer to NVMe SSD. Only applicable with ZeRO >= Stage-2.
`offload_optimizer_nvme_path`: Decides Nvme Path to offload optimizer states. If unspecified, will default to 'none'.
`offload_param_device`: [none] Disable parameter offloading, [cpu] offload parameters to CPU, [nvme] offload parameters to NVMe SSD. Only applicable with ZeRO Stage-3.
`offload_param_nvme_path`: Decides Nvme Path to offload parameters. If unspecified, will default to 'none'.
`zero3_init_flag`: Decides whether to enable `deepspeed.zero.Init` for constructing massive models. Only applicable with ZeRO Stage-3.
`zero3_save_16bit_model`: Decides whether to save 16-bit model weights when using ZeRO Stage-3.
`mixed_precision`: `no` for FP32 training, `fp16` for FP16 mixed-precision training and `bf16` for BF16 mixed-precision training.
`deepspeed_moe_layer_cls_names`: Comma-separated list of transformer Mixture-of-Experts (MoE) layer class names (case-sensitive) to wrap ,e.g, `MixtralSparseMoeBlock`, `Qwen2MoeSparseMoeBlock`, `JetMoEAttention,JetMoEBlock` ...
`deepspeed_hostfile`: DeepSpeed hostfile for configuring multi-node compute resources.
`deepspeed_exclusion_filter`: DeepSpeed exclusion filter string when using mutli-node setup.
`deepspeed_inclusion_filter`: DeepSpeed inclusion filter string when using mutli-node setup.
`deepspeed_multinode_launcher`: DeepSpeed multi-node launcher to use, e.g. `pdsh`, `standard`, `openmpi`, `mvapich`, `mpich`, `slurm`, `nossh` (requires DeepSpeed >= 0.14.5). If unspecified, will default to `pdsh`.
`deepspeed_config_file`: path to the DeepSpeed config file in `json` format. See the next section for more details on this.
```
Để có thể tinh chỉnh nhiều tùy chọn hơn, bạn sẽ cần sử dụng một tệp cấu hình DeepSpeed.

### Tệp cấu hình DeepSpeed
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. Hệ thống sẽ hỏi liệu bạn có muốn sử dụng tệp cấu hình cho deepspeed hay không, bạn hãy trả lời có và cung cấp đường dẫn đến tệp cấu hình deepspeed. 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 ví dụ NLP `examples/by_feature/deepspeed_with_config_support.py` (từ thư mục gốc của repo) với DeepSpeed Config File:

**Ví dụ tệp cấu hình DeepSpeed ZeRO Stage-2**
```bash
compute_environment: LOCAL_MACHINE
deepspeed_config:
 deepspeed_config_file: /home/ubuntu/accelerate/examples/deepspeed_config_templates/zero_stage2_config.json
 zero3_init_flag: true
distributed_type: DEEPSPEED
fsdp_config: {}
machine_rank: 0
main_process_ip: null
main_process_port: null
main_training_function: main
mixed_precision: fp16
num_machines: 1
num_processes: 2
use_cpu: false
```

với nội dung của `zero_stage2_config.json` là:
```json
{
    "fp16": {
        "enabled": true,
        "loss_scale": 0,
        "loss_scale_window": 1000,
        "initial_scale_power": 16,
        "hysteresis": 2,
        "min_loss_scale": 1
    },
    "optimizer": {
        "type": "AdamW",
        "params": {
            "lr": "auto",
            "weight_decay": "auto",
            "torch_adam": true,
            "adam_w_mode": true
        }
    },
    "scheduler": {
        "type": "WarmupDecayLR",
        "params": {
            "warmup_min_lr": "auto",
            "warmup_max_lr": "auto",
            "warmup_num_steps": "auto",
            "total_num_steps": "auto"
        }
    },
    "zero_optimization": {
        "stage": 2,
        "allgather_partitions": true,
        "allgather_bucket_size": 2e8,
        "overlap_comm": true,
        "reduce_scatter": true,
        "reduce_bucket_size": "auto",
        "contiguous_gradients": true
    },
    "gradient_accumulation_steps": 1,
    "gradient_clipping": "auto",
    "steps_per_print": 2000,
    "train_batch_size": "auto",
    "train_micro_batch_size_per_gpu": "auto",
    "wall_clock_breakdown": false
}
```

```bash
accelerate launch examples/by_feature/deepspeed_with_config_support.py \
--config_name "gpt2-large" \
--tokenizer_name "gpt2-large" \
--dataset_name "wikitext" \
--dataset_config_name "wikitext-2-raw-v1" \
--block_size 128 \
--output_dir "./clm/clm_deepspeed_stage2_accelerate" \
--learning_rate 5e-4 \
--per_device_train_batch_size 24 \
--per_device_eval_batch_size 24 \
--num_train_epochs 3 \
--with_tracking \
--report_to "wandb"\
```

**Ví dụ tệp cấu hình DeepSpeed cho ZeRO Stage-3 với CPU offload**
```bash
compute_environment: LOCAL_MACHINE
deepspeed_config:
 deepspeed_config_file: /home/ubuntu/accelerate/examples/deepspeed_config_templates/zero_stage3_offload_config.json
 zero3_init_flag: true
distributed_type: DEEPSPEED
fsdp_config: {}
machine_rank: 0
main_process_ip: null
main_process_port: null
main_training_function: main
mixed_precision: fp16
num_machines: 1
num_processes: 2
use_cpu: false
```
với nội dung của `zero_stage3_offload_config.json` là:
```json
{
    "fp16": {
        "enabled": true,
        "loss_scale": 0,
        "loss_scale_window": 1000,
        "initial_scale_power": 16,
        "hysteresis": 2,
        "min_loss_scale": 1
    },
    "optimizer": {
        "type": "AdamW",
        "params": {
            "lr": "auto",
            "weight_decay": "auto"
        }
    },
    "scheduler": {
        "type": "WarmupDecayLR",
        "params": {
            "warmup_min_lr": "auto",
            "warmup_max_lr": "auto",
            "warmup_num_steps": "auto",
            "total_num_steps": "auto"
        }
    },
    "zero_optimization": {
        "stage": 3,
        "offload_optimizer": {
            "device": "cpu",
            "pin_memory": true
        },
        "offload_param": {
            "device": "cpu",
            "pin_memory": true
        },
        "overlap_comm": true,
        "contiguous_gradients": true,
        "reduce_bucket_size": "auto",
        "stage3_prefetch_bucket_size": "auto",
        "stage3_param_persistence_threshold": "auto",
        "sub_group_size": 1e9,
        "stage3_max_live_parameters": 1e9,
        "stage3_max_reuse_distance": 1e9,
        "stage3_gather_16bit_weights_on_model_save": "auto"
    },
    "gradient_accumulation_steps": 1,
    "gradient_clipping": "auto",
    "steps_per_print": 2000,
    "train_batch_size": "auto",
    "train_micro_batch_size_per_gpu": "auto",
    "wall_clock_breakdown": false
}
```

```bash
accelerate launch examples/by_feature/deepspeed_with_config_support.py \
--config_name "gpt2-large" \
--tokenizer_name "gpt2-large" \
--dataset_name "wikitext" \
--dataset_config_name "wikitext-2-raw-v1" \
--block_size 128 \
--output_dir "./clm/clm_deepspeed_stage3_offload_accelerate" \
--learning_rate 5e-4 \
--per_device_train_batch_size 32 \
--per_device_eval_batch_size 32 \
--num_train_epochs 3 \
--with_tracking \
--report_to "wandb"\
```

**Ví dụ cấu hình ZeRO++** Bạn có thể sử dụng các tính năng của ZeRO++ bằng cách sử dụng các tham số cấu hình phù hợp. Lưu ý rằng ZeRO++ là một phần mở rộng của ZeRO Stage 3. Dưới đây là cách có thể chỉnh sửa tệp cấu hình, từ [hướng dẫn ZeRO++ của DeepSpeed](https://www.deepspeed.ai/tutorials/zeropp/):

```json
{
    "zero_optimization": {
        "stage": 3,
        "reduce_bucket_size": "auto",

        "zero_quantized_weights": true,
        "zero_hpz_partition_size": 8,
        "zero_quantized_gradients": true,

        "contiguous_gradients": true,
        "overlap_comm": true
    }
}
```

Đối với phân vùng phân cấp, kích thước phân vùng `zero_hpz_partition_size` nên được đặt bằng số lượng GPU trên mỗi nút. (Ví dụ, tệp cấu hình ở trên giả định 8 GPU trên mỗi nút)

**Các thay đổi quan trọng về mã khi sử dụng tệp cấu hình DeepSpeed**

1. DeepSpeed Optimizers and Schedulers. Để biết thêm thông tin về các thành phần này,
xem tài liệu [DeepSpeed Optimizers](https://deepspeed.readthedocs.io/en/latest/optimizers.html) và [DeepSpeed Schedulers](https://deepspeed.readthedocs.io/en/latest/schedulers.html). Chúng ta sẽ xem xét những thay đổi cần thiết trong mã khi sử dụng chúng.

   a. DS Optim + DS Scheduler: Trường hợp cả hai khóa `optimizer` và `scheduler` đều có mặt trong tệp cấu hình DeepSpeed. Trong tình huống này, chúng sẽ được sử dụng và người dùng phải dùng `accelerate.utils.DummyOptim` và `accelerate.utils.DummyScheduler` để thay thế các optimizer và scheduler PyTorch/Custom trong mã của họ. Dưới đây là đoạn trích từ `examples/by_feature/deepspeed_with_config_support.py` minh họa điều này:
   ```python
    # Creates Dummy Optimizer if `optimizer` was specified in the config file else creates Adam Optimizer
    optimizer_cls = (
        torch.optim.AdamW
        if accelerator.state.deepspeed_plugin is None
        or "optimizer" not in accelerator.state.deepspeed_plugin.deepspeed_config
        else DummyOptim
    )
    optimizer = optimizer_cls(optimizer_grouped_parameters, lr=args.learning_rate)

    # Creates Dummy Scheduler if `scheduler` was specified in the config file else creates `args.lr_scheduler_type` Scheduler
    if (
        accelerator.state.deepspeed_plugin is None
        or "scheduler" not in accelerator.state.deepspeed_plugin.deepspeed_config
    ):
        lr_scheduler = get_scheduler(
            name=args.lr_scheduler_type,
            optimizer=optimizer,
            num_warmup_steps=args.num_warmup_steps,
            num_training_steps=args.max_train_steps,
        )
    else:
        lr_scheduler = DummyScheduler(
            optimizer, total_num_steps=args.max_train_steps, warmup_num_steps=args.num_warmup_steps
        )
   ```
   b. Optimizer tùy chỉnh + Scheduler tùy chỉnh: Trường hợp cả hai khóa `optimizer` và `scheduler` đều không có trong tệp cấu hình DeepSpeed. Trong tình huống này, người dùng không cần thay đổi mã nào và đây là trường hợp khi sử dụng tích hợp thông qua DeepSpeed Plugin. Trong ví dụ trên, chúng ta có thể thấy rằng mã không thay đổi nếu các khóa `optimizer` và `scheduler` không có trong tệp cấu hình DeepSpeed.

   c. Custom Optim + DS Scheduler: Trường hợp chỉ có khóa `scheduler` trong tệp cấu hình DeepSpeed. Trong tình huống này, người dùng phải sử dụng `accelerate.utils.DummyScheduler` để thay thế scheduler PyTorch/Custom trong mã của họ.

   d. DS Optim + Custom Scheduler: Trường hợp chỉ có khóa `optimizer` trong tệp cấu hình DeepSpeed. Điều này sẽ gây ra lỗi vì bạn chỉ có thể sử dụng DS Scheduler khi đang dùng DS Optim.

2. Chú ý các giá trị `auto` trong các tệp cấu hình DeepSpeed ở ví dụ trên. Chúng được xử lý tự động bởi phương thức `prepare`
dựa trên model, dataloaders, dummy optimizer và dummy schedulers được cung cấp cho phương thức `prepare`. Chỉ các trường `auto` được chỉ định trong các ví dụ ở trên mới được xử lý bởi phương thức `prepare`, còn lại người dùng phải chỉ định rõ ràng.

Các giá trị `auto` được tính như sau:

- `reduce_bucket_size`: `hidden_size * hidden_size`
- `stage3_prefetch_bucket_size`: `int(0.9 * hidden_size * hidden_size)`
- `stage3_param_persistence_threshold`: `10 * hidden_size`

Để tính năng `auto` hoạt động cho 3 mục cấu hình này - Accelerate sẽ sử dụng `model.config.hidden_size` hoặc `max(model.config.hidden_sizes)` làm `hidden_size`. Nếu cả hai đều không khả dụng, quá trình khởi động sẽ thất bại và bạn sẽ phải thiết lập thủ công 3 mục cấu hình này. Hãy nhớ rằng 2 mục cấu hình đầu tiên là các bộ đệm giao tiếp - chúng càng lớn thì giao tiếp càng hiệu quả, nhưng cũng càng tiêu tốn nhiều bộ nhớ GPU hơn, do đó đây là một sự đánh đổi hiệu năng có thể điều chỉnh.

**Các lưu ý khi sử dụng tệp cấu hình DeepSpeed**

Dưới đây là một kịch bản mẫu sử dụng `deepspeed_config_file` trong các kịch bản khác nhau.

Mã `test.py`:

```python
from accelerate import Accelerator
from accelerate.state import AcceleratorState

def main():
    accelerator = Accelerator()
    accelerator.print(f"{AcceleratorState()}")

if __name__ == "__main__":
    main()
```

**Kịch bản 1**: Tệp cấu hình accelerate bị can thiệp thủ công, chứa `deepspeed_config_file` cùng với các mục khác.

1. Nội dung của cấu hình `accelerate`:

```yaml
command_file: null
commands: null
compute_environment: LOCAL_MACHINE
deepspeed_config:
  gradient_accumulation_steps: 1
  gradient_clipping: 1.0
  offload_optimizer_device: 'cpu'
  offload_param_device: 'cpu'
  zero3_init_flag: true
  zero3_save_16bit_model: true
  zero_stage: 3
  deepspeed_config_file: 'ds_config.json'
distributed_type: DEEPSPEED
downcast_bf16: 'no'
dynamo_backend: 'NO'
fsdp_config: {}
gpu_ids: null
machine_rank: 0
main_process_ip: null
main_process_port: null
main_training_function: main
megatron_lm_config: {}
num_machines: 1
num_processes: 2
rdzv_backend: static
same_network: true
tpu_name: null
tpu_zone: null
use_cpu: false
```

2. `ds_config.json`:

```json
{
    "bf16": {
        "enabled": true
    },
    "zero_optimization": {
        "stage": 3,
        "stage3_gather_16bit_weights_on_model_save": false,
        "offload_optimizer": {
            "device": "none"
        },
        "offload_param": {
            "device": "none"
        }
    },
    "gradient_clipping": 1.0,
    "train_batch_size": "auto",
    "train_micro_batch_size_per_gpu": "auto",
    "gradient_accumulation_steps": 10,
    "steps_per_print": 2000000
}
```

3. Đầu ra của `accelerate launch test.py`:

```bash
ValueError: When using `deepspeed_config_file`, the following accelerate config variables will be ignored:
['gradient_accumulation_steps', 'gradient_clipping', 'zero_stage', 'offload_optimizer_device', 'offload_param_device',
'zero3_save_16bit_model', 'mixed_precision'].
Please specify them appropriately in the DeepSpeed config file.
If you are using an accelerate config file, remove other config variables mentioned in the above specified list.
The easiest method is to create a new config following the questionnaire via `accelerate config`.
It will only ask for the necessary config variables when using `deepspeed_config_file`.
```

**Kịch bản 2**: Sử dụng giải pháp của lỗi để tạo cấu hình accelerate mới và kiểm tra rằng không còn lỗi mơ hồ nào được ném ra.

1. Chạy `accelerate config`:

```bash
$ accelerate config
-------------------------------------------------------------------------------------------------------------------------------
In which compute environment are you running?
This machine
-------------------------------------------------------------------------------------------------------------------------------
Which type of machine are you using?
multi-GPU
How many different machines will you use (use more than 1 for multi-node training)? [1]:
Do you wish to optimize your script with torch dynamo?[yes/NO]:
Do you want to use DeepSpeed? [yes/NO]: yes
Do you want to specify a json file to a DeepSpeed config? [yes/NO]: yes
Please enter the path to the json DeepSpeed config file: ds_config.json
Do you want to enable `deepspeed.zero.Init` when using ZeRO Stage-3 for constructing massive models? [yes/NO]: yes
How many GPU(s) should be used for distributed training? [1]:4
accelerate configuration saved at ds_config_sample.yaml
```

2. Nội dung của cấu hình `accelerate`:

```yaml
compute_environment: LOCAL_MACHINE
deepspeed_config:
  deepspeed_config_file: ds_config.json
  zero3_init_flag: true
distributed_type: DEEPSPEED
downcast_bf16: 'no'
dynamo_backend: 'NO'
fsdp_config: {}
machine_rank: 0
main_training_function: main
megatron_lm_config: {}
num_machines: 1
num_processes: 4
rdzv_backend: static
same_network: true
use_cpu: false
```

3. Đầu ra của `accelerate launch test.py`:

```bash
Distributed environment: DEEPSPEED  Backend: nccl
Num processes: 4
Process index: 0
Local process index: 0
Device: cuda:0
Mixed precision type: bf16
ds_config: {'bf16': {'enabled': True}, 'zero_optimization': {'stage': 3, 'stage3_gather_16bit_weights_on_model_save': False, 'offload_optimizer': {'device': 'none'}, 'offload_param': {'device': 'none'}}, 'gradient_clipping': 1.0, 'train_batch_size': 'auto', 'train_micro_batch_size_per_gpu': 'auto', 'gradient_accumulation_steps': 10, 'steps_per_print': inf, 'fp16': {'enabled': False}}
```

**Kịch bản 3**: Đặt các đối số của lệnh `accelerate launch` liên quan đến DeepSpeed thành `"auto"` trong tệp cấu hình DeepSpeed và kiểm tra xem mọi thứ có hoạt động như mong đợi hay không.

1. `ds_config.json` mới với `"auto"` cho các đối số lệnh `accelerate launch` DeepSpeed:

```json
{
    "bf16": {
        "enabled": "auto"
    },
    "zero_optimization": {
        "stage": "auto",
        "stage3_gather_16bit_weights_on_model_save": "auto",
        "offload_optimizer": {
            "device": "auto"
        },
        "offload_param": {
            "device": "auto"
        }
    },
    "gradient_clipping": "auto",
    "train_batch_size": "auto",
    "train_micro_batch_size_per_gpu": "auto",
    "gradient_accumulation_steps": "auto",
    "steps_per_print": 2000000
}
```

2. Đầu ra của `accelerate launch --mixed_precision="fp16" --zero_stage=3 --gradient_accumulation_steps=5 --gradient_clipping=1.0 --offload_param_device="cpu" --offload_optimizer_device="nvme" --zero3_save_16bit_model="true" test.py`:

```bash
Distributed environment: DEEPSPEED  Backend: nccl
Num processes: 4
Process index: 0
Local process index: 0
Device: cuda:0
Mixed precision type: fp16
ds_config: {'bf16': {'enabled': False}, 'zero_optimization': {'stage': 3, 'stage3_gather_16bit_weights_on_model_save': True, 'offload_optimizer': {'device': 'nvme'}, 'offload_param': {'device': 'cpu'}}, 'gradient_clipping': 1.0, 'train_batch_size': 'auto', 'train_micro_batch_size_per_gpu': 'auto', 'gradient_accumulation_steps': 5, 'steps_per_print': inf, 'fp16': {'enabled': True, 'auto_cast': True}}
```

**Lưu ý**:
1. Các giá trị `"auto"` còn lại được xử lý trong lời gọi `accelerator.prepare()` như đã giải thích ở điểm 2 của
`Important code changes when using DeepSpeed Config File`.
2. Chỉ khi `gradient_accumulation_steps` là `auto`, giá trị được truyền khi tạo đối tượng `Accelerator` thông qua `Accelerator(gradient_accumulation_steps=k)` sẽ được sử dụng. Khi sử dụng DeepSpeed Plugin, giá trị từ plugin đó sẽ được dùng và ghi đè lên giá trị được truyền khi tạo đối tượng Accelerator.

## Lưu và tải

1. Việc lưu và tải mô hình không thay đổi đối với ZeRO Stage-1 và Stage-2.

2. dưới ZeRO Stage-3, `state_dict` chỉ chứa các placeholder vì trọng số mô hình được phân vùng trên nhiều GPU.
ZeRO Stage-3 có 2 tùy chọn:

   a. Lưu toàn bộ trọng số mô hình 16bit để tải trực tiếp sau đó bằng `model.load_state_dict(torch.load(pytorch_model.bin))`. Để làm điều này, hãy đặt `zero_optimization.stage3_gather_16bit_weights_on_model_save` thành True trong tệp cấu hình DeepSpeed hoặc đặt `zero3_save_16bit_model` thành True trong DeepSpeed Plugin. **Lưu ý rằng tùy chọn này yêu cầu gộp các trọng số trên một GPU, có thể gây chậm và tốn bộ nhớ, vì vậy chỉ sử dụng tính năng này khi cần thiết.** Dưới đây là đoạn mã từ `examples/by_feature/deepspeed_with_config_support.py` minh họa điều này:
   ```python
   unwrapped_model = accelerator.unwrap_model(model)

   # New Code #
   # Saves the whole/unpartitioned fp16 model when in ZeRO Stage-3 to the output directory if
   # `stage3_gather_16bit_weights_on_model_save` is True in DeepSpeed Config file or
   # `zero3_save_16bit_model` is True in DeepSpeed Plugin.
   # For Zero Stages 1 and 2, models are saved as usual in the output directory.
   # The model name saved is `pytorch_model.bin`
   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),
   )
   ```

   b. Để lấy trọng số 32bit, trước tiên hãy lưu mô hình bằng `model.save_checkpoint()`. Dưới đây là đoạn mã từ `examples/by_feature/deepspeed_with_config_support.py` minh họa điều này:
   ```python
   success = model.save_checkpoint(PATH, ckpt_id, checkpoint_state_dict)
   status_msg = f"checkpointing: PATH={PATH}, ckpt_id={ckpt_id}"
   if success:
       logging.info(f"Success {status_msg}")
   else:
       logging.warning(f"Failure {status_msg}")
   ```
   Điều này sẽ tạo ra các phân vùng mô hình và optimizer ZeRO cùng với script `zero_to_fp32.py` trong thư mục checkpoint. Bạn có thể sử dụng script này để thực hiện gộp offline. Nó không yêu cầu các tệp cấu hình hay GPU. Dưới đây là một ví dụ về cách sử dụng:
   ```bash
   $ cd /path/to/checkpoint_dir
   $ ./zero_to_fp32.py . pytorch_model.bin
   Processing zero checkpoint at global_step1
   Detected checkpoint of type zero stage 3, world_size: 2
   Saving fp32 state dict to pytorch_model.bin (total_numel=60506624)
   ```
   Để lấy mô hình 32bit để lưu/truy vấn suy luận, bạn có thể thực hiện:
   ```python
   from deepspeed.utils.zero_to_fp32 import load_state_dict_from_zero_checkpoint

   unwrapped_model = accelerator.unwrap_model(model)
   fp32_model = load_state_dict_from_zero_checkpoint(unwrapped_model, checkpoint_dir)
   ```
   Nếu bạn chỉ quan tâm đến `state_dict`, bạn có thể thực hiện các bước sau:
   ```python
   from deepspeed.utils.zero_to_fp32 import get_fp32_state_dict_from_zero_checkpoint

   state_dict = get_fp32_state_dict_from_zero_checkpoint(checkpoint_dir)
   ```
   Lưu ý rằng tất cả các hàm này đều yêu cầu bộ nhớ (RAM tổng quát) gấp ~2 lần kích thước của checkpoint cuối cùng.

## ZeRO Inference
DeepSpeed ZeRO Inference hỗ trợ ZeRO stage 3 với ZeRO-Infinity. Nó sử dụng cùng giao thức ZeRO như khi huấn luyện, nhưng không dùng optimizer và lr scheduler, và chỉ stage 3 là liên quan. Với tích hợp accelerate, bạn chỉ cần chuẩn bị model và dataloader như minh họa bên dưới:

```python
model, eval_dataloader = accelerator.prepare(model, eval_dataloader)
```

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

1. Tích hợp hiện tại không hỗ trợ Pipeline Parallelism của DeepSpeed.
2. Tích hợp hiện tại không hỗ trợ `mpu`, làm hạn chế tính song song hóa tensor được hỗ trợ trong Megatron-LM.
3. Tích hợp hiện tại không hỗ trợ nhiều mô hình.

## DeepSpeed đa nút
DeepSpeed hỗ trợ suy luận và huấn luyện đa nút thông qua nhiều trình khởi chạy khác nhau. Bạn có thể chỉ định một trình khởi chạy khác bằng cách đặt cấu hình `deepspeed_multinode_launcher` trong CLI hoặc trong tệp cấu hình DeepSpeed.

Hiện tại, accelerate hỗ trợ truyền cấu hình cho các trình khởi chạy đa nút DeepSpeed sau: `pdsh` (mặc định), `standard`, `openmpi`, `mvapich`, `mpich`, `slurm`, `nossh` (yêu cầu DeepSpeed >= 0.14.5).

Vui lòng đọc [tài liệu DeepSpeed](https://www.deepspeed.ai/getting-started/#resource-configuration-multi-node) để biết thêm thông tin về các trình khởi chạy khác nhau. Mặc định, DeepSpeed sẽ cố gắng sử dụng SSH không mật khẩu từ nút máy chính đến các nút khác để thực hiện lệnh khởi chạy. Trong cấu hình này, lệnh accelerate launch chỉ cần được chạy trên nút chính. Nếu sử dụng trình khởi chạy `nossh`, bạn sẽ cần chạy lệnh accelerate launch trên mọi nút bằng cách sao chép cấu hình.

## Tài nguyên DeepSpeed

Tài liệu về các thành phần bên trong liên quan đến deepspeed có thể được tìm thấy [tại đây](../package_reference/deepspeed).

- [github của dự án](https://github.com/deepspeedai/DeepSpeed)
- [Tài liệu sử dụng](https://www.deepspeed.ai/getting-started/)
- [Tài liệu API](https://deepspeed.readthedocs.io/en/latest/index.html)
- [Bài viết trên blog](https://www.microsoft.com/en-us/research/search/?q=deepspeed)

Các bài báo:

- [ZeRO: Tối ưu hóa bộ nhớ hướng tới huấn luyện các mô hình có hàng nghìn tỷ tham số](https://huggingface.co/papers/1910.02054)
- [ZeRO-Offload: Dân chủ hóa việc huấn luyện mô hình quy mô tỷ tham số](https://huggingface.co/papers/2101.06840)
- [ZeRO-Infinity: Phá vỡ rào cản bộ nhớ GPU cho học sâu quy mô cực lớn](https://huggingface.co/papers/2104.07857)
- [ZeRO++: Truyền thông tập thể cực kỳ hiệu quả cho việc huấn luyện mô hình khổng lồ](https://huggingface.co/papers/2306.10209)

Cuối cùng, xin hãy nhớ rằng `Accelerate` chỉ tích hợp DeepSpeed, do đó nếu bạn gặp bất kỳ vấn đề hoặc câu hỏi nào liên quan đến việc sử dụng DeepSpeed, vui lòng tạo một issue trên [DeepSpeed GitHub](https://github.com/deepspeedai/DeepSpeed/issues).

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

