Fundamentos de ML

A gran escala manda la memoria: precisión mixta y los tres paralelismos

He medido en un portátil adónde van los bytes de un entrenamiento: con precisión mixta seguían siendo 16 bytes por parámetro, la mitad de las activaciones eran matrices de atención y FSDP dividió entre ocho el estado de cada proceso a cambio de 1,5 veces el tráfico del paralelismo de datos simple.

¿Acabas de llegar a la serie? Empieza aquí: qué da por sabido y qué no.

En la parte 11 serví un modelo que cabía en una sola máquina. El vocabulario del paralelismo sale de entrenar uno que no cabe: paralelismo de datos, de tensores y de pipeline, ZeRO, FSDP. Cada uno de esos términos responde a la misma pregunta, la de adónde van los bytes.

He medido lo que cabe en un portátil: un paso de entrenamiento en su GPU, gradientes convertidos a 16 bits y hasta ocho procesos en su CPU que se reparten un mismo modelo. Las cifras a escala de clúster que vienen después salen de hacer la cuenta con esas mismas reglas.

Cuenta los bytes antes de contar las GPU

Al entrenar con Adam se guardan cuatro números por parámetro: el peso, su gradiente y las dos medias móviles del optimizador que vimos en la parte 9. En fp32 son 4 bytes cada uno, 16 bytes por parámetro. Construí un GPT de 85,2 millones de parámetros, di un paso y sumé los tensores. Salieron 1,36 GB, 16,0 bytes por parámetro. El asignador de memoria de la GPU se quedó a menos de un 2 % de esa cifra.

La precisión mixta deja esa cifra en 16. Con el autocast de PyTorch en bf16, el mismo modelo guardaba 16,0 bytes por parámetro. Los pesos siguen en fp32. El autocast solo ejecuta en 16 bits las operaciones de su lista, entre ellas las multiplicaciones de matrices, y deja en fp32 las normalizaciones, la softmax y la pérdida. La receta habitual a gran escala mantiene una copia de trabajo en bf16 además de la copia maestra en fp32 que actualiza el optimizador, y también da 16. Megatron, la biblioteca de entrenamiento de NVIDIA, llega a 18 en las configuraciones que guardan los gradientes en fp32. Solo el bf16 puro, con los pesos y el estado del optimizador incluidos, bajó la cifra a la mitad, a 8,0. Esa variante entraña un riesgo numérico, porque bf16 almacena 7 bits de mantisa y las actualizaciones pequeñas se pierden al redondear.

Así que un modelo de 7000 millones de parámetros necesita 112 GB de estado de entrenamiento antes de leer un solo token. Eso no cabe en ninguna GPU de 80 GB.

Las activaciones crecen con el batch

La otra parte de la cuenta es lo que la pasada hacia delante guarda para la pasada hacia atrás: el grafo de la parte 8, con cada resultado intermedio que el gradiente va a necesitar. Lo medí en el mismo modelo con secuencias de 1024 tokens. Con una secuencia guardaba 1,29 GB y con cuatro, 4,86 GB, un crecimiento casi lineal. La mitad, 2,42 GB, eran matrices de atención: una de 1024 × 1024 por cabeza, por capa y por secuencia, en fp32. La precisión mixta no las tocó. En esta GPU, la atención de PyTorch se ejecutaba sin fusionar, operación a operación, y guardaba esa matriz en fp32 incluso con el autocast activo. El autocast recortó el resto un 34 %, de 2,44 a 1,61 GB, y añadió 170 MB de copias de los pesos en bf16. Por eso el total con cuatro secuencias solo bajó a 4,21 GB.

El recálculo de activaciones (el checkpointing de activaciones de la parte 8) guarda solo la entrada de cada bloque y lo vuelve a ejecutar durante la pasada hacia atrás. Con él, la cifra en fp32 bajó a 178 MB, 27 veces menos que los 4,86 GB. El precio es una segunda pasada hacia delante.

Korthikanti y sus coautores estiman que las activaciones de una capa, en 16 bits, ocupan unos s·b·h·(34 + 5as/h) bytes. Ahí s es la longitud de secuencia, b el batch, h el ancho y a el número de cabezas. El segundo término corresponde a las matrices de atención. Con las 12 capas de este modelo y cuatro secuencias salen 4,30 GB. Es una cifra cercana a los 4,21 medidos, aunque los términos no coinciden. Tres quintas partes del término de atención son dropout, que este modelo no usa. Lo que queda es la salida de la softmax, 1,21 GB en 16 bits, justo la mitad de los 2,42 que esta GPU guardaba en fp32. Si llevas la fórmula a un modelo de 7B con 8192 tokens, salen 380 GB para una sola secuencia, unos 170 sin dropout. Un kernel de atención fusionado que nunca guarda la matriz de atención baja esos 380 GB a 37, y el recálculo completo, a unos 2.

