Đào tạo PyTorch với nhiều GPU: Hướng dẫn đầy đủ

PyTorch đã trở thành một trong những framework học sâu phổ biến nhất, được các nhà nghiên cứu và thực hành yêu thích nhờ vào đồ thị tính toán động và tính dễ sử dụng của nó. Khi các mô hình học sâu ngày càng lớn và phức tạp hơn, việc đào tạo chúng một cách hiệu quả đòi hỏi phải khai thác sức mạnh của nhiều GPU. Trong bài viết này, chúng ta sẽ đi sâu vào thế giới đào tạo đa GPU với PyTorch, khám phá các kỹ thuật như DataParallel và DistributedDataParallel để tăng tốc đáng kể quy trình đào tạo của bạn.

Nhu cầu về tốc độ: Tại sao đa GPU lại quan trọng

Việc đào tạo các mô hình học sâu tiên tiến thường mất nhiều ngày hoặc thậm chí nhiều tuần trên một GPU đơn. Tốc độ lặp lại chậm này có thể cản trở tiến bộ nghiên cứu và trì hoãn việc đưa các mô hình vào sản xuất. Bằng cách phân phối quá trình đào tạo trên nhiều GPU, chúng ta có thể giảm đáng kể thời gian cần thiết để đào tạo những mô hình lớn này.

Có hai phương pháp chính để song song hóa quá trình đào tạo trong PyTorch:

Song song dữ liệu: Mô hình được nhân bản trên mỗi GPU, và một phần dữ liệu được xử lý trên mỗi bản sao. Các gradient được tích lũy trên các GPU sau mỗi lần lặp.
Song song mô hình: Các phần khác nhau của mô hình được chia trên các GPU, với mỗi GPU chịu trách nhiệm một phần của quá trình truyền xuôi và truyền ngược. Phương pháp này ít phổ biến hơn và phức tạp hơn trong việc triển khai.

Trong bài viết này, chúng tôi sẽ tập trung vào song song dữ liệu, vì đây là phương pháp được sử dụng rộng rãi nhất và được PyTorch hỗ trợ tốt.

Bắt đầu với DataParallel

Mô-đun DataParallel của PyTorch cung cấp một cách đơn giản để khai thác nhiều GPU với những thay đổi mã tối thiểu. Nó tự động chia dữ liệu đầu vào trên các GPU có sẵn và tích lũy các gradient trong quá trình truyền ngược.

Dưới đây là một ví dụ cơ bản về việc sử dụng DataParallel để bọc một mô hình:

import torch
import torch.nn as nn
 
# Định nghĩa mô hình của bạn
model = nn.Sequential(
    nn.Li.
near(10, 20),
    nn.ReLU(),
    nn.Linear(20, 5)
)
 
# Di chuyển mô hình đến GPU
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)
 
# Bọc mô hình với DataParallel
parallel_model = nn.DataParallel(model)

Bây giờ, khi bạn truyền một đầu vào vào parallel_model, nó sẽ tự động được chia nhỏ trên các GPU có sẵn. Mô-đun xử lý việc thu thập các đầu ra và gradient, khiến nó trở nên minh bạch với phần còn lại của mã huấn luyện của bạn.

inputs = torch.randn(100, 10).to(device)
outputs = parallel_model(inputs)

Ưu điểm và Hạn chế

DataParallel dễ sử dụng và có thể cung cấp tốc độ tăng tốt khi bạn có vài GPU trên một máy đơn. Tuy nhiên, nó có một số hạn chế:

Nó chỉ hỗ trợ huấn luyện đa GPU trong một quy trình duy nhất, vì vậy nó không mở rộng tốt đến các cụm lớn hơn.
Mô hình phải vừa vặn hoàn toàn trong bộ nhớ của mỗi GPU, giới hạn kích thước mô hình tối đa.
Có thể có nhiều chi phí đáng kể từ việc sao chép dữ liệu giữa các GPU, đặc biệt là với nhiều thao tác nhỏ.

