FLOPs

I FLOPs (operazioni in virgola mobile) contano le operazioni aritmetiche eseguite da una rete neurale per elaborare un input, per esempio un'immagine o un token, soprattutto moltiplicazioni e addizioni nei suoi strati. Questo conteggio misura il costo computazionale di un modello indipendentemente dall'hardware su cui viene eseguito, quindi è il metodo standard per confrontare il peso computazionale di architetture diverse. I modelli di visione vengono solitamente indicati in GFLOPs (miliardi di operazioni) per una dimensione di input specificata; anche il calcolo totale usato per addestrare un modello di grandi dimensioni viene espresso in FLOPs.

FLOPs, FLOPS e MAC a confronto#

È facile confondere tre termini simili:

• FLOPs (s minuscola): numero di operazioni in virgola mobile, una proprietà del modello e della dimensione dell'input. Misura il lavoro da svolgere.
• FLOPS (S maiuscola): operazioni in virgola mobile al secondo, una proprietà dell'hardware, come una GPU. Misura la velocità di esecuzione; dividendo i FLOPs di un modello per i FLOPS di picco di un dispositivo si ottiene il tempo di esecuzione minimo possibile.
• MAC: operazioni di moltiplicazione e accumulo. Un MAC è una moltiplicazione più un'addizione, quindi equivale a due FLOPs. Alcuni articoli e strumenti riportano i MAC con il nome di FLOPs, dimezzando così i valori.

Come si contano i FLOPs#

La maggior parte dei FLOPs di una rete proviene da moltiplicazioni di matrici e convoluzioni. Uno strato completamente connesso con n input e m output costa circa 2 × n × m FLOPs per input. Una convoluzione calcola un prodotto scalare per ogni valore di output, quindi il suo costo è 2 × C_in × k × k × C_out × H_out × W_out, dove k è la dimensione del kernel e H_out × W_out la risoluzione dell'output. Le funzioni di attivazione, la normalizzazione e le addizioni aggiungono un costo relativamente ridotto. L'esempio seguente calcola il costo di una convoluzione con una formula e lo verifica con il contatore di FLOPs integrato di 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")

Entrambe le righe stampano 0.944 GFLOPs; la riga della formula mostra lo stesso strato come 0.472 GMAC, la metà del valore in FLOPs. Nei Transformer, un passaggio in avanti costa circa 2 FLOPs per parametro e per token, mentre l'addestramento ne costa circa 6: è una regola pratica derivata dalla ricerca sulle leggi di scala, che stima il calcolo totale di un addestramento come 6 × parametri × token di addestramento.

FLOPs e velocità nel mondo reale#

I FLOPs prevedono la velocità solo in modo approssimativo. La latenza dipende anche dal traffico di memoria, dal grado di parallelizzazione di ogni operazione e dalla disponibilità di kernel ottimizzati per l'hardware. L'articolo su ShuffleNet V2 ha mostrato che reti con FLOPs simili possono avere velocità nettamente diverse sullo stesso dispositivo, e che le convoluzioni depthwise, pur richiedendo pochi FLOPs, sono spesso limitate dalla larghezza di banda della memoria anziché dai calcoli. Anche le ottimizzazioni intervengono su fattori diversi. Il pruning dei modelli e le dimensioni di input ridotte eliminano operazioni, mentre la quantizzazione dei modelli lascia invariato il numero di operazioni e le rende meno costose eseguendole con interi a 8 bit. I FLOPs sono quindi più utili come primo filtro prima di misurare la latenza di inferenza sul dispositivo di destinazione, ad esempio con la modalità benchmark di Ultralytics:

FLOPs nella selezione dei modelli#

Le famiglie di modelli vengono rilasciate in diverse dimensioni, così i team possono bilanciare la precisione e il calcolo; la lezione sulle dimensioni dei modelli di Ultralytics Academy illustra questa scelta. Ultralytics YOLO26 varia da 5.5 GFLOPs per YOLO26n a 194.4 GFLOPs per YOLO26x con un input da 640×640, e model.info() stampa i GFLOPs di qualsiasi modello caricato. I droni e i telefoni alimentati a batteria usano le varianti più piccole, mentre i server cloud possono permettersi quelle più grandi. Poiché il costo di una rete convoluzionale cresce con il numero di pixel, le dimensioni dell'input incidono sui FLOPs quanto quelle del modello:

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")

Il ciclo stampa 1.3, 5.5 e 23.4 GFLOPs: a ogni raddoppio del lato dell'input, il conteggio aumenta di circa quattro volte, quindi eseguire YOLO26n a 1,280 pixel costa più dei 20.9 GFLOPs di YOLO26s con input di 640, un modello con un numero di parametri quattro volte maggiore.