ONE is preparing: 01 / INITIALIZING MODEL ROUTER. Evaluating routing across providers.
Current state
01 / INITIALIZING MODEL ROUTER.

Evaluating routing across providers.

Start learning
← Fine-tuning & Tối ưu

AI Builder

Huấn luyện hỗn hợp độ chính xác

Vietnamese onlyThe learning content is available in Vietnamese only. The surrounding interface follows your language.

Kỹ thuật kết hợp FP16 và FP32 trong huấn luyện để tăng tốc và giảm bộ nhớ mà vẫn giữ chính xác.

lesson105 minFine-tuning & Tối ưuAI Engineer

Dự đoán

Một mô hình 7B tham số train 4 ngày trên 8 GPU A100. Có cách nào giảm xuống khoảng 2 ngày mà hầu như không mất chất lượng?

Ý tưởng quen thuộc: khi xây nhà, móng chịu lực dùng vật liệu đắt nhất (FP32), tường ngăn dùng gạch nhẹ (FP16). Cả nhà nhẹ hơn mà cấu trúc chịu lực vẫn vững.

Khám phá — cùng một số, nhiều định dạng

Các định dạng lưu cùng một số thực với độ chính xác khác nhau. Sai số làm tròn là lý do mixed precision phải chọn lọc chỗ nào dùng định dạng nào.

Định dạngCấu trúc bitDải và độ chính xác
FP161 dấu, 5 mũ, 10 mantissaMin normal khoảng 6,1e-5, max 65504; mantissa chính xác nhất trong nhóm 16 bit; dải hẹp nên cần loss scaling
BF161 dấu, 8 mũ, 7 mantissaCùng dải với FP32; mantissa chỉ cho khoảng 2 chữ số thập phân; gần như không cần loss scaling
FP8 E4M31 dấu, 4 mũ, 3 mantissaMax khoảng 448; dùng cho trọng số và kích hoạt
FP8 E5M21 dấu, 5 mũ, 2 mantissaMax khoảng 57344; dùng cho gradient, đuôi phân phối dài

Loss scaling: cứu gradient khỏi underflow

Khi gradient lưu ở FP16 thuần, nhiều giá trị nhỏ bị flush về 0 (underflow). Loss scaling nhân loss với một hệ số S trước backward để đưa gradient về dải biểu diễn được, rồi chia lại trước khi cập nhật.

Gradient gốcNhân với S = 1024Kết quả trong FP16
1e-8 (dưới dải FP16)1e-5 (trong dải FP16)Được giữ lại, không bị flush về 0

Chú ý: BF16 không bao giờ underflow với các giá trị này, vì dải exponent của BF16 rộng như FP32. Nên khi huấn luyện LLM hầu như không cần loss scaling.

Khoảnh khắc aha

Không phải mọi phép tính đều cần chính xác như nhau. Nhân ma trận (forward và backward) chịu được sai số nhỏ, nên dùng FP16 hoặc BF16 để nhanh hơn 2 đến 3 lần trên Tensor Core. Nhưng cập nhật trọng số cần tích luỹ những thay đổi cực nhỏ qua hàng triệu bước, nên phải dùng FP32 để không mất từng hạt gradient. Mixed precision là chọn đúng định dạng cho đúng việc.

Thử thách

Gradient có giá trị 1e-8. Ngưỡng normal nhỏ nhất của FP16 là khoảng 6,1e-5. Điều gì xảy ra khi lưu gradient này ở FP16 không có loss scaling?
Mô hình đang huấn luyện ổn định ở FP32. Bạn bật autocast FP16 (không đổi gì khác) và sau 100 bước loss thành NaN. Bước đầu tiên nên thử là gì?

Lý thuyết

Mixed precision training (Micikevicius và cộng sự, 2018) kết hợp nhiều định dạng số thực trong cùng quá trình huấn luyện, để tận dụng tốc độ Tensor Core mà vẫn giữ ổn định. Khác với lượng tử hoá (thường cho suy luận), mixed precision dùng khi đang huấn luyện và phụ thuộc vào kiến trúc GPU.

1. Master weights FP32. Giữ một bản sao FP32 của trọng số để tích luỹ các bước cập nhật nhỏ:

Wt+1FP32=WtFP32−η⋅unscale(gtFP16)W_{t+1}^{\text{FP32}} = W_t^{\text{FP32}} - \eta \cdot \text{unscale}(g_t^{\text{FP16}})

Đầu mỗi bước cast sang FP16 để forward và backward; cuối bước unscale gradient rồi cập nhật bản FP32.

