Optimization Algorithm

Thuật toán tối ưu hóa, hay optimizer, là quy tắc mà quy trình huấn luyện dùng để thay đổi các tham số của model nhằm giảm hàm loss. Trong học sâu, optimizer nhận gradient của loss theo từng trọng số model thông qua lan truyền ngược, rồi quyết định dịch chuyển mỗi trọng số bao xa và theo hướng nào. Kết hợp với learning rate, optimizer quyết định tốc độ hội tụ của quá trình huấn luyện, độ ổn định, mức bộ nhớ cần dùng và thường cả khả năng khái quát hóa của model cuối cùng.

Cách optimizer hoạt động#

Gần như mọi optimizer trong học sâu đều là biến thể của gradient descent: tính gradient g của loss trên một mini-batch, rồi dịch chuyển trọng số một bước nhỏ theo hướng ngược lại, w ← w − η·g. Các optimizer khác nhau ở cách xử lý g trước khi cập nhật. Phương pháp momentum lấy trung bình gradient theo thời gian để tăng tốc theo những hướng nhất quán. Phương pháp thích ứng chia bước cập nhật của mỗi tham số cho ước tính đang chạy về độ lớn gradient của tham số đó. Muon trực giao hóa toàn bộ bản cập nhật cho từng ma trận trọng số. Phương pháp bậc hai cũng sử dụng độ cong, giúp mỗi bước có cơ sở tốt hơn nhưng tốn kém hơn nhiều khi tính toán. Các phương pháp không cần gradient, chẳng hạn thuật toán tiến hóa và tìm kiếm ngẫu nhiên, tối ưu hóa bằng cách thử các ứng viên rồi giữ lại ứng viên tốt nhất:

Quy tắc cập nhật quan trọng nhất khi bề mặt loss có điều kiện kém, cong dốc theo một số hướng và thoải theo những hướng khác. Chạy ba optimizer từ cùng một điểm khởi đầu trong một thung lũng hẹp cho thấy sự khác biệt:

import torch

# A long, narrow valley: f(w) = w1^2 + 50 * w2^2, with its minimum at (0, 0)
scale = torch.tensor([1.0, 50.0])
optimizers = {
    "SGD": lambda p: torch.optim.SGD(p, lr=0.015),
    "SGD + momentum": lambda p: torch.optim.SGD(p, lr=0.015, momentum=0.9),
    "Adam": lambda p: torch.optim.Adam(p, lr=0.1),
}

for name, make_optimizer in optimizers.items():
    w = torch.tensor([5.0, 1.0], requires_grad=True)
    optimizer = make_optimizer([w])
    # Same loss and starting point for every optimizer; only the update rule differs
    for step in range(100):
        loss = (scale * w**2).sum()
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    print(f"{name:15s} f(w) after 100 steps: {(scale * w**2).sum().item():.6f}")

SGD thuần dừng ở mức 0.056531 vì hướng dốc w2 giới hạn learning rate: mọi mức learning rate trên 0.02 đều khiến w2 vượt quá nhiều hơn ở mỗi bước, và tại 0.021, loss tăng lên khoảng 9,5 tỷ trong vòng 100 bước. Với giới hạn đó, tiến độ theo hướng thoải w1 rất chậm. Momentum đạt 0.000216 nhờ tăng tốc theo w1, còn Adam đạt 0.001953 nhờ dùng kích thước bước riêng cho từng tọa độ.

Các thuật toán tối ưu hóa phổ biến#

