DDP

DistributedDataParallel (DDP) duy trì một bản sao đầy đủ của mô hình trên mỗi GPU. Mỗi GPU xử lý một phần dữ liệu không chồng chéo với một bước truyền thẳng và một bước truyền ngược. Trước bước tối ưu hóa, một all-reduce sẽ trung bình hóa gradient trên tất cả các GPU để đảm bảo mọi bản sao mô hình đều giống hệt nhau. Hãy sử dụng DDP khi mô hình của bạn vừa trên một GPU duy nhất.

                         ┌─────────────────┐
                         │  training data  │
                         └────────┬────────┘
               ┌──────────────────┼──────────────────┐
               │ shard 0          │ shard 1          │ shard 2
               ▼                  ▼                  ▼
        ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
        │   model     │    │   model     │    │   model     │
        │  (copy 0)   │    │  (copy 1)   │    │  (copy 2)   │
        │   GPU 0     │    │   GPU 1     │    │   GPU 2     │
        └──────┬──────┘    └──────┬──────┘    └──────┬──────┘
               │ grads            │ grads            │ grads
               └──────────────────┼──────────────────┘
                               all-reduce
                          (average gradients)
               ┌──────────────────┼──────────────────┐
               ▼                  ▼                  ▼
        ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
        │  optimizer  │    │  optimizer  │    │  optimizer  │
        │    step     │    │    step     │    │    step     │
        └─────────────┘    └─────────────┘    └─────────────┘
          (identical)        (identical)        (identical)

DDD được kích hoạt tự động khi bạn khởi chạy bằng trình khởi chạy đa tiến trình như Accelerate.

# 4 GPUs on one machine
accelerate launch --num_processes 4 train.py

Cấu hình DDP

Truyền các TrainingArguments này để kiểm soát hành vi của DDP.

• gradient_accumulation_steps() xác định thời điểm thực hiện all-reduce. Trainer bỏ qua all-reduce ở các bước tích lũy trung gian và chỉ chạy nó ở micro-batch cuối cùng. Ví dụ, với gradient_accumulation_steps=4, all-reduce sẽ chạy mỗi 4 lần truyền ngược.
• ~TrainingArguments.ddp_find_unused_parameters duyệt qua đồ thị autograd ở cuối bước forward đối với các tham số sẽ không nhận gradient và đánh dấu chúng là sẵn sàng để chúng không chặn all-reduce. Không sử dụng cùng với ~TrainingArguments.gradient_checkpointing vì gradient checkpointing loại bỏ các kích hoạt trung gian và tính lại chúng theo thời gian thực.
• ~TrainingArguments.ddp_bucket_cap_mb là kích thước bucket để gom các gradient thành một lần all-reduce duy nhất trong quá trình backward. Bucket lớn hơn đồng nghĩa với ít lệnh gọi all-reduce hơn và ít overhead khởi tạo hơn.
• ~TrainingArguments.ddp_broadcast_buffers đồng bộ hóa các buffer của mô hình (chẳng hạn như thống kê chạy của BatchNorm) từ rank 0 đến tất cả các rank khác vào đầu mỗi bước truyền thẳng. Tắt tính năng này nếu mô hình của bạn chỉ sử dụng LayerNorm. Không sử dụng cùng với ~TrainingArguments.gradient_checkpointing.
• ~TrainingArguments.ddp_backend thiết lập backend truyền thông. Sử dụng "nccl" cho GPU NVIDIA (mặc định và nhanh nhất), "gloo" cho huấn luyện hoặc gỡ lỗi trên CPU, và "xccl", "hccl" hoặc "cncl" cho phần cứng khác.
• ddp_timeout() đặt giới hạn thời gian cho tất cả các tiến trình và thao tác (all-reduce, broadcast) để hoàn thành. Nếu một tiến trình bị treo, chẳng hạn như khi tải một mô hình lớn chậm, thời gian chờ sẽ gây ra lỗi thay vì chặn vô thời hạn.

from transformers import TrainingArguments

args = TrainingArguments(
    ...,
    gradient_accumulation_steps=4,
    ddp_backend="nccl",
    ddp_find_unused_parameters=False,
    ddp_bucket_cap_mb=25,
    ddp_broadcast_buffers=True,
    ddp_timeout=1800,
)

Các bước tiếp theo

• Xem FSDP để huấn luyện các mô hình quá lớn để chạy trên một GPU duy nhất.
• Xem DeepSpeed để tìm hiểu về tối ưu hóa ZeRO và offloading.
• Đọc chương Data Parallelism trong The Ultra-Scale Playbook để biết thêm thông tin về cách DDP hoạt động.