Mặc dù có những hạn chế này, DataParallel vẫn là một lựa chọn tốt cho nhiều trường hợp sử dụng phổ biến và là một cách tuyệt vời để bắt đầu với huấn luyện đa GPU trong PyTorch.

Mở rộng với DistributedDataParallel

Đối với các mô hình và cụm lớn hơn, mô-đun DistributedDataParallel (DDP) của PyTorch cung cấp một cách tiếp cận linh hoạt và hiệu quả hơn cho huấn luyện đa GPU. DDP sử dụng nhiều quy trình, mỗi quy trình có GPU riêng của nó, để song song hóa quá trình huấn luyện.

Các tính năng chính của DDP bao gồm:

Hỗ trợ Đa Quy Trình: DDP có thể mở rộng lên hàng trăm GPU trên nhiều nút, cho phép huấn luyện các mô hình rất lớn.
Giao tiếp Hiệu Quả: Nó sử dụng backend NCCL để giao tiếp GPU-to-GPU nhanh chóng, giảm thiểu chi phí.
Đồng bộ hóa Gradient: DDP tự động đồng bộ hóa gradient giữa các quy trình trong quá trình lan truyền ngược.

Dưới đây là một ví dụ về cách thiết lập DDP trong tệp huấn luyện của bạn:

import torch
import torch.distributed as dist
import torch.multiprocessing as m.

def train(rank, world_size):

Khởi tạo nhóm quy trình

dist.init_process_group(backend='nccl', rank=rank, world_size=world_size)

Định nghĩa mô hình của bạn

model = nn.Sequential(...)

Bọc mô hình với DDP

model = nn.parallel.DistributedDataParallel(model, device_ids=[rank])

Vòng lặp huấn luyện của bạn ở đây

...

def main(): world_size = torch.cuda.device_count() mp.spawn(train, args=(world_size,), nprocs=world_size, join=True)

if name == 'main': main()


Trong ví dụ này, chúng tôi sử dụng `torch.multiprocessing` để tạo một quy trình cho mỗi GPU. Mỗi quy trình khởi tạo nhóm quy trình riêng của nó bằng cách sử dụng `dist.init_process_group()`, chỉ định cấp bậc và tổng kích thước thế giới của nó.

Sau đó, mô hình được bọc với DDP, truyền danh sách các ID thiết bị để sử dụng. Bên trong vòng lặp huấn luyện, mô hình có thể được sử dụng như bình thường, với DDP xử lý việc phân phối dữ liệu và gradient giữa các quy trình.

### So sánh hiệu suất

Để minh họa lợi ích về hiệu suất của huấn luyện đa GPU, hãy so sánh thời gian huấn luyện cho một mô hình đơn giản trên một GPU duy nhất, với `DataParallel` và với DDP:

| Cài đặt        | Thời gian huấn luyện (giây) | Tăng tốc |
|----------------|-------------------|---------|
| GPU đơn        | 100               | 1x      |
| DataParallel   | 55                | 1.8x    |
| DDP (4 GPU)    | 30                | 3.3x    |

Như chúng ta có thể thấy, cả `DataParallel` và DDP đều cung cấp tăng tốc đáng kể so với huấn luyện trên một GPU duy nhất. DDP có thể mở rộng tốt hơn với nhiều GPU hơn và có thể đạt được tăng tốc gần như tuyến tính trong nhiều trường hợp.

## Các thực hành tốt nhất cho huấn luyện đa GPU

Để có được lợi ích tối đa từ huấn luyện đa GPU trong PyTorch, hãy lưu ý các thực hành tốt nhất sau:

