🔌 Hardware: la realidad física
Todo lo que hace un LLM —cada multiplicación, cada token— se traduce al final en señales eléctricas viajando por cables de silicio a velocidades finitas. Esta página explica qué hay físicamente dentro de la GPU, por qué los datos tardan lo que tardan, y cómo hemos llegado hasta aquí.
🕰️ De los píxeles a los parámetros
La GPU que tienes en casa ejecuta hoy, en segundos, lo que hace 5 años requería un clúster de cientos de miles de dólares. Así es cómo pasamos de renderizar triángulos a ejecutar conversaciones con inteligencias artificiales.
2007 — CUDA: la GPU se vuelve programable
NVIDIA lanza G80 (GeForce 8800 GTX): la primera GPU que se puede programar para algo que no sean gráficos. Nace el concepto GPGPU (General-Purpose GPU). 128 núcleos sombra → 128 CUDA cores. Nadie imagina aún que estas tarjetas de videojuegos acabarán conversando con humanos.
2012 — AlexNet: el punto de inflexión
Alex Krizhevsky entrena una red neuronal profunda en 2 GTX 580s y destroza el campeonato ImageNet. Por primera vez, una GPU demuestra que puede hacer algo que una CPU no puede: ML a escala. Las GPUs pasan de «cosas para gamers» a «el motor de la inteligencia artificial».
2017 — El año que cambió todo: Transformer + Tensor Cores
Dos revoluciones en paralelo. Google publica «Attention Is All You Need» (Transformer). NVIDIA lanza la V100 con Tensor Cores: hardware específico para multiplicar matrices en 1 ciclo (antes: 16 ciclos en CUDA Cores). La arquitectura Transformer resulta ser increíblemente paralelizable en GPUs. Es el Big Bang de los LLMs.
2020 — GPT-3: la era del clúster
GPT-3 (175B parámetros) solo es ejecutable en clústers empresariales de cientos de GPUs. La brecha entre lo que la investigación descubre y lo que una persona puede ejecutar en casa es máxima. Si no trabajas en OpenAI/Google/Meta, los LLMs son algo que usas por API, no algo que ejecutas.
2023 — Llama + cuantización: la democratización
Meta lanza Llama (7B, 13B, 65B): modelos abiertos que cualquiera puede descargar. Aparece llama.cpp (cuantización en CPU), GPTQ, AWQ. Por primera vez, un modelo de capacidad real (7B) cabe en una GPU de consumo con cuantización. El AI local deja de ser un sueño.
2024-2026 — La era del AI local
RTX 5090 con 48+ GB VRAM. Apple M3 Ultra con 192 GB de memoria unificada. Modelos 100B+ que caben en una GPU gracias a FP4/NF4. El hardware de consumo alcanza lo que en 2020 requería un datacenter de $100k. La inferencia local es mainstream: tu GPU de $1600 ejecuta lo que hace 5 años necesitaba un clúster de $100,000.
🎯 Por qué esto importa para lo que viene
Cada uno de estos hitos ha sido un salto en lo que una persona puede ejecutar en su propio hardware. La razón por la que hoy puedes descargar un modelo, abrir una terminal y hablar con una inteligencia artificial en tu propia máquina no es solo la investigación en algoritmos. Es también —y sobre todo— que el hardware ha corrido para alcanzar a los modelos. Sin la evolución de las GPUs, los LLMs serían solo cosa de datacenters.
La evolución en números
| Hito | GPU | TFLOPS (FP16) | VRAM | BW (GB/s) | Consumo |
|---|---|---|---|---|---|
| 2007 — CUDA | G80 | ~0.3 | 768 MB | 86 | 177 W |
| 2012 — AlexNet | GTX 580 | ~1.5 | 1.5 GB | 192 | 244 W |
| 2017 — Transformer | V100 | 125 | 16/32 GB | 900 | 300 W |
| 2020 — GPT-3 | A100 | 312 | 40/80 GB | 2,039 | 400 W |
| 2023 — Llama 2 | RTX 4090 | 82 | 24 GB | 1,008 | 450 W |
| 2026 — Era local | RTX 5090 | ~200 | 48 GB | ~1,792 | ~600 W |
💡 Crecimiento 2007 → 2026:
• TFLOPS: 0.3 → ~200 → ~670× más
• VRAM: 0.75 GB → 48 GB → ~64× más
• Ancho de banda: 86 → ~1,792 GB/s → ~21× más
La capacidad de cómputo ha crecido 10× más rápido que el ancho de banda de memoria. Esa divergencia es el Memory Wall, y es la razón por la que la inferencia de LLMs es memory-bound (lo veremos en detalle más abajo).
El Memory Wall: la ley que define el hardware de IA
Desde ~2005, los chips han duplicado su capacidad de cómputo cada ~2 años (Ley de Moore para transistores + arquitecturas paralelas). Pero el ancho de banda de memoria solo crece ~15% anual. El resultado es que cada año la brecha entre lo que la GPU puede calcular y lo que puede alimentar de datos es mayor.
Evolución del gap compute vs. memory bandwidth:
TFLOPS BW (GB/s) FLOP/byte
2007 (G80): 0.3 86 3.5 ← compute-bound
2012 (GTX 580): 1.5 192 7.8 ← compute-bound
2017 (V100): 125 900 139 ← empieza a ser MB
2020 (A100): 312 2,039 153 ← memory-bound
2023 (RTX 4090): 82 1,008 81 ← memory-bound
2026 (RTX 5090 est.): 200 1,792 112 ← memory-bound
La inferencia de un LLM típico tiene intensidad aritmética ~1-2 FLOP/byte.
Por debajo de ~50 FLOP/byte, eres memory-bound.
Todas las GPUs modernas están muy por debajo de ese umbral.
🔴 La consecuencia inevitable: La evolución del hardware de IA no es una historia de «cada año chips más rápidos».
Es la historia de cómo la industria ha intentado —con éxito limitado— alimentar de datos a unos chips que cada vez calculan más rápido.
HBM (High Bandwidth Memory), GDDR7, memoria unificada (Apple), interposers de silicio… todas son soluciones al mismo problema: el Memory Wall.
Y la solución más efectiva para sortearlo hoy no es un chip más rápido: es mover menos datos.
Por eso la cuantización (FP16 → FP8 → FP4) es la herramienta más poderosa para acelerar LLMs.
🔌 El mapa físico de la GPU
Antes de entender los ciclos y los tiempos, necesitas saber qué hay físicamente dentro de una GPU. Esta es la jerarquía completa, desde el chip hasta el bus.
Arquitectura física de una GPU (RTX 4090)
Aquí se hacen las cuentas. Contiene 128 SM con CUDA Cores y Tensor Cores.
Aquí viven los pesos del modelo. 12 chips alrededor del chip GPU.
Los cables que conectan VRAM con chip. Por aquí viajan los pesos.
⏱️ Línea de tiempo: cargar 4 bytes desde VRAM
Total: ~202 ciclos ≈ 91 ns. Solo 2 ciclos (~1%) se usan realmente para multiplicar.
⏱️ Ciclos, distancias y latencias
Ahora que sabes qué hay dentro, vamos a ver cuánto tarda cada cosa y por qué. El concepto clave: un ciclo de reloj es el latido de la GPU, y cada operación cuesta una cantidad de latidos distinta.
⏱️ El ciclo de reloj: el latido de la GPU
¿Qué es un ciclo de reloj? Es un pulso eléctrico que sincroniza todo el chip. Como un metrónomo para músicos o el ritmo cardiaco para el cuerpo. En cada pulso, el chip puede avanzar un paso.
Un ciclo es un "tic" del reloj:
⬆️ subida del pulso | ⬇️ bajada del pulso | 1 ciclo completo
Sumar dos números 1 + 1 = 2
Tarda 1 ciclo. Es la operación más simple. Un solo paso.
Multiplicar 123 × 456 = 56,088
Tarda ~4 ciclos. Tiene varios pasos internos: multiplicar dígito a dígito y sumar parciales.
Leer un peso desde VRAM
Tarda ~200 ciclos. No es una sola operación: es un viaje de ida y vuelta con escalas.
🔄 Así se ven en una línea de tiempo:
⚠️ Diferencia de escala: Mientras la VRAM hace 1 sola lectura (200 ciclos), el núcleo podría haber hecho 200 sumas o 50 multiplicaciones. La VRAM es el cuello de botella porque el chip se pasa 200 ciclos esperando a que llegue 1 dato.
Muestra cómo avanza cada operación ciclo a ciclo
🏭 Analogía: la fábrica y la cinta transportadora
Imagina una fábrica con una cinta transportadora que avanza un paso cada segundo (1 paso = 1 ciclo).
• Sumar es como poner un tornillo en una caja: se hace en 1 paso, la caja sigue adelante. ✅
• Multiplicar es como montar 4 piezas: necesitas 4 pasos. En cada paso, la pieza se mueve a la siguiente estación de montaje. ✅
• Leer de VRAM es como pedir un repuesto al almacén externo: el trabajador tiene que ir al almacén (paso 1-10), el almacenero busca el repuesto (paso 11-90), el trabajador vuelve (paso 91-140), y lo lleva a la línea de montaje (paso 141-200). Durante esos 200 pasos, la fábrica está parada esperando el repuesto. 🔴
Esa espera es el cuello de botella de los LLM. Cada multiplicación de matrices necesita un "repuesto" (peso) del almacén (VRAM), y tarda 200 pasos en llegar. La fábrica (GPU) pasa el 99% del tiempo esperando repuestos.
Tiempos de acceso en detalle
| Operación | Ciclos | Tiempo real | Distancia equivalente |
|---|---|---|---|
| 1 ciclo de reloj | 1 | 0.45 ns | 13.5 cm (luz) / 9 cm (señal) |
| Suma de enteros | 1 | 0.45 ns | — |
| Multiplicación FP32 | ~4 | 1.8 ns | — |
| Tensor Core matmul 4×4 | 1 | 0.45 ns | — |
| Leer de L1 Cache | ~10 | 4.5 ns | 0.4 mm (señal dentro del chip) |
| Leer de L2 Cache | ~50 | 22.5 ns | 2 mm (a través del chip) |
| Leer de VRAM (GDDR6X) | ~200 | 90 ns | ~2 cm (ida+vuelta + latencia chip) |
| Leer de RAM CPU (DDR5) | ~500 | 225 ns | ida+vuelta PCIe + RAM latencia |
| Leer de SSD NVMe | ~1,000,000 | 0.45 ms | controlador + bus PCIe + flash |
Leer de VRAM cuesta ~200× más que una multiplicación. Por eso mover datos es el cuello de botella.
Los pesos no caben en la caché
🟢 Resumen visual de la jerarquía:
Registros (32 MB) → están DENTRO de cada SM, son la memoria más rápida (~1 ciclo). Aquí se ponen los números justo antes de multiplicarse.
L1 Cache (16 MB) → está DENTRO del chip, compartida entre unos pocos SM. Si los datos están aquí, se leen en ~10 ciclos.
L2 Cache (72 MB) → está DENTRO del chip, compartida globalmente. Trampolín antes de ir a VRAM. ~50 ciclos.
VRAM (24 GB) → está FUERA del chip, conectada por el bus. Aquí viven los pesos. ~200 ciclos.
Los pesos del modelo NO CABEN ni en registros, ni en L1, ni en L2. Solo caben en VRAM. Por eso cada multiplicación requiere leer de VRAM, y eso cuesta ~200 ciclos.
Física de la señal en el chip
Una señal eléctrica en un conductor de cobre viaja a aproximadamente el 70% de la velocidad de la luz en el vacío (la velocidad real depende de la permitividad del material dieléctrico alrededor del conductor):
Velocidad de la luz: 299,792,458 m/s ≈ 30 cm/ns
Velocidad en PCB (cobre): ~70% ≈ 21 cm/ns
Velocidad en silicio (chip): ~50% ≈ 15 cm/ns
Reloj GPU (2.23 GHz):
1 ciclo = 0.45 ns
Distancia recorrida en 1 ciclo:
- En PCB: 21 cm/ns × 0.45 ns ≈ 9.5 cm
- En silicio: 15 cm/ns × 0.45 ns ≈ 6.8 cm
Esto significa:
- Señal cruzando el chip (3 cm) ≈ 0.2 ns ≈ 0.4 ciclos
- Señal chip→VRAM (2 cm) ≈ 0.1 ns ≈ 0.2 ciclos
- Pero la VRAM tarda ~90 ns por su latencia interna (no por distancia)💡 Mito: «la velocidad de la luz es el límite» — Es cierto, pero en una GPU el límite no es la distancia física (2 cm) sino la latencia de los chips de memoria. Cada chip GDDR6X tiene su propia lógica interna: decodificar direcciones, activar filas en la matriz de celdas, leer los condensadores, amplificar la señal, y enviarla de vuelta. Eso lleva ~80 ciclos. Es como un camión que tarda 10 minutos en cargarse aunque el viaje sean 2 minutos.
🚛 El viaje: de VRAM a los núcleos
¿Qué es lo que viaja exactamente?
Lo que viaja desde VRAM a los núcleos son los pesos (parámetros). Los pesos son números que se multiplican. El modelo tiene miles de millones de ellos.
❓ Pregunta clave: «¿Por qué los pesos tienen que viajar si solo se van a multiplicar?»
✅ Respuesta: Porque la multiplicación no ocurre donde están guardados los pesos. El Tensor Core que hace la multiplicación está dentro del chip GPU. El peso está en VRAM, fuera del chip.
Es como tener los números en una libreta y la calculadora en la mesa. No puedes multiplicar dentro de la libreta. Tienes que leer el número de la libreta, teclearlo en la calculadora, y entonces obtienes el resultado.
La «libreta» es la VRAM. La «calculadora» es el Tensor Core. El «movimiento de tus ojos y manos» es el bus de memoria.
El flujo, paso a paso
El prompt se tokeniza y se carga en VRAM
«La capital de Francia es» → [123, 456, 789, 101] → 4 vectores de 4096 números
Se lee W_Q desde VRAM → a los núcleos
33 MB de pesos viajan por el bus. Tarda ~0.03 ms.
Se multiplica: activaciones × W_Q = Q
Esto ocurre en los Tensor Cores. Tarda ~0.001 ms. Los pesos se descartan de la caché.
Se lee W_K desde VRAM
Hay que volver a VRAM a por la siguiente matriz. No se guardó porque no cabía en caché.
Esto se repite para W_K, W_V, W_O, W_gate, W_up, W_down
Cada una requiere leer ~33-100 MB de pesos desde VRAM. 7 matrices por capa. 32 capas. Luego otra vez para el siguiente token.
💡 ¿Cuántos datos viajan en total por el bus?
Para generar 1 token con un modelo 7B en FP16:
• 32 capas × 7 matrices × ~33 MB = ~7.4 GB leídos desde VRAM
• A 1008 GB/s: ~7.4 ms de ida y vuelta constante de datos
Para 100 tokens de respuesta: ~740 GB de datos viajando por el bus
Pero la VRAM sigue teniendo los mismos 14 GB de pesos. No se gastan. Solo se leen.
Cálculo detallado: datos por capa
| Operación | Matriz | Params | Bytes (FP16) | Lecturas |
|---|---|---|---|---|
| Attention Q | d_model × d_model | 16.7M | 33.5 MB | 1× |
| Attention K | d_model × d_model | 16.7M | 33.5 MB | 1× |
| Attention V | d_model × d_model | 16.7M | 33.5 MB | 1× |
| Attention O | d_model × d_model | 16.7M | 33.5 MB | 1× |
| FFN gate | d_model × d_ff | 45.1M | 90.2 MB | 1× |
| FFN up | d_model × d_ff | 45.1M | 90.2 MB | 1× |
| FFN down | d_ff × d_model | 45.1M | 90.2 MB | 1× |
| Total por capa | 202M | 404 MB | 7 lecturas | |
| Total 32 capas | 6.5B | 12.9 GB | 224 lecturas | |
Pero espera — hay 6.5B parámetros, no 14 GB
En el modelo de 7B hay ~6.7B parámetros (no 7B exactos). En FP16, 6.7B × 2 bytes = 13.4 GB. La tabla de arriba suma ~12.9 GB, que son los pesos de las capas. El resto (~0.5 GB) es embedding y LM head, que solo se leen una vez al principio y al final.
💡 Por cada token generado, el bus mueve ~13 GB de pesos.
Pero no todos a la vez. Son 224 viajes individuales (7 matrices × 32 capas), cada uno moviendo 33-90 MB. El bus es una autopista por la que viajan constantemente estos datos, como una cinta transportadora de números.
Es como tener que leer 224 capítulos de un libro, y cada capítulo requiere ir a la estantería a buscar el libro (VRAM), abrirlo por la página correcta, leerla, y dejarlo.
Ancho de banda efectivo vs. teórico
El ancho de banda teórico de 1008 GB/s es el límite máximo, pero en la práctica no se alcanza porque:
- Overhead de dirección: cada lectura de VRAM requiere enviar una dirección de memoria antes de recibir los datos
- Row activation: la VRAM organiza los datos en filas y columnas. Cambiar de fila cuesta tiempo extra
- Bank conflicts: múltiples peticiones a la misma partición de VRAM se serializan
- Protocol overhead: la señal tiene que ser codificada/decodificada (GDDR6X usa PAM4, que codifica 2 bits por símbolo)
En benchmarks reales (como llama.cpp), una RTX 4090 suele alcanzar ~80-85% del ancho de banda teórico, es decir, ~800-850 GB/s efectivos.
🚀 Demo: el viaje completo del modelo
Una animación interactiva que muestra todo lo que has aprendido: cómo los pesos se cargan en VRAM, cómo viajan a los núcleos para procesar el texto, y por qué cada nueva palabra requiere repetir el proceso desde cero.
🚀 El viaje completo del modelo
Sigue el recorrido de los datos desde que el modelo está en disco hasta que se genera cada nueva palabra.
🔵 Fase 1: Cargar modelo — Los pesos (parámetros) viajan desde el SSD a la VRAM a través del PCIe. Un modelo de 7B en FP16 pesa ~14 GB. Tarda unos segundos en cargarse completamente. Una vez en VRAM, los pesos están listos para ser leídos por la GPU.
🐢 El cuello de botella: memory-bound
La inferencia es mover datos, no calcular
Ahora que sabemos qué viaja (pesos), dónde (bus), y por qué tarda (~200 ciclos por viaje), podemos entender por qué la inferencia está limitada por la memoria, no por la potencia de cálculo.
🧮 Capacidad de cálculo (TFLOPS)
82 TFLOPS = 82 billones de multiplicaciones por segundo
Pero cada multiplicación necesita sus operandos. Si los operandos tardan 200 ciclos en llegar, el núcleo se para y espera.
🚛 Capacidad de transporte (BW)
1008 GB/s = 1 terabyte de datos por segundo pueden viajar por el bus
El modelo 7B pesa 14 GB. Cada token requiere leer ~13 GB. 1008 / 13 ≈ 77 tokens/s. Ese es el límite.
🔴 El dato que lo explica todo:
De cada 200 ciclos que tarda en leerse un peso de VRAM, solo ~2 ciclos se usan para multiplicar. El 99% del tiempo la GPU está esperando a que lleguen datos desde la VRAM.
Es como un chef superrápido (puede cortar una cebolla en 0.1 segundos) pero que tiene que ir a la despensa a buscar cada ingrediente, y la despensa está al otro lado de la cocina. Pasa el 99% del tiempo caminando y el 1% cortando.
Cálculo exacto: tiempo de inferencia
Modelo 7B FP16 en RTX 4090 (1008 GB/s, 82 TFLOPS)
PESOS A LEER POR TOKEN:
Attention (Q,K,V,O): 4 × 33.5 MB = 134 MB
FFN (gate,up,down): 3 × 90.2 MB = 270 MB
Total por capa: 404 MB
32 capas: 12.9 GB
+ Embedding + LM Head: ~0.5 GB
------------------------------------------
Total leído por token: 13.4 GB
TIEMPO DE CARGA (1008 GB/s):
13.4 GB / 1008 GB/s = 13.3 ms
TIEMPO DE CÓMPUTO (82 TFLOPS):
FLOPs por token (7B): ~14 GFLOP
14 GFLOP / 82 TFLOP/s = 0.17 ms
TIEMPO TOTAL ESTIMADO:
13.3 + 0.17 ≈ 13.5 ms/token
→ ~74 tokens/s
En realidad con overheads y KV cache: ~60-70 tokens/s¿Y si cuantizamos?
Modelo 7B Q4_K_M en RTX 4090 (1008 GB/s)
Pesos a leer: 6.7B × 0.5 bytes = 3.4 GB
Tiempo de carga: 3.4 / 1008 = 3.4 ms
Tiempo de cómputo: ~0.05 ms (matmuls más pequeñas)
Total: ~3.5 ms/token → ~290 tokens/s
En la práctica: ~200-250 t/s (algo de overhead de de-cuantización)🟢 Moraleja: La cuantización acelera 4× porque reduces los datos que viajan por el bus en 4×. No porque las multiplicaciones sean más rápidas (de hecho, multiplicar INT4 puede ser más lento que FP16 en Tensor Cores). El cuello de botella siempre es el bus.
Roofline Model
El modelo Roofline clasifica cualquier operación según su intensidad aritmética (FLOPs por byte movido):
Intensidad aritmética = FLOPs / Bytes desde VRAM
Para inferencia de 1 token en 7B FP16:
Intensidad = 14 GFLOP / 13.4 GB ≈ 1.0 FLOP/byte
Límites de la RTX 4090:
Techo de cómputo: 82 TFLOPS
Techo de memoria: 1008 GB/s
Rendimiento real = min(82 TFLOP, 1008 GB/s × 1.0 FLOP/byte)
= min(82 TFLOP, 1.0 TFLOP)
= 1.0 TFLOP ← memory bound!
La GPU solo usa el 1.2% de su capacidad de cómputo.¿Cómo escapar del memory-bound?
- Batching: procesas N prompts a la vez. Los pesos se leen 1 vez y se reutilizan para N prompts. La intensidad aritmética sube a N × 1.0 FLOP/byte. Con batch=512, pasas a 512 FLOP/byte → compute-bound.
- Cuantizar: reduces los bytes/peso. Mueves menos datos por el mismo bus.
- Speculative Decoding: generas K tokens baratos con un modelo pequeño, verificas con el grande en paralelo.
- Prompt Caching: reutilizas la KV Cache de prompts repetidos sin tener que reprocesarlos.
📋 Resumen: respuestas a tus preguntas
❓ «¿Los pesos caben en los núcleos de cálculo?»
No. Los núcleos tienen registros (32 MB en total). Los pesos de una capa son ~400 MB. Los pesos viven en VRAM (24 GB).
❓ «¿Si el modelo pesa 24 GB, esos 24 GB se mueven por el bus?»
No se mueven de golpe. Viajan por el bus en fragmentos, capa por capa, matriz por matriz. Por cada token se mueven ~13 GB (el modelo completo), pero en 224 viajes individuales a lo largo de ~13 ms.
❓ «¿Por qué 200 ciclos si la distancia son 2 cm?»
Porque la VRAM tiene su propia latencia interna (~80 ciclos para buscar el dato dentro del chip). La distancia física solo explica ~10-20 ciclos. El resto es burocracia del protocolo de memoria.
❓ «¿Qué es lo que se mueve por la autopista?»
Los pesos (parámetros del modelo). Son números que viajan desde VRAM a los Tensor Cores para ser multiplicados. ~13 GB por token en FP16, ~3.5 GB por token en Q4.
❓ «¿Cómo hemos llegado hasta aquí?»
Desde CUDA en 2007 hasta hoy: los TFLOPS se han multiplicado por ~670, la VRAM por ~64, el ancho de banda por ~21. Pero el cómputo ha crecido 10× más rápido que la memoria — por eso hoy la inferencia está limitada por el bus, no por los núcleos.
🚀 Conclusión final
La inferencia de LLMs no es un problema de potencia de cálculo (tenemos de sobra). Es un problema de transporte de datos. La GPU pasa el 99% del tiempo esperando a que los pesos lleguen desde la VRAM. Cuantizar = reducir la carga a transportar = 4× más rápido.