GPU (Graphics Processing Unit)

Bộ xử lý đồ họa (GPU) là bộ xử lý có hàng nghìn lõi đơn giản, thực hiện cùng một phép toán trên nhiều phần dữ liệu cùng lúc. GPU được phát triển để kết xuất đồ họa 3D, tức là tính toán song song hàng triệu pixel và đỉnh; chúng trở thành phần cứng chủ đạo cho học sâu vì quá trình huấn luyện và suy luận mạng nơ-ron chủ yếu gồm các phép nhân ma trận có thể song song hóa theo cách tương tự. Nền tảng CUDA của NVIDIA, ra mắt năm 2007, giúp lập trình GPU cho tính toán đa dụng; đến năm 2012, mạng AlexNet, được huấn luyện trong năm đến sáu ngày trên hai GPU NVIDIA GTX 580, đã chiến thắng cuộc thi ImageNet với tỷ lệ lỗi top-5 là 15.3%, so với 26.2% của đối thủ xếp thứ hai. Ngày nay, PyTorch, TensorFlow và JAX chạy trên GPU NVIDIA thông qua CUDA, trên GPU AMD thông qua ROCm và trên Apple silicon thông qua Metal; các cụm gồm hàng nghìn GPU huấn luyện những model nền tảng lớn nhất.

Cách GPU tăng tốc học sâu#

CPU dành phần lớn diện tích chip cho cache và logic điều khiển, giúp một số ít lõi chạy nhanh mã có nhiều nhánh. GPU dùng phần diện tích đó cho các phép toán số học: GPU NVIDIA được chia thành các streaming multiprocessor, mỗi bộ chạy nhóm 32 luồng gọi là warp; các luồng trong nhóm thực thi cùng chỉ thị trên dữ liệu khác nhau. Trong khi một số warp chờ bộ nhớ, các warp khác tính toán, nhờ đó chip luôn hoạt động miễn là có đủ việc song song. Từ thế hệ Volta năm 2017, GPU NVIDIA còn tích hợp Tensor Core, các đơn vị nhân ma trận nhỏ chỉ trong một bước với độ chính xác thấp hơn; hiện nay hỗ trợ cả FP8 và, từ Blackwell, FP4. NVIDIA A100 đạt tối đa 19.5 TFLOPS với phép toán FP32 tiêu chuẩn và 312 TFLOPS ở BF16 trên Tensor Core; đó là lý do hầu hết quá trình huấn luyện trên GPU sử dụng độ chính xác hỗn hợp. Đoạn mã này đo thời gian thực hiện cùng phép nhân ma trận trên CPU và GPU:

import time

import torch

gpu = torch.accelerator.current_accelerator()  # cuda, mps, or xpu device on this machine
a = torch.randn(4096, 4096)
b = torch.randn(4096, 4096)

for device in (torch.device("cpu"), gpu):
    x, y = a.to(device), b.to(device)
    x @ y  # warm-up run
    torch.accelerator.synchronize()
    start = time.perf_counter()
    for _ in range(10):
        x @ y
    torch.accelerator.synchronize()  # GPU calls return immediately, so wait for them to finish
    seconds = (time.perf_counter() - start) / 10
    print(f"{device.type}: {seconds * 1000:.1f} ms per multiply, {2 * 4096**3 / seconds / 1e12:.1f} TFLOPS")

Trên máy tính xách tay Apple M5 Pro, đoạn mã in ra cpu: 80.0 ms per multiply, 1.7 TFLOPS và mps: 18.3 ms per multiply, 7.5 TFLOPS, cho thấy GPU tích hợp của máy nhanh hơn khoảng 4.4 lần ở FP32. GPU trung tâm dữ liệu nới rộng khoảng cách hơn nữa nhờ có nhiều lõi hơn và bộ nhớ băng thông cao (HBM) truyền tải vài terabyte mỗi giây, đủ để cấp dữ liệu trọng số và activation cho các lõi. Bộ nhớ GPU, thường gọi là VRAM, cũng quyết định kích thước model và batch size có thể chứa trên một thiết bị; các kỹ thuật như gradient checkpointing và huấn luyện phân tán được dùng để khắc phục giới hạn đó.