- **Chọn chiến lược song song hóa phù hợp**: Sử dụng `DataParallel` cho các trường hợp đơn giản với một vài GPU, và chuyển sang DDP cho các mô hình lớn hơn và cụm máy.
- **Điều chỉnh kích thước batch**: Kích thước batch lớn hơn có thể cải thiện việc sử dụng GPU và giảm chi phí giao tiếp. Thử nghiệm với các kích thước batch khác nhau.
Tìm điểm ngọt vàng cho mô hình và phần cứng của bạn.
- **Sử dụng Chính xác Hỗn hợp**: Mô-đun `torch.cuda.amp` của PyTorch cho phép đào tạo chính xác hỗn hợp, có thể giảm đáng kể mức sử dụng bộ nhớ và cải thiện hiệu suất trên GPU hiện đại.
- **Xử lý Trạng thái Ngẫu nhiên**: Đảm bảo đặt các hạt giống ngẫu nhiên một cách rõ ràng để có thể tái tạo, và sử dụng `torch.manual_seed()` để đảm bảo mỗi quá trình có một trạng thái ngẫu nhiên duy nhất.
- **Phân tích và Tối ưu hóa**: Sử dụng các công cụ phân tích như PyTorch Profiler hoặc NVIDIA Nsight để xác định các điểm nghẽn về hiệu suất và tối ưu hóa mã của bạn.

## Ví dụ Thực tế

Đào tạo đa GPU đã được sử dụng để đạt được kết quả tiên tiến nhất trong một loạt các lĩnh vực, từ thị giác máy tính đến xử lý ngôn ngữ tự nhiên. Dưới đây là một số ví dụ đáng chú ý:

- **BigGAN**: Các nhà nghiên cứu tại DeepMind đã sử dụng PyTorch DDP để đào tạo mô hình BigGAN trên 128 GPU, tạo ra các hình ảnh chất lượng cao với mức độ chi tiết và đa dạng chưa từng có.
- **OpenAI GPT-3**: Mô hình ngôn ngữ GPT-3, với 175 tỷ tham số, đã được đào tạo trên một cụm 10.000 GPU bằng cách kết hợp song song mô hình và dữ liệu.
- **AlphaFold 2**: Mô hình gấp protein AlphaFold 2 của DeepMind đã được đào tạo trên 128 lõi TPUv3, thể hiện khả năng mở rộng của đào tạo đa thiết bị vượt xa chỉ là GPU.

Những ví dụ này cho thấy sức mạnh của đào tạo đa GPU để đẩy mạnh ranh giới của những gì có thể đạt được với học sâu.

## Kết luận

Trong bài viết này, chúng tôi đã khám phá thế giới của đào tạo đa GPU với PyTorch, từ cơ bản của `DataParallel` đến các kỹ thuật nâng cao của `DistributedDataParallel`. Bằng cách khai thác sức mạnh của nhiều GPU, bạn có thể tăng tốc đáng kể quy trình đào tạo của mình và giải quyết các mô hình lớn hơn, phức tạp hơn.

Hãy nhớ chọn chiến lược song song phù hợp với trường hợp sử dụng của bạn, điều chỉnh siêu tham số của bạn và tuân theo các thực hành tốt nhất để đạt hiệu suất tối ưu. Với cách tiếp cận đúng, đào tạo đa GPU có thể là một trò chơi thay đổi trò chơi cho các dự án học sâu của bạn.

Để tìm hiểu thêm về đào tạo đa GPU.
Để tìm hiểu thêm về đào tạo song song trong PyTorch, hãy xem các tài nguyên bổ sung này:

- [Tài liệu PyTorch DataParallel](https://pytorch.org/docs/stable/generated/torch.nn.DataParallel.html)
- [Tài liệu PyTorch DistributedDataParallel](https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html)
- [Tổng quan về Phân phối PyTorch](https://pytorch.org/tutorials/beginner/dist_overview.html)

Chúc may mắn trong quá trình đào tạo!

Cpu Vs Gpu in Ai DCNN (Deep Convolutional Neural Networks) là gì? Giải thích!