bf16 y fp16 cambian rango por precisión

La precisión mixta tiene dos formatos de 16 bits, y la diferencia se nota en los gradientes. En fp16 tienes 10 bits de mantisa almacenados y no puedes representar nada por debajo de unos 6e-8. El formato bf16 conserva el rango de exponente de fp32 y solo guarda 7 bits de mantisa.

Cogí los gradientes reales de un batch del modelo de 85M y los convertí. En fp16 se quedaron en cero 23 046 de los 85,2 millones. El 20 % cayó por debajo de 6e-5, en el rango subnormal, donde fp16 renuncia a bits de mantisa para llegar a números más pequeños. Con los gradientes multiplicados por 65 536 antes de convertirlos (es lo que le pasa a cada gradiente cuando se multiplica la pérdida), no se perdió ni se desbordó ninguno. Escalé gradientes ya calculados. En un entrenamiento real en fp16, los gradientes que fluyen hacia atrás entre capas también pueden quedarse en cero por underflow, y escalar la pérdida los protege igual.

Esa multiplicación se llama escalado de la pérdida (loss scaling). GradScaler la aplica y deshace la escala antes del paso del optimizador. Cuando un paso produce un inf o un NaN, el escalador se salta ese paso y reduce la escala a la mitad. En bf16 no se quedó en cero ningún gradiente, fuera cual fuera la escala. Gracias a su rango de fp32, bf16 no necesita escalador.

El paralelismo de datos lo copia todo y ZeRO lo reparte

La forma obvia de añadir GPU es el paralelismo de datos, que en PyTorch se llama DDP. A cada GPU le das el modelo entero y una parte del batch. Antes del paso, las GPU promedian sus gradientes con un all-reduce, una operación colectiva que deja la misma suma en todas. DDP divide el cómputo y deja copiado cada byte del estado. ZeRO, y después el FSDP de PyTorch, mantienen la misma aritmética y dividen el estado en shards. Las tres etapas de ZeRO reparten el estado del optimizador, luego también los gradientes y al final los pesos. FSDP equivale a la tercera. Cada GPU reúne lo que no le pertenece solo mientras una capa lo necesita.

Ejecuté DDP, ZeRO-1 y FSDP con hasta ocho procesos en la CPU de este portátil, con un modelo de 4,8 millones de parámetros y siempre el mismo batch global de 64 secuencias. Todas las variantes en fp32, con cualquier número de procesos, terminaron el tercer paso con la misma pérdida, 3,60987. Es el mismo cálculo, repartido de otra manera.

Un paso de entrenamiento del mismo modelo, repartido entre procesos en este portátil. Elige cómo repartirlo y arrastra el número de procesos. La barra de arriba es lo que guarda un proceso, frente a una copia completa. La de abajo es lo que envía en anillo en cada paso, frente al máximo de todas las configuraciones.

estado por proceso

pesos 19,1 MB gradientes 19,1 MB Adam 38,3 MB

tráfico por proceso y paso

estado por proceso
76,5 MB
de una copia completa
100,0 %
por operaciones colectivas
0,0 MB
enviado en anillo
0,0 MB
pérdida en el paso 3
3,60987

Empieza con DDP y sube el número de procesos. Por muchos que haya, cada uno guarda los 76,5 MB completos de pesos, gradientes y estado de Adam. Eso es lo que quiere decir copiarlo todo. ZeRO-1, el ZeroRedundancyOptimizer de PyTorch, solo reparte el estado de Adam, y con ocho procesos guarda 43,5 MB. FSDP lo reparte todo y se queda en 9,6 MB, la octava parte.

