nouvelles

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

Nouveau rapport de sagesse

Editeur : Qiao Yang

[Introduction à la nouvelle sagesse] Un article récemment accepté par DeepMind lors de l'ICML 2024 a complètement exposé leur « tyrannie » soutenue par Google. Un article estime que la puissance de calcul et le coût requis pour cette recherche représentent environ 15 % de la pré-formation de Llama 3, et que le coût peut atteindre 12,9 millions de dollars américains.

Quel budget expérimental est nécessaire pour publier un article de conférence ?

Récemment, DeepMind a publié une étude qui a mené une enquête empirique approfondie sur divers détails algorithmiques et architecturaux, tels que la sélection des paramètres et des optimiseurs, lorsque le LLM évolue.

Cet article a été accepté par ICML 2024.

Adresse papier : https://arxiv.org/abs/2407.05872

Le document de 63 pages couvre des dizaines de milliers de modèles et les alternatives incluent 3 optimiseurs, 4 schémas de paramétrage, plusieurs hypothèses d'alignement, plus d'une douzaine de taux d'apprentissage et 14 tailles de paramètres allant jusqu'à 26,8 B.

4 schémas de paramétrage qui nécessitent des expérimentations

Rien qu’en entendant ces chiffres, il n’est pas difficile de savoir que cette recherche doit impliquer un grand nombre d’expériences de modélisation.

Un lecteur fidèle, afin de tester sa compréhension du contenu de l'article, a compté toutes les expériences qui y étaient menées et a estimé le coût de réplication de l'article.

En additionnant toute la puissance de calcul requise, le montant a atteint la somme étonnante de 12,9 millions de dollars.

Le moment est venu de tester vos compétences de base. Si vous dirigez une équipe de recherche, estimer la puissance de calcul et les coûts requis sur la base du plan expérimental est une compétence essentielle.

Alors suivons cet article de blog pour découvrir où exactement ces plus de 10 millions de dollars américains ont été brûlés.

Informations sur l'architecture du transformateur

L'annexe C du document fournit divers paramètres détaillés sur l'algorithme et l'architecture du modèle, tels que l'utilisation d'une architecture de décodeur uniquement, la normalisation des couches, la fonction d'activation GeLU, l'absence d'abandon, le tokenizer T5, la taille de lot de 256, l'utilisation du parallélisme FSDP, etc.

Statistiques à l'échelle des paramètres des modèles expérimentaux

Grâce aux informations architecturales, nous pouvons estimer approximativement les FLOPS requis pour chaque jeton en formation, noté M.

Étant donné que l'article ne décrit aucun mécanisme GQA/MQA, on suppose que Rkv=1, en plus de lseq=512, Dhead=128, L=8 (profondeur) et V=32101 (vocabulaire de segmentation de mots).

Les paramètres totaux du modèle peuvent être exprimés comme suit :

On peut donc obtenir la formule de calcul de M :

Par défaut, le nombre de jetons traités par expérience (TPE) est de 5 000 (nombre d'étapes de formation) × 256 (taille du lot) × 512 (lseq), soit environ 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

Expérience d'alignement

Dans l'expérience d'alignement des hypothèses, le résultat optimal obtenu à partir de l'analyse du taux d'apprentissage ultérieure a été directement utilisé au lieu d'une analyse du taux d'apprentissage distincte, de sorte que le calcul du coût à cette étape est relativement simple :

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

Si le H100 coûte 3 dollars par heure de fonctionnement, le coût de l'expérience d'alignement est d'environ 888 dollars.

taux d'apprentissage

Sous-problème : expérience de perte d'évaluation optimale (perte d'évaluation)

Le tableau E1 de l'article enregistre toutes les combinaisons possibles d'optimiseur × schéma de paramétrage × taille du modèle × paramètres expérimentaux sous 6 tailles de modèle, et effectue respectivement des analyses de taux d'apprentissage de base pour obtenir la meilleure perte d'évaluation.

Un total des variables expérimentales suivantes sont incluses :

- Dimension du modèle D∈3072,4096,6144,8192,12288,16384

- 4 options de paramétrage

- 3 optimiseurs, dont SGD n'a que 5 paramètres expérimentaux, Adam et Adam+Param Scaling ont 7 paramètres expérimentaux

Supposons que les expériences ici sont toutes menées individuellement et que les résultats ne sont pas reproduits ailleurs. Par conséquent, si elles sont toutes exécutées une seule fois, il existe une estimation limite supérieure du coût :

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)

Le coût de cette partie avoisine les 400 000 $, ce qui reste dans la fourchette acceptable, mais c'est déjà très cher pour la plupart des budgets académiques.

Le tableau E1 donne la meilleure perte d'évaluation, mais ne décrit pas la stratégie de balayage de LR, et le nombre de points sur chaque image est également différent.

