Fundamentos · Unidades
FP64, FP32, TF32, BF16, FP16, FP8, INT8, FP4: la precisión decide el rendimiento
Qué bits tiene cada formato, por qué una misma GPU rinde 50 veces más en FP4 que en FP64, por qué BF16 ganó a FP16 y qué pierdes de verdad al cuantizar un modelo.
Una H100 hace 34TFLOPS en FP64 y 1 979TFLOPS en FP8. Es el mismo chip, los mismos vatios y la misma memoria. Lo único que cambia es cuántos bits tiene cada número. La precisión numérica no es un detalle de programadores: es la variable que multiplica o divide por 50 el rendimiento de cualquier GPU, y la que decide si un modelo de 70 000 millones de parámetros cabe o no en tu tarjeta. Cuando dos fichas técnicas dan cifras de FLOPS o TOPS, lo primero que hay que preguntar es: ¿en qué formato?
Qué hay dentro de un número: signo, exponente y mantisa
Un número en coma flotante se guarda en tres trozos. Un bit de signo. Unos bits de exponente, que fijan el orden de magnitud (el «×10n» de la notación científica, pero en base 2). Y unos bits de mantisa, que fijan las cifras significativas. Más bits de exponente dan más rango: números más grandes y más pequeños sin desbordar. Más bits de mantisa dan más precisión: más decimales distinguibles entre dos potencias de dos consecutivas.
| Formato | Bits (S·E·M) | Máximo aprox. | Dígitos decimales | Bytes por parámetro |
|---|---|---|---|---|
| FP64 | 1·11·52 | 1,8 × 10308 | 15,95 | 8 |
| FP32 | 1·8·23 | 3,4 × 1038 | 7,22 | 4 |
| TF32 | 1·8·10 (en 32 bits) | 3,4 × 1038 | 3,31 | 4 |
| BF16 | 1·8·7 | 3,4 × 1038 | 2,41 | 2 |
| FP16 | 1·5·10 | 65 504 | 3,31 | 2 |
| FP8 E4M3 | 1·4·3 | 448 | 1,2 | 1 |
| FP8 E5M2 | 1·5·2 | 57 344 | 0,9 | 1 |
| INT8 | entero | 127 | 2,41 (256 niveles) | 1 |
| NVFP4 | 1·2·1 + escala E4M3 por 16 | 6 (× escala) | 0,6 | 0,5625 |
| MXFP4 | 1·2·1 + escala E8M0 por 32 | 6 (× escala) | 0,6 | 0,53125 |
Los «dígitos decimales» salen de la mantisa. Con m bits de fracción y el 1 implícito que todo flotante normalizado lleva delante, hay 2m+1 valores distinguibles por binada, y el logaritmo en base 10 de esa cifra es el número de dígitos que puedes fiarte.
Dígitos significativos de un flotante
dígitos ≈ log₁₀(2^(bits de mantisa + 1))
FP16: log₁₀(2¹¹) = log₁₀(2 048) = 3,31 dígitos
FP32 tiene 23 bits de mantisa: log10(224) = log10(16 777 216) = 7,22 dígitos. BF16 se queda en 7 bits: log10(256) = 2,41. FP8 E4M3, con 3 bits, distingue 16 valores por binada: 1,2 dígitos. Y el elemento E2M1 de FP4 solo puede valer 0, ±0,5, ±1, ±1,5, ±2, ±3, ±4, ±5 o ±6. Toda la «precisión» de FP4 vive en la escala del bloque, no en el número.
La lección de la tabla es que rango y precisión son ejes independientes. FP16 y BF16 ocupan los mismos 16 bits, pero uno apuesta por precisión (10 bits de mantisa, máximo 65 504) y el otro por rango (8 bits de exponente, máximo 3,4 × 1038). Esa elección decide cuál se usa para entrenar.
Por qué la misma GPU rinde 58 veces más en FP8 que en FP64
Hay dos razones físicas. La primera es el multiplicador: el circuito que multiplica dos mantisas crece aproximadamente con el cuadrado de sus bits, así que multiplicar mantisas de 52 bits cuesta unas 25 veces más silicio que multiplicar mantisas de 10. En la misma superficie caben muchos más multiplicadores pequeños, y en los Tensor Cores además se agrupan en matrices que ejecutan decenas de FMA por ciclo. La segunda es el ancho de banda: un operando de 8 bits ocupa un octavo de uno de 64, así que registros, cachés y memoria sirven ocho veces más operandos por segundo con los mismos cables.
H100 SXM: TFLOPS dense por precisión
Fíjate en la escalera: cada vez que los bits se reducen a la mitad, el pico se dobla. En Blackwell hay un peldaño más: la B200 hace 4 500TFLOPS en FP8 y 9 000TFLOPS en FP4, siempre dense. Los bits también deciden cuánta memoria ocupa un modelo, la primera pregunta de quien quiere ejecutar un LLM en local.
Memoria de los pesos de un modelo
GB ≈ parámetros (miles de millones) × bytes por parámetro
Llama 3.3 70B: 70 × 2 (BF16) = 140 GB · 70 × 0,5625 (NVFP4) ≈ 39,4 GB
En BF16, el formato en que se publican casi todos los pesos, 70 000 millones de parámetros ocupan 140GB: no cabe en ninguna GPU de consumo ni en una RTX PRO 6000 de 96 GB. En FP8 son 70GB, y en NVFP4 (4 bits más una escala FP8 compartida por cada 16 valores, 4,5 bits por parámetro) unos 39,4GB. A eso hay que sumar la KV cache y un 10-20 % de sobrecarga: la calculadora de VRAM hace la cuenta con el modelo y el contexto que elijas.
BF16 contra FP16: por qué ganó el que tiene menos decimales
Entrenar una red es acumular gradientes muy pequeños durante millones de pasos. Con FP16 hay dos accidentes esperando. Por arriba, cualquier activación que supere 65 504 se convierte en infinito. Por abajo, cualquier gradiente menor que 6,1 × 10-5 entra en la zona subnormal y, por debajo de 6 × 10-8, se convierte en cero: deja de enseñar. Para sobrevivir, el entrenamiento en FP16 necesita loss scaling: multiplicar la pérdida por una constante grande antes de retropropagar, dividir después y ajustar esa constante cuando aparece un desbordamiento.
BF16 se inventó en Google para quitarse ese problema de encima. Es FP32 con los 16 bits bajos de la mantisa cortados: conserva los 8 bits de exponente y con ellos todo el rango de FP32. No hay desbordamiento ni gradientes que se vayan a cero, no hace falta loss scaling y convertir de FP32 es truncar. El precio es que solo quedan 2,41 dígitos: 1 + 1/256 ya no se puede representar. Por eso la precisión mixta guarda una copia maestra de los pesos en FP32, hace los productos en BF16 y acumula en FP32 dentro del propio Tensor Core: los productos son baratos; las sumas largas, donde se pierde información, se hacen con 23 bits.
En las fichas, FP16 y BF16 Tensor tienen siempre el mismo pico, en NVIDIA y en AMD: las unidades son las mismas y solo cambia el decodificador de entrada. Lo que no es igual es la acumulación, y ahí vive una de las trampas más silenciosas del catálogo de GeForce.
TF32: el FP32 «de folleto» de los Tensor Cores
Los Tensor Cores no multiplican FP32. Cuando multiplicas matrices FP32 en PyTorch sobre una NVIDIA moderna, por dentro puede pasar TF32: 19 bits (signo, 8 de exponente, 10 de mantisa) que NVIDIA introdujo en Ampere. Los operandos se redondean al entrar al Tensor Core y se acumula en FP32 de verdad. Rango de FP32, precisión de FP16.
Tres cosas hay que saber. Primera: TF32 ocupa 32 bits en memoria, así que no ahorra VRAM ni ancho de banda, solo cálculo. Segunda: en datacenter la ganancia es enorme y en consumo es nula. Una H100 hace 495TFLOPS en TF32 frente a 67TFLOPS FP32 en los CUDA cores, 7,4 veces más; una RTX 5090 hace 105TFLOPS en ambos, porque sus Tensor Cores están recortados en TF32. Tercera: en PyTorch el matmul en TF32 está desactivado por defecto desde la versión 1.12 (torch.backends.cuda.matmul.allow_tf32); las convoluciones de cuDNN sí lo usan. Si un benchmark «FP32» de una A100 parece demasiado bueno, era TF32.
FP8 y FP4: cuando la precisión se guarda en la escala
Con 8 bits ya no cabe un formato para todo. Hopper y Ada trajeron dos: E4M3 (4 bits de exponente, 3 de mantisa, máximo 448) y E5M2 (5 y 2, máximo 57 344). E4M3 renuncia a los infinitos para estirar el rango y da 16 valores por binada; se usa para pesos y activaciones. E5M2 es FP16 con la mantisa cortada, solo 8 valores por binada; se usa para gradientes, que necesitan rango y no resolución. Ambos corren al mismo pico. Con tan pocos niveles, ningún tensor real cabe sin un factor de escala en FP32 que el Transformer Engine ajusta dinámicamente. DeepSeek-V3 se entrenó en E4M3 con escalas por bloques de 128 valores: FP8 vale para preentrenar, no solo para inferir.
Con 4 bits la escala deja de ser un accesorio y pasa a ser el formato. El elemento E2M1 tiene nueve valores absolutos; lo que da sentido a un bloque es la escala compartida, y hay dos estándares:
- MXFP4 (OCP Microscaling, 2023): bloque de 32 con escala E8M0, una potencia de dos. Barata en silicio, 4,25 bits por parámetro, más error. Formato abierto: lo soportan NVIDIA Blackwell y AMD MI350/MI355X, y en él se publicaron los pesos de GPT-OSS.
- NVFP4 (NVIDIA, 2025): bloque de 16 con escala E4M3 y una segunda escala FP32 por tensor. 4,5 bits por parámetro, error menor, solo NVIDIA. NVIDIA reporta menos de un 1 % de degradación frente a FP8 en DeepSeek-R1.
| Equipo | FP64 (TFLOPS) | FP32 (TFLOPS) | FP16/BF16 dense (TFLOPS) | FP8 dense (TFLOPS) | FP4 dense (TFLOPS) | INT8 (TOPS) | Memoria (GB) |
|---|---|---|---|---|---|---|---|
| GeForce RTX 4090 | 1,29 | 82,6 | 330 | 661 | — | 661 | 24 |
| GeForce RTX 5090 | 1,64 | 105 | 419 | 838 | 1 676 | 838 | 32 |
| NVIDIA H100 SXM5 80 GB | 34 | 67 | 990 | 1 979 | — | 1 979 | 80 |
| NVIDIA B200 SXM (HGX B200) | 37 | 75 | 2 250 | 4 500 | 9 000 | 4 500 | 180 |
| AMD Instinct MI355X | 78,6 | 157 | 2 500 | 5 000 | 10 100 | 5 000 | 288 |
La columna FP4 vacía significa que el hardware no lo soporta en sus unidades matriciales, no cero.
La tabla enseña dos cosas que el marketing no cuenta. Una: FP4 dobla a FP8 (9 000 frente a 4 500 en B200, 1 676 frente a 838 en RTX 5090), pero el salto de FP16 a FP4 es 4×, no 8×. Dos: AMD y NVIDIA no reparten el silicio igual. En la MI355X, MXFP6 corre al ritmo de MXFP4 (10 100TFLOPS); en la B200, FP6 corre al ritmo de FP8 (4 500TFLOPS). Mismo formato, ratio distinta.
FP64: cuándo importa y por qué las GPU gaming lo capan a 1/64
Hay cálculos que no toleran 7 dígitos. Un solver implícito de elementos finitos, una simulación de fluidos con millones de pasos temporales o un modelo climático suman y restan cantidades casi iguales durante horas; con FP32 el error de redondeo se acumula hasta comerse la respuesta. Eso es FP64, lo que mide el LINPACK del Top500. Si tu trabajo es CAE o ciencia computacional, el número que manda es el que ningún folleto destaca.
FP64 vector por GPU
Las GPU de consumo y de workstation no tienen unidades FP64 de verdad: mantienen un puñado por SM para que los programas que lo piden no fallen, a 1/64 del ritmo FP32. La RTX 5090, con 105TFLOPS FP32, se queda en 1,64TFLOPS FP64: casi seis veces menos que una A100 de 2020. El motivo es económico: el multiplicador de 52 bits es caro y ni un juego ni un LLM lo usan. La MI300X es la GPU con más FP64 de su generación (81,7TFLOPS vector, 163,4 en matriz) y Blackwell no mejora a Hopper: 37 frente a 34. Blackwell Ultra recorta FP64 unas 27 veces respecto a B200 para dedicar el silicio a FP4: una B300 no vale para HPC clásico.
RTX 5090: 104,8 TFLOPS FP32 ÷ 64 = 1,64 TFLOPS FP64Cuantizar: qué se gana y qué se pierde
Cuantizar es convertir los pesos de un modelo entrenado en BF16 a un formato con menos bits para inferir. Se gana memoria y ancho de banda, que son lo que manda al generar tokens. Lo que hay que entender es que INT4 en un LLM es un formato de almacenamiento, no de cálculo: los pesos Q4_K_M, AWQ o GPTQ se guardan en 4 bits más escalas por grupo de 32-128 valores, y el kernel los descuantiza a FP16 antes de multiplicar. Funciona en cualquier GPU y acelera la lectura, no el cálculo. Con FP8 y NVFP4 nativos en Hopper y Blackwell sí se multiplica en el formato reducido.
Llama 3.1 8B: GiB por cuantización
Los bits por peso reales superan al nombre porque incluyen las escalas: Q4_K_M ocupa 4,89 bits por peso, Q8_0 ocupa 8,5. Lo que se pierde se mide en perplejidad o divergencia KL frente al original: Q8_0 es indistinguible, Q5 y Q4_K_M pierden poco, y por debajo de 4 bits la degradación crece deprisa y depende de la familia del modelo. Los modelos pequeños sufren más que los grandes con el mismo formato: un 8B en Q2 se nota; un 70B en Q4 a menudo no.
Techo de tokens por segundo en decode
tokens/s ≈ ancho de banda (GB/s) ÷ bytes leídos por token (GB)
RTX 5090 con 8B en Q4_K_M: 1 792 ÷ 4,92 ≈ 364 tokens/s de techo teórico
4,58 GiB son 4,92 GB decimales. En Q8_0 (7,95 GiB = 8,54 GB) el techo baja a 210 tokens/s, y en F16 (16,06 GB) a 112. La cuantización no ha cambiado ni un FLOPS; ha cambiado los bytes por token, y en decode con batch 1 esa es la única cifra que importa. La herramienta de tokens por segundo hace la estimación para cada GPU y cuantización.
Lo que debes recordar
- Bits de exponente = rango, bits de mantisa = precisión. FP16 y BF16 pesan lo mismo y eligen ejes opuestos; BF16 ganó en entrenamiento porque no desborda y no necesita loss scaling.
- Cada vez que los bits se reducen a la mitad, el pico Tensor se dobla: H100 494,7 TF32 → 989,5 FP16 → 1 979 FP8 dense. Blackwell añade FP4 a 2× FP8.
- Cuantizar a INT4 ahorra memoria y ancho de banda, no cálculo: el kernel descuantiza a FP16. FP8 y FP4 nativos (Hopper, Blackwell, MI350) sí aceleran la multiplicación.
- FP64 es 1/64 de FP32 en GeForce y RTX PRO. Para CAE y ciencia, mira esa línea antes que ninguna otra.
- Una comparación de TFLOPS solo vale si coincide precisión, acumulación y sparsity.
Para mirar en una ficha técnica
- TFLOPS Tensor por precisión: busca la fila dense de FP16/BF16 y FP8; si solo hay una cifra «AI TOPS», es FP4 o FP8 sparse (÷ 2 para dense). Trampa: comparar el FP8 de una con el FP16 de otra.
- Acumulación FP32: en GeForce la tasa FP16 con acumulación FP32 es la mitad de la publicada. Trampa: usar el número grande para estimar entrenamiento o fine-tuning.
- FP64 (TFLOPS): si no aparece, asume 1/64 del FP32. Trampa: una GPU «para IA» de 96 GB vendida como workstation científica.
- Formatos soportados: FP8 exige Hopper/Ada o superior, FP4 exige Blackwell o CDNA 4. Trampa: «soporta FP6» sin cifra de pico.
- Bytes por parámetro: 2 (BF16), 1 (FP8/Q8), ~0,6 (Q4_K_M), 0,5625 (NVFP4); multiplica por los parámetros y compara con la VRAM.
Fuentes
- NVIDIA H100 Tensor Core GPU — especificaciones — picos por precisión (publicados con sparsity), FP64 vector y Tensor.
- NVIDIA RTX Blackwell GPU Architecture (whitepaper) — RTX 5090: FP4 1 676 dense, FP8 838, FP16 419 con acumulación FP16 y 209,5 con FP32, FP64 a 1/64.
- NVIDIA Ada GPU Architecture (whitepaper) — RTX 4090: FP16 330,3 / 165,2, FP8 660,6, FP64 a 1/64.
- NVIDIA HGX platform — HGX B200: cifras por 8 GPU de FP4, FP8/FP6, FP16, TF32, INT8 y FP64.
- NVIDIA Ampere Architecture In-Depth — definición de TF32, BF16 en Tensor Cores.
- FP8 Formats for Deep Learning (arXiv 2209.05433) — E4M3 y E5M2: bits, rango, uso en pesos, activaciones y gradientes.
- OCP Microscaling Formats (MX) Specification v1.0 — MXFP4, MXFP6, MXFP8, escala E8M0 por bloque de 32.
- Introducing NVFP4 for Efficient and Accurate Low-Precision Inference — bloque de 16, escala E4M3, degradación frente a FP8.
- AMD Instinct MI355X — especificaciones — FP64 78,6, FP16 2,5 PFLOPS, FP8 5, MXFP6 y MXFP4 10,1 PFLOPS.
- AMD Instinct MI300X — especificaciones — FP64 81,7 vector / 163,4 matriz, TF32 653,7, FP8 2 614,9 dense.
- Inside NVIDIA Blackwell Ultra — B300: NVFP4 15 PFLOPS dense y recorte de FP64 e INT8.
- llama.cpp — tools/quantize/README.md — bits por peso, tamaño y tokens/s de Llama 3.1 8B por tipo de cuantización.
- bfloat16 floating-point format (Wikipedia) — estructura de bits y origen en Google Brain; cruce de los valores de la tabla de formatos.