• Gradient descent ngẫu nhiên (SGD): Cập nhật theo hướng ngược với gradient mini-batch. Với momentum 0.9, phương pháp này đã huấn luyện hầu hết các mạng nơ-ron tích chập mang tính cột mốc và lưu thêm một giá trị cho mỗi tham số.
• AdaGrad và RMSProp: Điều chỉnh bước cập nhật của mỗi tham số theo lịch sử bình phương gradient. AdaGrad chia cho căn bậc hai của tổng tích lũy, vốn chỉ tăng, nên bước cập nhật giảm dần trong suốt quá trình huấn luyện. Thay vào đó, RMSProp dùng trung bình suy giảm theo hàm mũ, giúp kích thước bước cập nhật phản ứng linh hoạt.
• Adam: Kết hợp momentum với cách điều chỉnh theo kiểu RMSProp và hiệu chỉnh cả hai trung bình đang chạy để bù cho giá trị khởi đầu bằng không. Các giá trị mặc định, learning rate 0.001 với β1 = 0.9 và β2 = 0.999, phù hợp với nhiều bài toán.
• AdamW: Adam với weight decay tách rời, trực tiếp làm giảm trọng số thay vì thông qua điều chỉnh gradient thích ứng. Đây là optimizer tiêu chuẩn cho Transformer và mô hình ngôn ngữ lớn (LLMs).
• Muon: Trực giao hóa bản cập nhật momentum của từng ma trận trọng số 2D bằng các vòng lặp Newton–Schulz và duy trì một buffer trạng thái duy nhất cho mỗi tham số. Moonshot AI đã mở rộng quy mô phương pháp này cho tiền huấn luyện LLM.
• L-BFGS: Phương pháp quasi-Newton xây dựng ước tính độ cong từ các gradient gần đây. Phương pháp này hội tụ chỉ sau vài bước trên các bài toán trơn với toàn bộ batch, còn gradient mini-batch nhiễu khiến nó không phù hợp với mạng lớn.

Gói optimizer của PyTorch triển khai tất cả các phương pháp này, bao gồm torch.optim.Muon, cùng với các bộ lập lịch learning rate tương thích với mọi phương pháp.

Optimizer và các thuật ngữ liên quan#

• Hàm loss: Mục tiêu mà optimizer tối thiểu hóa, chẳng hạn như cross-entropy cho phân loại hoặc sai số bình phương trung bình cho hồi quy.
• Bộ lập lịch learning rate: Điều chỉnh kích thước bước η trong quá trình huấn luyện bằng warmup, giảm theo bậc hoặc annealing cosine, và có thể dùng cùng bất kỳ optimizer nào.
• Tinh chỉnh hyperparameter: Tìm kiếm ở cấp cao hơn trên các thiết lập như optimizer, learning rate và batch size; mỗi ứng viên đòi hỏi một lần chạy huấn luyện toàn phần hoặc một phần. Các phương pháp không dùng gradient như tối ưu hóa Bayesian và tìm kiếm tiến hóa đảm nhiệm công việc này, vì không thể tính gradient của điểm số validation theo các lựa chọn như optimizer.

Chọn optimizer#

Optimizer và learning rate được chọn cùng nhau vì mỗi optimizer hoạt động tốt trong một khoảng riêng: SGD với momentum thường bắt đầu ở mức 0.01 đến 0.1, còn optimizer thuộc họ Adam ở khoảng 0.001. Huấn luyện Ultralytics YOLO tự động chọn: optimizer="auto" mặc định bỏ qua lr0 và chọn AdamW với learning rate được điều chỉnh theo số lớp cho các lần chạy tối đa 10.000 iteration, hoặc chọn MuSGD—kết hợp SGD và Muon được dùng để huấn luyện các checkpoint YOLO26 đã phát hành—cho lịch trình dài hơn; khi chỉ định optimizer, lr0 sẽ có hiệu lực:

from ultralytics import YOLO

# Tải model YOLO26n đã tiền huấn luyện
model = YOLO("yolo26n.pt")

# Chọn rõ SGD; lr0 chỉ áp dụng khi optimizer không phải là "auto"
results = model.train(data="coco8.yaml", epochs=5, optimizer="SGD", lr0=0.01)

Với optimizer="SGD", trainer cũng bật momentum Nesterov, dùng tham số momentum—mặc định là 0.937—làm hệ số.