Modelli e piattaforme di IA

Comprendere i parametri e le esigenze di memoria dei modelli linguistici di grandi dimensioni: un’analisi approfondita

mm
Pubblicato il
Aggiornato il
Aggiungi Unite.AI alle tue fonti preferite su Google

I modelli linguistici di grandi dimensioni (LLM) hanno visto notevoli progressi negli ultimi anni. Modelli come GPT-4, Google’s Gemini e Claude 3 stanno fissando nuovi standard in termini di capacità e applicazioni. Questi modelli non solo migliorano la generazione di testo e la traduzione, ma stanno anche aprendo nuove frontiere nell’elaborazione multimodale, combinando testo, immagini, audio e video per fornire soluzioni AI piÃđ complete.

Ad esempio, GPT-4 di OpenAI ha mostrato miglioramenti significativi nella comprensione e generazione di testo simile a quello umano, mentre i modelli Gemini di Google eccellono nel gestire tipi di dati diversi, tra cui testo, immagini e audio, consentendo interazioni piÃđ fluide e contestualmente rilevanti. Allo stesso modo, i modelli Claude 3 di Anthropic sono noti per le loro capacità multilingue e per le prestazioni migliorate nei compiti AI.

Mentre lo sviluppo dei LLM continua ad accelerare, comprendere le peculiarità di questi modelli, in particolare i loro parametri ed esigenze di memoria, diventa cruciale. Questa guida si propone di demistificare questi aspetti, offrendo una spiegazione dettagliata e facile da comprendere.

I fondamenti dei modelli linguistici di grandi dimensioni

Cosa sono i modelli linguistici di grandi dimensioni?

I modelli linguistici di grandi dimensioni sono reti neurali addestrate su enormi dataset per comprendere e generare linguaggio umano. Si basano su architetture come i Transformer, che utilizzano meccanismi come l’auto-attenzione per elaborare e produrre testo.

Importanza dei parametri nei LLM

I parametri sono i componenti fondamentali di questi modelli. Comprendono pesi e bias, che il modello regola durante l’addestramento per minimizzare gli errori nelle previsioni. Il numero di parametri spesso correla con la capacità e le prestazioni del modello, ma influenza anche le esigenze computazionali e di memoria.

Comprendere l’architettura Transformer

Transformers-architecture

Architettura Transformer

Panoramica

L’architettura Transformer, introdotta nel paper “Attention Is All You Need” di Vaswani et al. (2017), ÃĻ diventata la base per molti LLM. Consiste in un encoder e un decoder, ciascuno composto da diversi strati identici.

Componenti encoder e decoder

  • Encoder: Elabora la sequenza di input e crea una rappresentazione consapevole del contesto.
  • Decoder: Genera la sequenza di output utilizzando la rappresentazione dell’encoder e i token precedentemente generati.

Blocchi chiave

  1. Attenzione multi-testa: Consente al modello di concentrarsi su diverse parti della sequenza di input contemporaneamente.
  2. Reti neurali feed-forward: Aggiungono non linearità e complessità al modello.
  3. Normalizzazione dei livelli: Stabilizza e accelera l’addestramento normalizzando gli output intermedi.

Calcolare il numero di parametri

Transformer Training

Modelli pre-addestrati per l’addestramento efficiente dei Transformer

Calcolare i parametri nei LLM basati su Transformer

Vediamo di scomporre il calcolo dei parametri per ogni componente di un LLM basato su Transformer. Utilizzeremo la notazione del paper originale, dove d_model rappresenta la dimensione degli stati nascosti del modello.

  1. Layer di embedding:
    • Parametri = vocab_size * d_model
  2. Attenzione multi-testa:
    • Per h teste, con d_k = d_v = d_model / h:
    • Parametri = 4 * d_model^2 (per Q, K, V e proiezioni di output)
  3. Rete neurale feed-forward:
    • Parametri = 2 * d_model * d_ff + d_model + d_ff
    • Dove d_ff ÃĻ tipicamente 4 * d_model
  4. Normalizzazione dei livelli:
    • Parametri = 2 * d_model (per scala e bias)

Parametri totali per un livello Transformer:

  • Parametri_layer = Parametri_attenzione + Parametri_ffn + 2 * Parametri_layernorm

Per un modello con N livelli:

  • Parametri totali = N * Parametri_layer + Parametri_embedding + Parametri_output

Esempio di calcolo

