notizia

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Nuovo rapporto sulla saggezza

Editore: Qiao Yang

[Introduzione alla Nuova Saggezza] Un documento recentemente accettato da DeepMind all'ICML 2024 ha completamente messo in luce la loro "tirannia" sostenuta da Google. Un articolo stima che la potenza di calcolo e il costo richiesti per questa ricerca siano circa il 15% del pre-addestramento di Llama 3 e il costo può raggiungere i 12,9 milioni di dollari USA.

Quanto budget sperimentale è necessario per pubblicare un articolo di una conferenza?

Recentemente, DeepMind ha pubblicato uno studio che ha condotto un'ampia indagine empirica su vari dettagli algoritmici e architettonici, come la selezione di parametri e ottimizzatori, quando LLM si espande.

Questo documento è stato accettato dall'ICML 2024.

Indirizzo del documento: https://arxiv.org/abs/2407.05872

Il documento di 63 pagine copre decine di migliaia di modelli e le alternative includono 3 ottimizzatori, 4 schemi di parametrizzazione, diverse ipotesi di allineamento, più di una dozzina di tassi di apprendimento e 14 dimensioni dei parametri fino a 26,8 B.

4 schemi di parametrizzazione che richiedono sperimentazione

Solo ascoltando questi numeri, non è difficile capire che questa ricerca dovrà coinvolgere un gran numero di esperimenti di modellizzazione.

Un lettore fedele, per verificare la sua comprensione del contenuto dell'articolo, ha contato tutti gli esperimenti condotti in esso e ha stimato il costo della replica dell'articolo.

Sommando tutta la potenza di calcolo richiesta, ha effettivamente raggiunto la sorprendente cifra di 12,9 milioni di dollari.

È giunto il momento di mettere alla prova le tue competenze di base. Se sei a capo di un gruppo di ricerca, stimare la potenza di calcolo e i costi richiesti in base al piano sperimentale è una competenza essenziale.

Allora seguiamo questo articolo del blog per scoprire dove sono stati bruciati esattamente questi oltre 10 milioni di dollari USA.

Informazioni sull'architettura del trasformatore

L'Appendice C del documento fornisce varie impostazioni dettagliate sull'algoritmo e sull'architettura del modello, come l'utilizzo dell'architettura solo decodificatore, la normalizzazione dei livelli, la funzione di attivazione GeLU, nessun dropout, tokenizzatore T5, dimensione batch di 256, utilizzo del parallelismo FSDP, ecc.

Statistica a scala parametrica di modelli sperimentali

Attraverso le informazioni sull'architettura, possiamo stimare approssimativamente i FLOPS richiesti per ciascun token in addestramento, indicato come M.

Poiché il documento non descrive alcun meccanismo GQA/MQA, si presuppone che Rkv=1, oltre a lseq=512, Dhead=128, L=8 (profondità) e V=32101 (vocabolario del segmentatore di parole).

I parametri totali del modello possono essere espressi come:

Possiamo quindi ottenere la formula di calcolo di M:

Per impostazione predefinita, il numero di token elaborati per esperimento (TPE) è 5k (numero di passaggi di training) × 256 (dimensione batch) × 512 (lseq), ovvero circa 6,5536e9.

def M(d: int, L=8, l_seq=512, V=32101) -> int:     return 6*d * (L*(12*d + l_seq) + V) TPE = 50000 * 256 * 512

Esperimento di allineamento

Nell'esperimento di allineamento delle ipotesi, il risultato ottimale ottenuto dalla successiva scansione del tasso di apprendimento è stato utilizzato direttamente invece di una scansione del tasso di apprendimento separata, quindi il calcolo dei costi in questa fase è relativamente semplice:

def alignment() -> int:     return 4 * TPE * sum(M(d) for d in [1024,2048,4096]) # >>> f'{alignment():.3E}' # '3.733E+20' # >>> cost_of_run(alignment())[0] # 888.81395400704

Se l’H100 costa 3 dollari l’ora di funzionamento, il costo dell’esperimento di allineamento è di circa 888 dollari.

tasso di apprendimento

Sottoproblema: esperimento di perdita di valutazione ottimale (eval loss).

La tabella E1 del documento registra tutte le possibili combinazioni di ottimizzatore × schema di parametrizzazione × dimensione del modello × impostazioni sperimentali in 6 dimensioni del modello ed esegue rispettivamente scansioni del tasso di apprendimento di base per ottenere la migliore perdita di valutazione.

Sono incluse in totale le seguenti variabili sperimentali:

- Dimensione modello D∈3072,4096,6144,8192,12288,16384

- 4 opzioni di parametrizzazione