Huấn luyện và triển khai model trên GPU#

Tác vụ huấn luyện chỉ tận dụng GPU hiệu quả khi các phần còn lại của pipeline theo kịp: worker CPU phải giải mã và tăng cường ảnh đủ nhanh, batch phải đủ lớn để tận dụng các lõi, và phép toán nên chạy ở độ chính xác thấp hơn trên Tensor Core. Mức sử dụng GPU thấp thường chỉ ra một trong những vấn đề sau:

Ultralytics YOLO mặc định huấn luyện trên GPU CUDA đầu tiên khi có sẵn, chấp nhận device=[0, 1] để huấn luyện đa GPU, và với batch=-1 sẽ chạy AutoBatch, đo bộ nhớ trống của GPU rồi chọn batch size sử dụng khoảng 60% dung lượng đó. Các nhóm không có phần cứng cục bộ có thể chọn GPU đám mây trên Ultralytics Platform cho mỗi lần huấn luyện. Khi inference, model YOLO26n được export sang TensorRT xử lý ảnh 640 pixel trong 1,7 ms trên GPU NVIDIA T4, so với 38,9 ms khi dùng ONNX trên CPU. Đoạn mã này huấn luyện YOLO26 trên GPU đầu tiên bằng AutoBatch:

from ultralytics import YOLO

# Tải model phát hiện YOLO26 nhỏ nhất
model = YOLO("yolo26n.pt")

# Huấn luyện trên GPU 0 và để AutoBatch xác định kích thước batch phù hợp với bộ nhớ GPU
results = model.train(data="coco8.yaml", epochs=3, imgsz=640, device=0, batch=-1)

GPU so với CPU, TPU và NPU#

• CPU: Một số ít lõi mạnh mẽ để chạy mã đa dụng có nhiều nhánh. CPU xử lý việc tải và tiền xử lý dữ liệu trong hầu hết pipeline huấn luyện, đồng thời đảm nhiệm suy luận khi không có bộ tăng tốc.
• GPU: Hàng nghìn lõi có thể lập trình, cùng Tensor Core. GPU chạy được hầu hết model và framework, do nhiều nhà cung cấp sản xuất và có mặt trên mọi dịch vụ đám mây lớn.
• TPU: Chip chuyên dụng cho ứng dụng của Google, được xây dựng xoay quanh các đơn vị nhân ma trận lớn. TPU đánh đổi tính linh hoạt của GPU để đạt hiệu quả cao với khối lượng công việc ma trận đặc lớn và được cung cấp qua Google Cloud.
• NPU: Bộ tăng tốc mạng nơ-ron tiêu thụ ít điện năng, có trong điện thoại, máy tính xách tay và thiết bị biên; được dùng cho suy luận thay vì huấn luyện.

Ứng dụng thực tế#

• Huấn luyện model lớn: Model ngôn ngữ và thị giác có hàng tỷ tham số được huấn luyện trên các cụm gồm hàng nghìn GPU trung tâm dữ liệu, kết nối qua liên kết tốc độ cao như NVLink và InfiniBand.
• Phân tích video thời gian thực: Một GPU có thể chạy phát hiện và theo dõi đối tượng trên nhiều luồng camera cùng lúc để giám sát giao thông, phân tích bán lẻ hoặc kiểm tra nhà máy.
• Robot học và xe tự hành: Các module GPU nhúng như NVIDIA Jetson chạy model nhận thức ngay trên thiết bị; gửi dữ liệu camera đến máy chủ sẽ gây độ trễ quá lớn.
• Chẩn đoán hình ảnh y khoa: GPU xử lý khối dữ liệu CT và MRI 3D lớn để phân đoạn cơ quan và khối u trong vài giây thay vì vài phút.