Consideriamo un modello con le seguenti specifiche:

  • d_model = 768
  • h (numero di teste di attenzione) = 12
  • N (numero di livelli) = 12
  • vocab_size = 50.000
  1. Layer di embedding:
    • 50.000 * 768 = 38.400.000
  2. Attenzione multi-testa:
    • 4 * 768^2 = 2.359.296
  3. Rete neurale feed-forward:
    • 2 * 768 * (4 * 768) + 768 + (4 * 768) = 4.719.616
  4. Normalizzazione dei livelli:
    • 2 * 768 = 1.536

Parametri totali per livello:

  • 2.359.296 + 4.719.616 + (2 * 1.536) = 7.081.984

Parametri totali per 12 livelli:

  • 12 * 7.081.984 = 84.983.808

Parametri totali del modello:

  • 84.983.808 + 38.400.000 = 123.383.808

Questo modello avrebbe circa 123 milioni di parametri.

Tipi di utilizzo della memoria

Quando si lavora con i LLM, ÃĻ necessario considerare due tipi principali di utilizzo della memoria:

  1. Memoria del modello: La memoria necessaria per archiviare i parametri del modello.
  2. Memoria di lavoro: La memoria necessaria durante l’inferenza o l’addestramento per archiviare le attivazioni intermedie, i gradienti e gli stati dell’ottimizzatore.

Calcolare la memoria del modello

La memoria del modello ÃĻ direttamente legata al numero di parametri. Ogni parametro ÃĻ tipicamente archiviato come un numero a virgola mobile a 32 bit, anche se alcuni modelli utilizzano l’addestramento a precisione mista con numeri a virgola mobile a 16 bit.

Memoria del modello (byte) = Numero di parametri * Byte per parametro

Per il nostro modello di esempio con 123 milioni di parametri:

  • Memoria del modello (32-bit) = 123.383.808 * 4 byte = 493.535.232 byte ≈ 494 MB
  • Memoria del modello (16-bit) = 123.383.808 * 2 byte = 246.767.616 byte ≈ 247 MB

Stimare la memoria di lavoro

Le esigenze di memoria di lavoro possono variare notevolmente in base al compito specifico, alla dimensione del batch e alla lunghezza della sequenza. Una stima approssimativa per la memoria di lavoro durante l’inferenza ÃĻ:

Memoria di lavoro ≈ 2 * Memoria del modello

Questo tiene conto dell’archiviazione sia dei parametri del modello che delle attivazioni intermedie. Durante l’addestramento, le esigenze di memoria possono essere ancora piÃđ elevate a causa della necessità di archiviare i gradienti e gli stati dell’ottimizzatore:

Memoria di addestramento ≈ 4 * Memoria del modello

Per il nostro modello di esempio:

  • Memoria di lavoro di inferenza ≈ 2 * 494 MB = 988 MB ≈ 1 GB
  • Memoria di addestramento ≈ 4 * 494 MB = 1.976 MB ≈ 2 GB

Utilizzo della memoria nello stato stazionario e utilizzo della memoria di picco

Quando si addestrano grandi modelli linguistici basati sull’architettura Transformer, comprendere l’utilizzo della memoria ÃĻ cruciale per un’allocazione efficiente delle risorse. Vediamo di scomporre le esigenze di memoria in due categorie principali: utilizzo della memoria nello stato stazionario e utilizzo della memoria di picco.

Utilizzo della memoria nello stato stazionario

L’utilizzo della memoria nello stato stazionario comprende i seguenti componenti:

  1. Pesi del modello: Copie FP32 dei parametri del modello, che richiedono 4N byte, dove N ÃĻ il numero di parametri.
  2. Stati dell’ottimizzatore: Per l’ottimizzatore Adam, ciÃē richiede 8N byte (2 stati per parametro).
  3. Gradienti: Copie FP32 dei gradienti, che richiedono 4N byte.
  4. Dati di input: Supponendo input int64, ciÃē richiede 8BD byte, dove B ÃĻ la dimensione del batch e D ÃĻ la dimensione dell’input.

L’utilizzo totale della memoria nello stato stazionario puÃē essere approssimato da:

  • M_steady = 16N + 8BD byte

Utilizzo della memoria di picco

L’utilizzo della memoria di picco si verifica durante il passo all’indietro quando vengono archiviate le attivazioni per il calcolo dei gradienti. I principali contributori all’utilizzo della memoria di picco sono:

  1. Normalizzazione dei livelli: Richiede 4E byte per livello di normalizzazione, dove E = BSH (B: dimensione del batch, S: lunghezza della sequenza, H: dimensione nascosta).
  2. Blocco di attenzione:
    • Calcolo QKV: 2E byte
    • Matrice di attenzione: 4BSS byte (S: lunghezza della sequenza)
    • Output di attenzione: 2E byte
  3. Blocco feed-forward:
    • Primo livello lineare: 2E byte
    • Attivazione GELU: 8E byte
    • Secondo livello lineare: 2E byte
  4. Perdita di entropia incrociata:
    • Logits: 6BSV byte (V: dimensione del vocabolario)