- 3 ottimizzatori, di cui SGD ha solo 5 impostazioni sperimentali, Adam e Adam+Param Scaling hanno 7 impostazioni sperimentali

Supponiamo che gli esperimenti qui siano tutti condotti in modo indipendente e che i risultati non siano replicati da altri luoghi. Pertanto, se vengono eseguiti tutti una volta, esiste una stima limite superiore del costo:

H = [1,2,4,6,8,12,16,20,24,32,48,64,96,128] D = [h * 128 for h in H] def table_e1() -> int:   sets_x_optims = 5 + 7 + 7   return 4 * sets_x_optims * TPE * sum(M(d) for d in D[-6:]) # >>> f'{table_e1():.3E}';cost_of_run(table_e1()) # '1.634E+23' # (388955.9991064986, 16206.499962770775)

Il costo di questa parte è vicino ai 400.000 dollari, che rientra ancora nella fascia accettabile, ma è già molto costoso per la maggior parte dei budget accademici.

La tabella E1 fornisce la migliore perdita di valutazione, ma non descrive la strategia di scansione di LR e anche il numero di punti su ciascuna immagine è diverso.

Poiché non abbiamo ricevuto risposta dall'autore dell'articolo, non possiamo determinare il meccanismo specifico, quindi presumiamo che ciascuna perdita meglio valutata sia stata sottoposta a 15 esperimenti (l'ispezione visiva ha rilevato che il numero di punti in ciascuna riga è di circa 10 a 15).

parametro β

Secondo la Sezione 4.2 dell'articolo, il tasso di apprendimento implica anche la selezione di due iperparametri: β e γ.

Se sono presenti solo parametri β, si parla di impostazione "LR+default":

Questa parte include un ottimizzatore 3×, una parametrizzazione 4×, oltre a esperimenti separati su livelli globali e singoli (GlobalLR, Perlayer-fullalign) e un numero imprecisato di scansioni LR:

def beta_only() -> int:   return 3*4*2*PpL * TPE * sum(M(d) for d in D) # 7.988E+23 (1902022.3291813303, 79250.93038255542)

Come si può vedere dalla formula, il costo è simile a quello dell'esperimento epsilon riportato di seguito, entrambi pari a 2 milioni di dollari.

parametro γ

Rispetto all'esperimento sul parametro β, ci sono due differenze dettagliate in questa parte.

Innanzitutto, oltre alle impostazioni GlobalLR e Perlayer-fullalign, occorre aggiungere anche l'impostazione Perlayer-noalign.

In secondo luogo, una ricerca di iperparametri 3D (γ_1, γ_h, γ_L+1) viene eseguita solo per d=1024=b, quindi sono necessarie altre 800 esecuzioni.

La formula di calcolo dopo aver combinato i due è:

Il costo stimato di questa parte è vicino all'esperimento sulla mappa termica epsilon di Adam, circa 3,2 milioni di dollari.

def gamma_expts() -> int:   return 36*TPE * (800*M(1024) + PpL*sum(M(d) for d in D)) # gamma_expts 1.354E+24 (3224397.534237257, 134349.8972598857)

Parametri Epsilon dell'ottimizzatore Adam

L'esperimento sul parametro Epsilon descritto nella Sezione 4.3 del documento rappresenta la maggior parte del calcolo.

Secondo l'inferenza di cui sopra, vengono provati ogni volta 15 diversi tassi di apprendimento (punti per riga) per trovare la migliore perdita di valutazione, quindi l'importo del calcolo del grafico di modifica del parametro epsilon mostrato nella Figura 6 è:

I calcoli hanno rivelato una fattura sommaria di 2 milioni di dollari.

PpL = 15  # unprincipled estimate def eps_variants() -> int:   return 4 * 6 * PpL * TPE * sum(M(d) for d in D) ''' >>> f'{eps_variants():.3E}';cost_of_run(eps_variants()) '7.988E+23' (1902022.3291813303, 79250.93038255542) '''

Oltre al grafico a linee sul lato sinistro della Figura 6, sono presenti anche i risultati della mappa termica nell'Appendice F.

Supponendo che ciascun valore di blocco sia il risultato di 13 scansioni della velocità di apprendimento, l'importo del calcolo di questa parte è:

Si è scoperto che il costo solo per ottenere queste 8 mappe di calore era di 3,2 milioni di dollari. Inoltre, poiché modelliamo il numero di scansioni LR come costante 13, questo numero potrebbe essere inferiore al costo effettivo.

def eps_heatmaps() -> int:    # eps-type * eps-val * parameterizations * LR range * ...   return 2 * 6 * 4 * 13 * TPE * sum(M(d) for d in D[-6:]) ''' >>> f'{eps_heatmaps():.3E}';cost_of_run(eps_heatmaps()) '1.341E+24' (3193533.466348094, 133063.89443117057) '''

decadimento del peso

L'esperimento di decadimento del peso (Appendice G) è relativamente facile da comprendere. Viene eseguita una scansione LR di base sullo schema di parametrizzazione 4× e su tutti i parametri:

È molto più economico dell'esperimento epsilon, che equivale allo stipendio annuo di un ingegnere della Bay Area: 317.000 dollari.

def weight_decay() -> int:   return 4 * PpL * TPE * sum(M(d) for d in D) ''' >>> f'{weight_decay():.3E}'; cost_of_run(weight_decay()) '1.331E+23' (317003.7215302217, 13208.488397092571) '''

Ottimizzatore di Adafactor

Questa parte dell'esperimento è descritta in dettaglio nell'Appendice C3 e consiste nel verificare se il ridimensionamento dei parametri Adafactor e Adam+ abbiano meccanismi di ridimensionamento della larghezza simili.

Esistono grafici 2×4, in cui ciascun ottimizzatore raccoglie 11 punti dati, quindi la formula di calcolo è:

Altri $ 188.000 furono aggiunti al conto.

def adafactor() -> int:   return 2*2*4*PpL*TPE*sum(M(d) for d in D[:11]) ''' >>> f'{adafactor():.3E}'; cost_of_run(adafactor()) '7.918E+22' (188532.80765144504, 7855.533652143543) '''

Ottimizzazione del calcolo

Il documento tenta di modificare il numero di teste di attenzione H, sperando di trovare le impostazioni di calcolo ottimali, ma comporta modifiche nella dimensione del passo e nel set di dati, quindi questa parte non utilizza le descrizioni delle formule. Il codice di calcolo è il seguente:

def P(d: int, L=8, V=32101) -> int:     return 2 * d * (6*L*d + V) def compute_optimal():   indices_50k = (14, 14, 12)   return 4*PpL*sum([     TPE * sum(sum( M(d) for d in D[:i] ) for i in indices_50k),         20  * sum(P(d)*M(d) for d in D[:11]) *3,   ]) # compute_optim 7.518E+23 (1790104.1799513847, 74587.67416464102)

Riassumere

Riassumere la potenza di calcolo e i costi degli esperimenti di cui sopra:

alignment       3.733E+20 (888.81395400704, 37.033914750293334) table_e1        1.634E+23 (388955.9991064986, 16206.499962770775) eps_variants    7.988E+23 (1902022.3291813303, 79250.93038255542) eps_heatmaps    1.341E+24 (3193533.466348094, 133063.89443117057) beta_only       7.988E+23 (1902022.3291813303, 79250.93038255542) gamma_expts     1.354E+24 (3224397.534237257, 134349.8972598857) weight_decay    1.331E+23 (317003.7215302217, 13208.488397092571) adafactor       7.918E+22 (188532.80765144504, 7855.533652143543) compute_optim   7.518E+23 (1790104.1799513847, 74587.67416464102)

Si è riscontrato che la complessità computazionale dell'intero articolo era di 5,42e24 FLOPS.

Questo numero rappresenta solo il 15% dell'importo del calcolo di addestramento di Lama 3. Se eseguito su un cluster H100 da 100.000 carte, sono necessari solo 2 giorni per completare tutti gli esperimenti.

total_flops=5.421E+24 rental price: US$12.9M h100 node months required: 746.9595590938408 (sanity check) D=[128, 256, 512, 768, 1024, 1536, 2048, 2560, 3072, 4096, 6144, 8192, 12288, 16384] (sanity check) model sizes: ['0.00979B', '0.0227B', '0.058B', '0.106B', '0.166B', '0.325B', '0.534B', '0.794B', '1.1B', '1.87B', '4.02B', '6.97B', '15.3B', '26.8B'] (sanity check) M/6P: ['63.4%', '68.5%', '75.3%', '79.7%', '82.8%', '86.8%', '89.3%', '91.0%', '92.2%', '93.9%', '95.7%', '96.7%', '97.7%', '98.3%']

Tuttavia, se non lo misuriamo in base agli standard della pre-formazione LLM e consideriamo questo articolo di DeepMind solo come una ricerca accademica, questa quantità di calcoli sembra piuttosto stravagante.

Se il laboratorio avesse solo 10 H100, sarebbe impossibile condurre ricerche di questa portata.

Un grande laboratorio con 100 H100 potrebbe essere in grado di completare tutti gli esperimenti di cui sopra in pochi anni.

Riferimenti:

https://152334h.github.io/blog/scaling-exponents/

https://news.ycombinator.com/item?id=41107721

https://arxiv.org/abs/2407.05872