Comme nous n'avons pas reçu de réponse de l'auteur de l'article, nous ne pouvons pas déterminer le mécanisme spécifique, nous supposons donc que chaque perte la mieux évaluée a fait l'objet de 15 expériences (l'inspection visuelle a révélé que le nombre de points dans chaque ligne est d'environ 10). à 15).

paramètre β

Selon la section 4.2 de l'article, le taux d'apprentissage implique également la sélection de deux hyperparamètres : β et γ.

S'il n'y a que des paramètres β, on parle de réglage "LR+default" :

Cette partie comprend un optimiseur 3×, un paramétrage 4×, ainsi que des expériences distinctes sur des couches globales et uniques (GlobalLR, Perlayer-fullalign) et un nombre inconnu d'analyses 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)

Comme le montre la formule, le coût est similaire à celui de l’expérience Epsilon ci-dessous, qui s’élèvent toutes deux à 2 millions de dollars.

paramètre γ

Par rapport à l’expérience du paramètre β, il existe deux différences détaillées dans cette partie.

Tout d'abord, en plus des paramètres GlobalLR et Perlayer-fullalign, le paramètre Perlayer-noalign doit également être ajouté.

Deuxièmement, une recherche d'hyperparamètres 3D (γ_1, γ_h, γ_L+1) est effectuée uniquement pour d=1024=b, il y a donc 800 exécutions supplémentaires.

La formule de calcul après combinaison des deux est :

Le coût estimé de cette partie est proche de l'expérience de carte thermique epsilon d'Adam, soit environ 3,2 millions de dollars.

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)

Paramètres Epsilon de l'optimiseur Adam

L'expérience du paramètre Epsilon décrite dans la section 4.3 de l'article représente l'essentiel du calcul.

Selon l'inférence ci-dessus, 15 taux d'apprentissage différents (points par ligne) sont essayés à chaque fois pour trouver la meilleure perte d'évaluation, puis la quantité de calcul du graphique de changement de paramètre epsilon illustré à la figure 6 est :

Les calculs ont révélé une facture succinctement coûteuse de 2 millions de dollars.

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

En plus du graphique linéaire sur le côté gauche de la figure 6, vous trouverez également les résultats de la carte thermique à l'annexe F.

En supposant que chaque valeur de bloc est le résultat de 13 analyses de taux d'apprentissage, la quantité de calcul de cette partie est :

Il a été constaté que le coût de l’obtention de ces 8 cartes thermiques s’élevait à 3,2 millions de dollars américains. De plus, puisque nous modélisons le nombre de scans LR comme une constante de 13, ce nombre est probablement inférieur au coût réel.

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

perte de poids

L'expérience de décroissance du poids (Annexe G) est relativement facile à comprendre. Une analyse LR de base est effectuée sur le schéma de paramétrage 4× et sur tous les paramètres :

C'est beaucoup moins cher que l'expérience Epsilon, qui correspond au salaire annuel d'un ingénieur de la Bay Area, soit 317 000 $.

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

Optimiseur Adafactor

Cette partie de l'expérience est décrite en détail à l'annexe C3 et vise à tester si les mises à l'échelle des paramètres Adafactor et Adam + ont des mécanismes de mise à l'échelle de largeur similaires.

Il existe des tracés 2 × 4, où chaque optimiseur collecte 11 points de données, la formule de calcul est donc :

188 000 $ supplémentaires ont été ajoutés à la facture.

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

Optimisation des calculs

L'article tente de modifier le nombre de têtes d'attention H, dans l'espoir de trouver les paramètres de calcul optimaux, mais cela implique des changements dans la taille des pas et l'ensemble de données, cette partie n'utilise donc pas de descriptions de formules. Le code de calcul est le suivant :

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)

Résumer

Résumez la puissance de calcul et les coûts des expériences ci-dessus :

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)

Il a été constaté que la complexité informatique de l’ensemble du document était de 5,42e24 FLOPS.

Ce nombre ne représente que 15 % du montant calculé pour l'entraînement de Llama 3. S'il est exécuté sur un cluster H100 de 100 000 cartes, il ne faut que 2 jours pour terminer toutes les expériences.

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%']

Cependant, si nous ne le mesurons pas à partir des normes de pré-formation LLM et considérons uniquement cet article de DeepMind comme une recherche universitaire, cette quantité de calcul semble assez extravagante.

Si le laboratoire ne disposait que de 10 H100, il serait impossible de mener des recherches d’une telle ampleur.

Un grand laboratoire doté de 100 H100 pourrait être en mesure de réaliser toutes les expériences ci-dessus dans quelques années.

Les références:

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

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

https://arxiv.org/abs/2407.05872