La memoria totale delle attivazioni puÃē essere stimata come:

  • M_act = L * (14E + 4BSS) + 6BSV byte

Dove L ÃĻ il numero di livelli Transformer.

Utilizzo totale della memoria di picco

L’utilizzo della memoria di picco durante l’addestramento puÃē essere approssimato combinando la memoria nello stato stazionario e la memoria delle attivazioni:

  • M_peak = M_steady + M_act + 4BSV byte

Il termine aggiuntivo 4BSV tiene conto di un’altra allocazione all’inizio del passo all’indietro.

Comprendendo questi componenti, possiamo ottimizzare l’utilizzo della memoria durante l’addestramento e l’inferenza, garantendo un’allocazione efficiente delle risorse e un miglioramento delle prestazioni dei grandi modelli linguistici.

Leggi di scala e considerazioni sull’efficienza

Leggi di scala per i LLM

La ricerca ha dimostrato che le prestazioni dei LLM tendono a seguire determinate leggi di scala man mano che il numero di parametri aumenta. Kaplan et al. (2020) hanno osservato che le prestazioni del modello migliorano come una legge di potenza del numero di parametri, del budget di calcolo e della dimensione del dataset.

La relazione tra le prestazioni del modello e il numero di parametri puÃē essere approssimata da:

Prestazioni ∝ N^α

Dove N ÃĻ il numero di parametri e Îą ÃĻ un esponente di scala tipicamente intorno a 0,07 per i compiti di modellazione linguistica.

CiÃē implica che per ottenere un miglioramento del 10% delle prestazioni, dobbiamo aumentare il numero di parametri di un fattore di 10^(1/Îą) ≈ 3,7.

Tecniche di efficienza

Mentre i LLM continuano a crescere, ricercatori e pratici hanno sviluppato varie tecniche per migliorare l’efficienza:

a) Addestramento a precisione mista: Utilizzare numeri a virgola mobile a 16 bit o anche 8 bit per determinate operazioni per ridurre l’utilizzo della memoria e le esigenze computazionali.

b) Parallelismo del modello: Distribuire il modello su piÃđ GPU o TPU per gestire modelli piÃđ grandi di quelli che possono essere gestiti da un singolo dispositivo.

c) Checkpointing dei gradienti: Scambiare calcolo per memoria ricomputando determinate attivazioni durante il passo all’indietro invece di archiviarle.

d) Potatura e quantizzazione: Rimuovere i pesi meno importanti o ridurre la loro precisione post-addestramento per creare modelli piÃđ piccoli e efficienti.

e) Distillazione: Addestrare modelli piÃđ piccoli a imitare il comportamento di modelli piÃđ grandi, potenzialmente conservando gran parte delle prestazioni con meno parametri.

Esempio pratico e calcoli

GPT-3, uno dei piÃđ grandi modelli linguistici, ha 175 miliardi di parametri. Utilizza la parte del decoder dell’architettura Transformer. Per comprendere la sua scala, analizziamo il conteggio dei parametri con valori ipotetici:

  • d_model = 12288
  • d_ff = 4 * 12288 = 49152
  • Numero di livelli = 96

Per un livello decoder:

Parametri totali = 8 * 12288^2 + 8 * 12288 * 49152 + 2 * 12288 ≈ 1,1 miliardo

Parametri totali per 96 livelli:
1,1 miliardo * 96 = 105,6 miliardi

I parametri rimanenti provengono da componenti di embedding e altri.

Conclusione

Comprendere i parametri e le esigenze di memoria dei grandi modelli linguistici ÃĻ cruciale per progettare, addestrare e distribuire efficacemente questi potenti strumenti. Analizzando i componenti dell’architettura Transformer e esaminando esempi pratici come GPT, otteniamo una comprensione piÃđ approfondita della complessità e della scala di questi modelli.

Per approfondire le ultime novità sui grandi modelli linguistici e le loro applicazioni, consultate queste guide complete:

mm

Ho trascorso gli ultimi cinque anni immergendomi nel mondo affascinante del Machine Learning e del Deep Learning. La mia passione e la mia esperienza mi hanno portato a contribuire a oltre 50 progetti di ingegneria del software diversi, con un focus particolare su AI/ML. La mia curiosità in corso mi ha anche portato verso l'elaborazione del linguaggio naturale, un campo che sono ansioso di esplorare ulteriormente.