Esos bytes reaparecen en forma de tráfico. DDP hace un all-reduce de los gradientes una vez por paso, 19,1 MB. FSDP hace un all-gather de los pesos de cada bloque antes de la pasada hacia delante y otro antes de la pasada hacia atrás. Así, cada proceso recoge los trozos que no le pertenecen. Luego viene un reduce-scatter de los gradientes, y cada proceso se queda solo con la suma de su propio trozo. En total, por las operaciones colectivas de FSDP pasan unos 57 MB, el triple que con DDP. Por la red, la diferencia es menor. Un all-reduce en anillo, en el que cada proceso solo pasa fragmentos a su vecino, es un reduce-scatter seguido de un all-gather, por lo que cada proceso envía casi el doble de lo que aporta. Con ocho procesos, un anillo enviaría por proceso y paso 33,5 MB con DDP y 50 con FSDP, 1,5 veces más. El docstring de FSDP2 resume en una frase el canje de memoria por comunicación:

# torch 2.14.1, torch/distributed/fsdp/_fully_shard/_fully_shard.py:110-112
"""Apply fully sharded data parallelism (FSDP) to ``module``, where FSDP
shards module parameters, gradients, and optimizer states across data
parallel workers to save memory at the cost of communication."""

Elige FSDP con parámetros en bf16 y el tráfico baja a la mitad, mientras el estado sigue en 9,6 MB. MixedPrecisionPolicy convierte la copia que reúne FSDP, y el docstring de esa clase añade que «the optimizer step uses the sharded parameter in the original dtype» (_fsdp_api.py:30-31).

ZeRO-1 tiene una peculiaridad que conviene conocer. En el artículo de ZeRO, la etapa 1 se queda en el tráfico del paralelismo de datos simple. La versión de PyTorch hace un all-reduce de los gradientes y luego un broadcast de cada shard actualizado (zero_redundancy_optimizer.py:1151), con lo que también sale a 1,5 veces. Reparte tensores enteros, y por eso con ocho procesos el más cargado guardaba 5,2 MB de estado de Adam. Un reparto equitativo habría dado 4,8 a cada uno.

Con N GPU, un all-reduce en anillo envía desde cada GPU 2(N − 1)/N veces el tamaño de los gradientes. La cifra tiende al doble de ese tamaño y deja de crecer al añadir GPU. Para 7000 millones de gradientes en bf16 son 14 GB con dos GPU, 24,5 con ocho y 28 con mil. Cada GPU que se añade es un salto más en el anillo, con su propia latencia. Con un batch global fijo, añadir GPU también reduce el cómputo de cada una, así que la red ocupa una parte mayor de cada paso. Si el batch crece con ellas, esa parte se mantiene.

Los bytes que más tardan son los que pasan de una máquina a otra. Dentro de un servidor H100, NVLink mueve 450 GB/s por GPU en cada sentido; entre servidores, una tarjeta de red de 400 Gb/s mueve 50 GB/s, la novena parte.

El paralelismo de tensores y el de pipeline dividen lo que ZeRO no puede

Las etapas de ZeRO, que son de paralelismo de datos, reparten el estado. Ninguna reparte las activaciones: cada GPU sigue ejecutando capas enteras sobre su parte del batch. Cuando no caben las activaciones de una secuencia, o la comunicación del reparto sale demasiado cara, lo que se corta es el propio modelo.

El paralelismo de tensores divide cada matriz de pesos entre varias GPU. Cada GPU calcula una parte de cada capa. Megatron lo paga con dos all-reduce de activaciones en la pasada hacia delante de cada capa y otros dos en la pasada hacia atrás. Con tanto tráfico hacen falta los enlaces rápidos internos de un servidor, así que los autores de Megatron mantienen el paralelismo de tensores dentro de uno, con ocho GPU en sus DGX A100.

El paralelismo de pipeline da a cada GPU un tramo de capas consecutivas y va pasando las activaciones de una a otra. Divide cada batch en microbatches, de modo que etapas distintas pueden trabajar a la vez con microbatches distintos. Su coste es el tiempo muerto mientras el pipeline se llena y se vacía. Con p etapas y m microbatches, el schedule de GPipe, que ejecuta todas las pasadas hacia delante antes que ninguna hacia atrás, deja sin usar (p − 1)/(m + p − 1) del tiempo. Con cuatro etapas y cuatro microbatches eso supone un 43 %, y con ocho y sesenta y cuatro, un 10 %.

El pipeline divide el estado. Las activaciones las divide menos de lo que cabría esperar. El schedule habitual, una pasada hacia delante y luego una hacia atrás (1F1B), tiene el mismo tiempo muerto y menos microbatches en curso. Aun así, la primera etapa guarda p microbatches para su tramo de capas, lo que equivale a las activaciones de un modelo entero para un microbatch.

