Context Parallelism
Il parallelismo del contesto suddivide una sequenza di input lunga tra GPU che si scambiano chiavi e valori durante l'attenzione, riducendo la memoria richiesta a ciascuna GPU.
Il parallelismo del contesto (CP) è una tecnica di addestramento distribuito che suddivide una singola sequenza di input lunga tra più GPU. Ogni GPU contiene una porzione contigua o intercalata dei token e tutte le attivazioni calcolate a partire da essi, quindi la memoria necessaria su ciascun dispositivo diminuisce man mano che si aggiungono dispositivi. I layer che elaborano i token in modo indipendente, come la normalizzazione e i blocchi feed-forward, operano sui token locali senza comunicare. L'eccezione è la self-attention, perché ogni query può esaminare ogni chiave: perciò le GPU si scambiano chiavi e valori per ottenere esattamente lo stesso output dell'attenzione calcolata sull'intera sequenza. È una tecnica di sistema che consente di gestire una determinata finestra di contesto, la cui lunghezza è fissata dall'architettura e dall'addestramento del modello.
Come le GPU condividono chiavi e valori#
Le implementazioni differiscono soprattutto nel modo in cui le chiavi e i valori raggiungono le GPU che ne hanno bisogno:
- Attenzione ad anello: Le GPU formano un anello e passano i blocchi di coppie chiave-valore alle GPU vicine mentre calcolano sul blocco in loro possesso, nascondendo i trasferimenti dietro i calcoli.
- All-gather: Ogni GPU raccoglie tutte le chiavi e i valori, quindi calcola l'attenzione per le proprie query. Meta ha scelto questo metodo per Llama 3 perché supporta facilmente le maschere per i documenti, e l'attenzione a query raggruppate mantiene chiavi e valori molto più piccoli delle query.
- All-to-all: DeepSpeed Ulysses riorganizza i dati in modo che ogni GPU contenga tutti i token per un sottoinsieme di teste di attenzione, limitando il grado di parallelismo al numero di teste.
L'API sperimentale di parallelismo del contesto di PyTorch sostituisce l'attenzione a prodotto scalare scalato con l'attenzione ad anello all'interno di un blocco context_parallel(); Megatron-Core di NVIDIA raccoglie chiavi e valori tramite trasferimenti punto-punto ad anello nel passaggio in avanti e distribuisce i relativi gradienti con reduce-scatter nel passaggio all'indietro. Il CP differisce dal precedente parallelismo di sequenza di Megatron, che suddivide solo le attivazioni di layer norm e dropout insieme al parallelismo dei tensori, perché suddivide gli input e tutte le attivazioni lungo la sequenza.
Bilanciare l'attenzione causale#
Con una maschera causale, il token i presta attenzione solo agli i token che lo precedono e a sé stesso, quindi i token successivi richiedono più calcolo. Se si assegna a ogni GPU un quarto contiguo della sequenza, la prima GPU esegue poco lavoro e l'ultima ne esegue la maggior parte; il ritmo è dettato dalla GPU più occupata. Llama 3 e Megatron-Core suddividono la sequenza in un numero di segmenti doppio rispetto alle GPU e assegnano a ciascuna GPU un segmento iniziale e il corrispondente segmento speculare dalla fine:
import torch
seq_len, ranks = 8192, 4
positions = torch.arange(seq_len)
causal_work = positions + 1 # con una maschera causale, il token i presta attenzione a i + 1 chiavi
# Suddivisione contigua: il rank r prende il r-esimo quarto della sequenza
contiguous = [causal_work[shard].sum().item() for shard in positions.chunk(ranks)]
# Suddivisione bilanciata per il carico: dividere in 2 * ranks segmenti; il rank r prende il segmento r e quello speculare dalla fine
chunks = positions.chunk(2 * ranks)
balanced = [causal_work[torch.cat([chunks[r], chunks[-1 - r]])].sum().item() for r in range(ranks)]
print("Contiguous, millions of scores per rank:", [round(w / 1e6, 1) for w in contiguous])
print("Balanced, millions of scores per rank: ", [round(w / 1e6, 1) for w in balanced])La suddivisione contigua assegna alle quattro GPU [2.1, 6.3, 10.5, 14.7] milioni di punteggi di attenzione, con una differenza di 7×, mentre la suddivisione speculare assegna a ciascuna 8.4 milioni.
Dove si usa il parallelismo del contesto#
L'uso principale è l'addestramento di modelli linguistici di grandi dimensioni (LLM) su documenti e basi di codice lunghi. Meta ha esteso Llama 3 405B a sequenze di 131.072 token con un parallelismo del contesto a 16 vie, insieme al parallelismo dei tensori, della pipeline e dei dati, su 16.384 GPU H100; ha raggiunto il 38% del throughput BF16 massimo, rispetto al 41% ottenuto dallo stesso cluster con 8.192 token. L'altro ambito è il video: Movie Gen di Meta ha addestrato il proprio modello di generazione video da 30 miliardi di parametri su clip codificate come circa 73.000 token, usando il parallelismo del contesto insieme al parallelismo dei tensori, di sequenza e dei dati completamente suddivisi. Anche i modelli visione-linguaggio e i sistemi di comprensione video per video lunghi raggiungono lo stesso limite, perché ogni fotogramma aggiunge centinaia di token.
Il parallelismo del contesto si combina con le altre strategie:
- Parallelismo della pipeline: Suddivide i layer del modello tra le GPU.
- Parallelismo dei dati: Suddivide il batch tra copie complete del modello.
- Flash attention: Evita di memorizzare la matrice di attenzione su una singola GPU. Le implementazioni del parallelismo del contesto eseguono su ogni GPU un kernel simile sul blocco locale.
I modelli per immagini raggiungono queste lunghezze solo a risoluzioni molto elevate, poiché la lunghezza della sequenza cresce con il numero di patch o di posizioni sulla mappa delle caratteristiche. Ultralytics YOLO26 applica la self-attention solo alla sua mappa delle caratteristiche più grossolana, con stride 32, nei layer 10 e 22 della configurazione del modello, quindi l'attenzione copre 400 posizioni con il valore predefinito imgsz=640 e 1.600 con imgsz=1280.










