FLOPs

FLOPs (số phép toán dấu phẩy động) đếm các phép tính số học mà một mạng neural thực hiện để xử lý một đầu vào, chẳng hạn một ảnh hoặc một token, chủ yếu là phép nhân và phép cộng bên trong các layer. Số lượng này đo chi phí tính toán của model độc lập với phần cứng chạy model, nên là cách tiêu chuẩn để so sánh mức độ nặng của các kiến trúc khác nhau. Model thị giác thường được báo cáo bằng GFLOPs (hàng tỷ phép toán) tại kích thước đầu vào cụ thể; tổng lượng tính toán dùng để huấn luyện model lớn cũng được báo cáo bằng FLOPs.

FLOPs, FLOPS và MACs#

Ba thuật ngữ tương tự nhau này rất dễ bị nhầm lẫn:

• FLOPs (s thường): số lượng phép toán dấu phẩy động, là thuộc tính của model và kích thước đầu vào. Chỉ số này đo lượng công việc cần thực hiện.
• FLOPS (S viết hoa): số phép toán dấu phẩy động mỗi giây, là thuộc tính của phần cứng như GPU. Chỉ số này đo tốc độ xử lý; lấy FLOPs của model chia cho FLOPS tối đa của thiết bị sẽ cho thời gian chạy ngắn nhất có thể.
• MACs: phép nhân-tích lũy. Một MAC gồm một phép nhân và một phép cộng, nên bằng hai FLOPs. Một số bài báo và công cụ báo cáo MACs dưới tên FLOPs, khiến các con số giảm một nửa.

Cách tính FLOPs#

Phần lớn FLOPs của mạng đến từ phép nhân ma trận và phép tích chập. Một layer fully connected có n đầu vào và m đầu ra tốn khoảng 2 × n × m FLOPs cho mỗi đầu vào. Một phép tích chập tính một tích vô hướng cho mỗi giá trị đầu ra, nên chi phí là 2 × C_in × k × k × C_out × H_out × W_out, trong đó k là kích thước kernel và H_out × W_out là độ phân giải đầu ra. Activation, chuẩn hóa và phép cộng chỉ làm tăng chi phí tương đối nhỏ. Ví dụ dưới đây tính chi phí của một phép tích chập bằng công thức rồi kiểm tra bằng bộ đếm FLOP tích hợp của PyTorch:

import torch
from torch.utils.flop_counter import FlopCounterMode

# A 3x3 convolution mapping 64 channels to 128 on an 80x80 feature map
conv = torch.nn.Conv2d(64, 128, kernel_size=3, padding=1, bias=False)
x = torch.randn(1, 64, 80, 80)

# Each output value needs 64*3*3 multiply-accumulates (MACs); 1 MAC = 2 FLOPs
macs = 128 * 80 * 80 * 64 * 3 * 3
print(f"By formula: {2 * macs / 1e9:.3f} GFLOPs ({macs / 1e9:.3f} GMACs)")

# PyTorch's FLOP counter traces the real forward pass
with FlopCounterMode(display=False) as counter:
    conv(x)
print(f"Counted:    {counter.get_total_flops() / 1e9:.3f} GFLOPs")

Cả hai dòng đều in ra 0.944 GFLOPs; dòng công thức cũng cho biết cùng layer đó có 0.472 GMACs, bằng một nửa giá trị FLOPs. Với Transformer, một lượt forward tốn khoảng 2 FLOPs cho mỗi parameter trên mỗi token, còn huấn luyện tốn khoảng 6 FLOPs; đây là quy tắc kinh nghiệm từ nghiên cứu quy luật mở rộng, dùng để ước lượng tổng lượng tính toán cho một lần huấn luyện là 6 × số parameter × số token huấn luyện.

FLOPs và tốc độ thực tế#

FLOPs chỉ dự đoán tốc độ một cách tương đối. Latency còn phụ thuộc vào lưu lượng bộ nhớ, mức độ song song hóa hiệu quả của từng phép toán và việc phần cứng có kernel được tối ưu cho phép toán đó hay không. Bài báo ShuffleNet V2 cho thấy các mạng có FLOPs tương tự có thể chạy với tốc độ khác biệt rõ rệt trên cùng thiết bị; convolution depthwise có FLOPs thấp thường bị giới hạn bởi băng thông bộ nhớ thay vì năng lực tính toán. Các phương pháp tối ưu hóa cũng tác động đến những yếu tố khác nhau. Pruning model và giảm kích thước đầu vào loại bỏ phép toán, còn lượng tử hóa model giữ nguyên số phép toán nhưng làm mỗi phép toán rẻ hơn bằng cách tính toán với số nguyên 8 bit. Vì vậy, FLOPs phù hợp nhất để sàng lọc ban đầu trước khi đo latency inference trên thiết bị đích, chẳng hạn bằng chế độ benchmark của Ultralytics:

FLOPs trong lựa chọn model#

Họ model được phát hành với nhiều kích thước để các nhóm đánh đổi độ chính xác lấy năng lực tính toán; bài học kích thước model của Ultralytics Academy hướng dẫn lựa chọn này. Ultralytics YOLO26 có mức từ 5.5 GFLOPs với YOLO26n đến 194.4 GFLOPs với YOLO26x ở đầu vào 640×640; model.info() in ra GFLOPs của mọi model đã tải. Drone và điện thoại chạy bằng pin dùng biến thể nhỏ nhất, còn máy chủ đám mây có thể dùng biến thể lớn nhất. Vì chi phí của mạng tích chập tỷ lệ thuận với số pixel, kích thước đầu vào ảnh hưởng đến FLOPs nhiều tương đương kích thước model:

from ultralytics import YOLO
from ultralytics.utils.torch_utils import get_flops

# Load the smallest YOLO26 detection model and fuse its layers, as for inference
model = YOLO("yolo26n.pt")
model.fuse()

# Count GFLOPs for the same model at three input resolutions
for imgsz in [320, 640, 1280]:
    print(f"{imgsz}px: {get_flops(model.model, imgsz):.1f} GFLOPs")

Vòng lặp in ra 1.3, 5.5 và 23.4 GFLOPs: mỗi lần tăng gấp đôi cạnh đầu vào, số phép tính tăng khoảng bốn lần. Vì vậy, chạy YOLO26n ở 1,280 pixel tốn nhiều hơn 20.9 GFLOPs của YOLO26s, một model có số parameter gấp bốn lần, ở 640 pixel.