Memoria por GPU de un entrenamiento con secuencias de 8192 tokens, una por GPU. Cada receta indica cuántos bytes por parámetro ocupan los pesos, los gradientes y el estado de Adam. Las activaciones siguen la regla de Korthikanti con un kernel de atención fusionado. Las partes de cada capa que quedan fuera de las matrices divididas también se reparten a lo largo de la secuencia (paralelismo de secuencia), así que el paralelismo de tensores divide las activaciones. Las etapas de pipeline no las dividen, porque la primera guarda más o menos las de un modelo entero. El ámbar es el estado de entrenamiento y el gris, las activaciones. La línea marca 80 GB, un presupuesto que, en una tarjeta de 80 GiB (86 GB), deja unos pocos GB para CUDA y los búferes de comunicación. Las cifras salen de aplicar las reglas medidas más arriba.
GPU
1
estado por GPU
112 GB
activaciones
37 GB
total por GPU
149 GB
en 80 GB
no cabe

Elige el modelo de 405B. Sus 6,48 TB de estado de entrenamiento necesitan 81 GPU de 80 GB solo para caber en memoria, y el paralelismo de datos simple pone todo ese estado en cada una. El equipo de Llama 3 entrenó ese modelo en 16 384 GPU con secuencias de 8192 tokens. Usó paralelismo de tensores de grado 8 dentro de cada servidor, 16 etapas de pipeline y, por encima, 128 grupos de paralelismo de datos, que multiplicados dan justo esa cifra. El paralelismo de secuencia dividía a lo largo de la secuencia las partes que el paralelismo de tensores deja enteras. Pon esos tres valores y cada GPU necesita 122 GB con DDP. El paralelismo de tensores y el de pipeline bajan el estado de 6,48 TB a unos 51 GB por GPU, y las activaciones añaden algo menos de 72. Si repartes el estado del optimizador entre los 128 grupos, el total baja a 85 GB. Reparte también los gradientes y salen 79. Eso queda justo por debajo de la línea de 80 GB. Korthikanti hizo la cuenta para una capa de GPT-3, y las de Llama difieren en torno a una décima parte, así que con 79 GB son los detalles los que deciden si cabe. La tarjeta en sí tiene 80 GiB, unos 86 GB, de los que CUDA y los búferes de comunicación se llevan unos cuantos. Los 128 grupos son necesarios por el cómputo: a 400 billones de operaciones por segundo en cada GPU, 81 GPU tardarían unos 37 años en hacer las 3,8e25 operaciones del entrenamiento del 405B.

Qué vigila el ingeniero de ML

Son cuatro hábitos, y tres de ellos solo necesitan una calculadora.

Multiplica antes de reservar. Los parámetros por 16 bytes dan el estado de entrenamiento con Adam, con precisión mixta o sin ella. Divide entre las GPU solo si algo lo reparte.

Dimensiona las activaciones a partir del batch. Crecen con el producto del batch por la longitud de secuencia, y una atención sin fusionar añade una matriz por cabeza que crece con el cuadrado de la longitud. Usa primero un kernel fusionado. Aquí la precisión mixta recortó el resto en un tercio. El recálculo elimina la mayor parte de lo que queda a cambio de una segunda pasada hacia delante.

Elige el reparto según el cuello de botella. ¿No cabe el estado? Repártelo con ZeRO o FSDP. Si no caben las activaciones de una secuencia, recalcúlalas o divide cada capa con paralelismo de tensores dentro de un servidor, donde los enlaces son rápidos. Si el modelo sigue sin caber en un servidor, las etapas de pipeline entre servidores dividen su estado de entrenamiento y dejan en la primera etapa más o menos las activaciones de un modelo entero. ¿Todo cabe, pero va lento? Añade paralelismo de datos por encima.

Cuenta los bytes que viajan por la red. Repartir el estado cambia memoria por tráfico, que aquí fue 1,5 veces el del paralelismo de datos simple. El tráfico de cada GPU deja de crecer a medida que añades más. Con un batch global fijo, el cómputo de cada una sigue bajando. Antes de planificar con más máquinas, mide el enlace entre ellas.

La mayor parte del dimensionamiento es aritmética: una multiplicación para el estado, una fórmula de anillo para el tráfico y un producto de tres números para contar las GPU. Con esto se cierra la serie. Empezó en la parte 1 con un tokenizador que convertía texto en ids y termina con 16 384 GPU que se reparten un solo modelo.

Fundamentos de MLFrom code to weights