Leyes de escala y costos

La ley de potencia y la escala logarítmica

Kaplan et al. (2020) entrenaron transformers de 768 a 1 500 millones de parámetros (sin contar los embeddings) con texto de WebText2 y ajustaron la pérdida $L$ (entropía cruzada, en nats por token) frente al número de parámetros $N$, con datos de sobra:

Al tomar logaritmos, $\log L=\alpha_N\log N_c-\alpha_N\log N$: una recta de pendiente $-\alpha_N$ cuando los dos ejes están en escala logarítmica. Multiplicar $N$ por $k$ multiplica $L$ por $k^{-\alpha_N}$: por 10, $10^{-0.076}\approx 0.84$. Hay rectas parecidas para los datos ($\alpha_D\approx 0.095$, es decir ×0.80 por cada ×10) y para el cómputo bien repartido ($\alpha_C\approx 0.050$, ×0.89). Las constantes dependen del vocabulario y de los datos, y fuera del rango medido todo es extrapolación. La lección dibuja esta fórmula publicada, no las mediciones crudas.

Por qué seis: $C\approx 6ND$

En la ida, cada parámetro participa en una multiplicación y una suma por token: unos $2N$ FLOPs (Kaplan et al., ec. 2.2, ignorando el término de atención, pequeño cuando $d_{\text{modelo}}\gg n_{\text{ctx}}/12$). El regreso calcula dos cosas, el gradiente respecto de los pesos y respecto de las activaciones, y cada una cuesta lo mismo que la ida (Brown et al., 2020, tabla D.1): unos $4N$. En total, $6N$ por token y

Hoffmann et al. (2022, tabla A4) compararon su conteo exacto con $6ND$ en modelos de 73 M a 6.8 mil M de parámetros: la razón fue de 0.99 a 1.10. Para GPT-3, $6\cdot 175\cdot 10^{9}\cdot 300\cdot 10^{9}=3.15\cdot 10^{23}$; el artículo reporta $3.14\cdot 10^{23}$ con $N=174.6$ mil M.

Presupuesto fijo (Chinchilla)

Hoffmann et al. proponen para la pérdida

$E$ es la pérdida que no se puede quitar; el segundo término, lo que falta por tener un modelo finito; el tercero, por haber visto datos finitos. Minimizar $\hat L$ con $6ND=C$ fijo da $N_{\text{opt}}\propto C^{a}$ y $D_{\text{opt}}\propto C^{b}$ con $a\approx b\approx 0.5$: parámetros y datos crecen a la par, y su tabla 3 da unos 20 tokens por parámetro (1 000 M → 20.2 mil M de tokens; 10 mil M → 205 mil M). Kaplan había encontrado $N_{\text{opt}}\propto C^{0.73}$: con 10 veces más cómputo, 5.5 veces más parámetros y solo 1.8 veces más datos. Besiroglu et al. (2024) reajustaron las cinco constantes con datos reconstruidos de sus gráficas: las publicadas no concordaban con los otros dos métodos del artículo, y las suyas sí (su punto central da unos 26 tokens por parámetro). Llama 3 hizo su propio ajuste y, para $3.8\cdot 10^{25}$ FLOPs, predijo un modelo de 402 mil M con 16.55 billones de tokens.

Veinte es una guía para gastar bien el cómputo de entrenamiento, no una ley. Si el modelo se va a usar muchísimo, conviene uno más chico entrenado con más tokens, porque cada respuesta cuesta menos (Sardana et al., 2024): Llama 3.1 de 8 mil M leyó más de 15 billones de tokens.

De FLOPs a horas y dinero

Con una velocidad pico $P$ por GPU y una fracción de aprovechamiento (MFU, model FLOPs utilization, Chowdhery et al., 2022),

$H$ son las horas de GPU y $t$ el tiempo con $G$ GPU a la vez. Como $H$ no depende de $G$, duplicar las GPU reduce el tiempo a la mitad y deja el costo igual, mientras el aprovechamiento se mantenga. La ficha de la H100 da 1 979 teraFLOPS en BF16 «con dispersión»; sin ella, es la mitad (NVIDIA, 2021: la dispersión 2:4 duplica el rendimiento pico), unos 989. Llama 3 405B midió de 380 a 430 teraFLOPS por GPU, un MFU de 38 a 43 % (tabla 4), con hasta 16 384 GPU y 466 interrupciones en un periodo de 54 días. PaLM reporta 46.2 % y estima 21.3 % para GPT-3.

En código

def entrenamiento(n, d, util=400e12, precio=2.0, gpus=16384):
    flops = 6 * n * d                  # C ≈ 6·N·D
    horas = flops / util / 3600        # horas de GPU
    return flops, horas, horas / gpus / 24, horas * precio

modelos = [("Pythia 1.4B", 1.4e9, 300e9), ("GPT-3", 175e9, 300e9),
           ("Chinchilla", 70e9, 1.4e12), ("Llama 3.1 405B", 405e9, 15.6e12)]
for nombre, n, d in modelos:
    c, h, dias, usd = entrenamiento(n, d)
    print(f"{nombre:15} C = {c:.2e}  horas = {h:9.0f}  días = {dias:5.1f}  US$ {usd:9.0f}")

print(round(10 ** -0.076, 3))          # ×10 en N: la pérdida se multiplica por esto

Salida:

Pythia 1.4B     C = 2.52e+21  horas =      1750  días =   0.0  US$      3500
GPT-3           C = 3.15e+23  horas =    218750  días =   0.6  US$    437500
Chinchilla      C = 5.88e+23  horas =    408333  días =   1.0  US$    816667
Llama 3.1 405B  C = 3.79e+25  horas =  26325000  días =  66.9  US$  52650000
0.839

Los 400 billones de operaciones útiles por segundo, los 2 dólares por hora y las 16 384 GPU son supuestos (los dos primeros no son precios ni mediciones de cada modelo; GPT-3 y Chinchilla se entrenaron en otro hardware). La cifra cubre solo la corrida final: ni ensayos, ni fallas, ni datos, ni personas. Meta reportó 30.84 millones de horas de GPU H100 para Llama 3.1 405B.

Lo que viene

La lección 25 cuenta bytes en lugar de operaciones: qué modelo cabe en la memoria de una GPU y cómo se reparte el trabajo. La 26 mide el costo de usar el modelo, que con mucha demanda pesa más que el de entrenarlo. La 27 reutiliza un modelo base en vez de repetir esta cuenta.