2. Loss scaling. Gradient thường nằm trong khoảng 1e-9 đến 1e-3, còn FP16 chỉ phủ khoảng 6e-5 đến 65504. Nhân loss với S trước backward để dịch phân phối gradient lên dải FP16:

L^=S⋅L⇒g^=S⋅g⇒g=g^/S\hat{L} = S \cdot L \Rightarrow \hat{g} = S \cdot g \Rightarrow g = \hat{g} / S

3. Tính toán FP16 hoặc BF16. Forward và backward chạy ở 16 bit trên Tensor Core, nhưng bộ tích luỹ (phép cộng) vẫn ở FP32: D = A·B + C, với A, B ở FP16 và C, D ở FP32. Cách này giữ độ chính xác khi cộng hàng nghìn phần tử.

Ví dụ với PyTorch AMP

pytorch_amp.py

import torch
from torch import nn
from torch.amp import autocast, GradScaler
from torch.utils.data import DataLoader

device = "cuda"
model = MyTransformer().to(device)
optimizer = torch.optim.AdamW(model.parameters(), lr=3e-4)
criterion = nn.CrossEntropyLoss()

# GradScaler duy nhất cho toàn bộ quá trình train
scaler = GradScaler()

for epoch in range(num_epochs):
    for batch in DataLoader(train_ds, batch_size=32):
        optimizer.zero_grad(set_to_none=True)

        # 1) Forward + loss ở FP16 (hoặc BF16)
        with autocast(device_type=device, dtype=torch.float16):
            logits = model(batch.input_ids)
            loss = criterion(logits, batch.labels)

        # 2) Nhân loss lên S rồi backward (gradient đã được scale)
        scaler.scale(loss).backward()

        # 3) Unscale + clip gradient nếu cần
        scaler.unscale_(optimizer)
        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

        # 4) Step: nếu overflow -> skip, sau đó update scale
        scaler.step(optimizer)
        scaler.update()

GradScaler làm gì bên dưới?

  1. Khi gọi scale(loss), chỉ là phép nhân vô hướng, không thêm chi phí đáng kể.
  2. Khi backward chạy, gradient được tính với giá trị đã scale. Không phép nào biết nó đang bị scale.
  3. unscale_(optimizer) duyệt các tham số của optimizer, chia gradient cho scale và kiểm tra Inf hoặc NaN.
  4. Nếu có Inf hoặc NaN: bỏ qua optimizer.step(), giảm scale bằng backoff_factor (mặc định 0,5), reset bộ đếm.
  5. Nếu ổn: bộ đếm tăng. Khi đạt growth_interval (mặc định 2000), nhân scale với growth_factor (2,0) để khai thác hết dải FP16.

Chiến lược này tự tìm scale phù hợp cho từng pha huấn luyện: đầu huấn luyện gradient lớn, về sau gradient nhỏ dần và scale tự tăng.

So sánh FP16, BF16 và FP8

Tiêu chíFP16BF16FP8
Phạm viDải hẹp, cần loss scalingDải như FP32, gần như không cần loss scalingHai biến thể E4M3 và E5M2 cho kích hoạt và gradient
Độ phân giảiTốt nhất trong nhóm 16 bitThấp, khoảng 2 chữ số thập phânRất thấp
Phần cứngTừ VoltaTừ AmpereTừ Hopper (H100)

Khi huấn luyện LLM hiện đại, công thức phổ biến: forward ở E4M3, backward ở E5M2, master weight FP32, optimizer state có thể là BF16 hoặc FP32.

Tóm tắt

  • Mixed precision = FP16 hoặc BF16 cho forward và backward (nhanh 2 đến 3 lần trên Tensor Core), kết hợp FP32 cho master weights và cập nhật.
  • FP16 có dải hẹp nên cần loss scaling; BF16 có dải như FP32 nên gần như không cần.
  • GradScaler động: nhân loss với S trước backward, unscale trước cập nhật, tự điều chỉnh S khi có Inf hoặc NaN.
  • Tensor Core nhân ở 16 bit nhưng cộng tích luỹ ở 32 bit, nhờ đó giữ độ chính xác khi cộng hàng nghìn phần tử.
  • FP8 trên Hopper dùng E4M3 cho kích hoạt và E5M2 cho gradient.
  • Một số phép nhạy (softmax, layernorm, cross-entropy) nên giữ FP32; autocast xử lý phần lớn tự động.

Continue the module

Lesson 8 of 8