Equipos para IA · Edge

NPUs, portátiles Copilot+ y edge: para qué sirven de verdad

Qué hace una NPU que no haga la GPU, por qué el techo de un portátil Copilot+ son sus 135 GB/s y no sus TOPS, qué modelos corren en ella de verdad y cómo se compara con Jetson, Hailo y Coral.

Una NPU no es una GPU pequeña. Es un bloque de silicio diseñado para hacer una sola cosa, multiplicar y acumular enteros de 8 bits, con la menor energía posible. En un portátil Copilot+ comparte la misma memoria LPDDR5X que la CPU y la GPU, y ese bus de 128 bits, no los TOPS del folleto, decide qué modelos puede ejecutar y a qué velocidad. Lo mismo vale, con otras cifras, para un Jetson, una Raspberry Pi con Hailo o un Coral: en el borde la pregunta no es cuánto calcula el chip, sino cuánto le llega.

Tres motores y una sola memoria

Un SoC de portátil de 2026 lleva tres motores de cálculo: CPU, GPU integrada y NPU, y los tres leen y escriben en la misma RAM soldada. Lo que distingue a la NPU no es la potencia bruta sino cómo la gasta. Una GPU es una máquina general de coma flotante: miles de ALU con planificadores, cachés, registros y unidades de textura que se pagan en vatios aunque el trabajo sea una convolución INT8 trivial. Una NPU es una malla de unidades MAC (multiplica y acumula) con memoria local junto a cada unidad, sin planificación dinámica y con el flujo de datos fijado por el compilador antes de arrancar. De ahí una eficiencia por operación que la GPU no alcanza en cargas pequeñas y repetitivas.

LPDDR5X-8448128 bits · 135 GB/s · hasta 64 GBCPU12 × Oryon · 3,8 GHzGPU Adreno4,6 TFLOPS FP32NPU Hexagon45 TOPS INT8compartidacompartidacompartida
Anatomía de un Snapdragon X Elite: tres motores sobre una única memoria LPDDR5X de 128 bits (fuente: product brief de Qualcomm vía src/data/cpus.json).

Las cifras del diagrama ya cuentan la historia. La GPU Adreno rinde 4,6TFLOPS en FP32; aunque sus ALU ejecutaran cuatro INT8 por cada FP32, rondarían los 18 TOPS. La NPU hace 45TOPS INT8 con una fracción del área y del consumo. Pero las dos beben del mismo grifo de 135GB/s. Cuando el modelo cabe en la memoria local de la NPU, manda la eficiencia. Cuando son gigabytes que hay que releer en cada paso, manda el grifo.

El mapa de NPUs en septiembre de 2026

Microsoft fijó el umbral Copilot+ en más de 40TOPS INT8 en la NPU sola. Las tres plataformas de 2024 lo pasaron por poco: Snapdragon X Elite 45, Lunar Lake 48, Ryzen AI 300 50. La segunda generación lo dobla en Qualcomm y lo mantiene en Intel: el Snapdragon X2 Elite declara 80TOPS INT8 (85 en los SKU X2E-90 y X2E-84) y el Core Ultra X9 388H de Panther Lake, 50TOPS en la NPU frente a 122 en su GPU Arc B390. Apple sigue publicando 38TOPS para el Neural Engine del M4 y no da cifra para el M5, cuyo salto está en los Neural Accelerators de la GPU, no en el ANE.

NPU y aceleradores edge: TOPS INT8

050100Snapdragon X2 Elite (X2E-84)85 TOPSSnapdragon X2 Elite Extreme80 TOPSRyzen AI Max+ 395 (XDNA 2)50 TOPSCore Ultra X9 388H (Panther Lake)50 TOPSCore Ultra 7 258V (Lunar Lake)48 TOPSSnapdragon X Elite (X1E-84)45 TOPSApple M4 Neural Engine38 TOPSHailo-8 (AI HAT+)26 TOPSHailo-8L (AI HAT+)13 TOPSCoral Edge TPU4 TOPSTOPS

Umbral Copilot+ PC: más de 40 TOPS en la NPU. Qualcomm publica 80 u 85 según SKU; Intel 50 para el NPU 5 de todos los Panther Lake.

TOPS INT8 declarados por el fabricante para la NPU sola (o el acelerador dedicado), sin sumar CPU ni GPU. Coral y Hailo son aceleradores externos (fuentes: fichas oficiales de Qualcomm, Intel, AMD, Apple, Hailo/Raspberry Pi y Google Coral).

Dos cosas saltan a la vista: casi todo se agolpa entre 40 y 85, y no por falta de silicio; y los aceleradores para Raspberry Pi y los Coral están un orden de magnitud por debajo y siguen siendo útiles. Las dos tienen la misma explicación, y no está en el chip sino en la memoria.

El techo real: la LPDDR5X compartida

Un portátil Copilot+ de 2024 mueve entre 120GB/s y 136,5GB/s (LPDDR5X-7500 a 8533 sobre 128 bits). Los de 2026 suben a 152-154 GB/s con LPDDR5X-9600, y el X2 Elite Extreme llega a 228GB/s gracias a un bus de 192 bits con la memoria en el propio encapsulado. Todo eso es entre siete y quince veces menos que una RTX 5090. Y ese ancho de banda hay que repartirlo: mientras la NPU decodifica un modelo, la CPU y la GPU siguen pintando la pantalla y ejecutando el navegador.

Ancho de banda: del Raspberry Pi a la RTX 5090

05001k1,5k2kRTX 5090 (GDDR7)1 792 GB/sM4 Max (512 bits)546 GB/sDGX Spark / Jetson Thor273 GB/sRyzen AI Max+ 395256 GB/sSnapdragon X2 Elite Extreme228 GB/sJetson AGX Orin204,8 GB/sCore Ultra X9 388H153,6 GB/sSnapdragon X2 Elite152 GB/sSnapdragon X Elite135 GB/sRaspberry Pi 517,1 GB/sGB/s

Portátiles Copilot+ de 128 bits: 120-154 GB/s. El X2 Elite Extreme usa 192 bits. Strix Halo y GB10, 256 bits.

Ancho de banda de memoria de equipos edge y de portátil frente a una GPU discreta, en GB/s (fuentes: fichas oficiales; Raspberry Pi 5 calculado a partir de LPDDR4X-4267 de 32 bits).

Con esa cifra se calcula el techo de cualquier modelo de lenguaje que la NPU intente ejecutar. Generar un token exige leer todos los pesos una vez; el tiempo mínimo es el tamaño del modelo dividido por el ancho de banda.

Techo de tokens por segundo (decode, batch 1)

tokens/s ≈ ancho de banda (GB/s) ÷ tamaño de los pesos (GB)

Snapdragon X Elite con Phi-4-mini a 4 bits: 135 ÷ 1,92 ≈ 70 tokens/s

Phi-4-mini tiene 3 840 millones de parámetros. A 4 bits por peso ocupa 3,84 × 0,5 = 1,92GB. Leerlos a 135GB/s tarda 14,2 ms: unos 70 tokens por segundo como máximo físico, si la NPU tuviera la memoria para ella sola y no perdiera nada en el camino. Microsoft mide «hasta 20 tokens/s» para Phi Silica, su modelo de ese tamaño cuantizado a 4 bits, en las NPU de Snapdragon X. El resto se va en activaciones a 16 bits, en la memoria compartida y en que la NPU no llega al ancho de banda pico del bus. Puedes repetir la cuenta para cualquier equipo en el estimador de tokens por segundo.

La misma cuenta explica el atasco de TOPS en el gráfico anterior. Decodificar un LLM requiere dos operaciones por byte leído. A 135 GB/s son 270 GOPS, el 0,6 % de los 45 TOPS del X Elite. Para que una NPU de 80 TOPS estuviera ocupada con un LLM necesitaría 40 TB/s de memoria, doce veces lo que tiene un H100. Los fabricantes no ponen más MAC porque no sirven de nada; los TOPS extra van destinados a otro tipo de carga.

Punto de cruce del roofline

intensidad de cruce (ops/byte) = pico (TOPS) × 10¹² ÷ ancho de banda (GB/s) × 10⁹ = TOPS ÷ GB/s × 1 000

X Elite: 45 TOPS ÷ 135 GB/s ≈ 333 ops por byte

Por debajo de 333 operaciones por cada byte leído, la NPU del X Elite está limitada por memoria; por encima, por cálculo. Un LLM en decode está en 2 ops/byte, 166 veces por debajo. Una red convolucional de visión con imágenes de 640 píxeles, que reutiliza cada peso cientos de veces por fotograma, sí supera el cruce. Ese es el trabajo para el que se dimensionan las NPU. El explorador roofline permite situar cualquier carga.

X Elite · techo físico70tok/s135 GB/s ÷ 1,92 GB
Phi Silica · medido20tok/sMicrosoft, NPU Snapdragon X
Primer token230msprompt corto, Phi Silica

Qué corre en la NPU y qué no

La NPU no acelera nada por sí sola. Corre lo que una aplicación le envía por una pila de software concreta, con el modelo cuantizado y compilado para ese hardware. En Windows la pila es Windows ML sobre ONNX Runtime, con un proveedor de ejecución por fabricante: QNN para Qualcomm, OpenVINO para Intel, Vitis AI para AMD; DirectML, el camino anterior, se apoya en la GPU. En macOS es Core ML, que decide por su cuenta qué capas van al Neural Engine y cuáles a la GPU. Un modelo FP16 genérico de Hugging Face no toca la NPU: corre en la GPU o en la CPU, que es lo que hacen hoy LM Studio, Ollama o llama.cpp en la mayoría de portátiles. Que el equipo sea Copilot+ garantiza que Windows usa la NPU; no dice nada de Photoshop, Resolve o tu runtime de LLM. Busca «NPU», «QNN», «OpenVINO» o «Core ML» en la documentación de tu software antes de pagar por ella.

Lo que sí va a la NPU, porque el sistema operativo o el fabricante lo han compilado a propósito:

  • Recall y la búsqueda semántica de Windows: embeddings de capturas de pantalla, un modelo pequeño ejecutado en segundo plano miles de veces al día. La carga donde los vatios importan más que la latencia.
  • Subtítulos en directo y traducción: reconocimiento de voz continuo con modelos de decenas de millones de parámetros.
  • Efectos de cámara y micrófono (Windows Studio Effects, Center Stage de Apple): segmentación y supresión de ruido a 30 fotogramas por segundo, la carga convolucional canónica.
  • Modelos de lenguaje pequeños: Phi Silica en Windows, el modelo en dispositivo de Apple Intelligence en macOS. Entre 1 000 y 4 000 millones de parámetros, pesos a 4 bits, contexto de 2 000 a 4 000 tokens. Resumen un correo o reescriben un párrafo; no programan.
  • Fotografía y vídeo: superresolución, relleno generativo y eliminación de fondo en los editores que hayan portado sus modelos, que no son todos.

Lo que no va, y no irá mientras el bus sea de 128 bits: un Llama 3.1 70B, un Qwen3 32B, un FLUX.1 de 12 000 millones de parámetros, cualquier entrenamiento o fine-tuning. Un 8B a 4 bits ocupa 4,1GB y su techo teórico en un X Elite son 33 tokens/s; con las pérdidas que muestra Phi Silica, la mitad. Para eso están la GPU discreta o un equipo de memoria unificada con bus de 256 o 512 bits.

Edge fuera del portátil: Jetson, Hailo y Coral

El «edge» industrial se rige por las mismas leyes con presupuestos de energía muy distintos. En un extremo, los módulos Jetson de NVIDIA: el mismo CUDA que una workstation, memoria LPDDR de 256 bits y potencia configurable. El AGX Orin de 64 GB declara 275 TOPS, que son 170 de la GPU con sparsity más 105 de dos aceleradores DLA, también con sparsity: 85TOPS INT8 dense reales en GPU sobre 204,8GB/s, entre 15 y 60 W. Su sucesor, el Jetson AGX Thor (módulo T5000), salta a Blackwell: «2 070 TFLOPS FP4 sparse», es decir 1 035TFLOPS FP4 dense, con 128GB de LPDDR5X de 256 bits a 273GB/s y entre 40 y 130 W. Es el mismo subsistema de memoria que el DGX Spark: el cálculo se multiplicó por doce entre generaciones y el ancho de banda, por 1,33.

Equipos edge y de memoria unificada frente a una GPU discreta de gama media. INT8 en Ryzen AI Max+ y M4 Max es la NPU / Neural Engine; en Jetson, la GPU dense; NVIDIA no publica INT8 ni FP16 del GB10 (fuente: src/data/gpus.json).
EquipoMemoria (GB)Ancho de banda (GB/s)INT8 (TOPS)FP16/BF16 dense (TFLOPS)TDP (W)
NVIDIA Jetson AGX Orin 64 GB642058542,560
NVIDIA DGX Spark (GB10 Grace Blackwell, 128 GB)128273——140
AMD Ryzen AI Max+ 395 (Strix Halo, Radeon 8060S, 128 GB)12825650—55
Apple M4 Max (GPU 40 núcleos, 128 GB)12854638——
GeForce RTX 507012672247124250

Equipos edge y de memoria unificada frente a una GPU discreta de gama media. INT8 en Ryzen AI Max+ y M4 Max es la NPU / Neural Engine; en Jetson, la GPU dense; NVIDIA no publica INT8 ni FP16 del GB10 (fuente: src/data/gpus.json).

En el otro extremo están los aceleradores de pocos vatios. El AI HAT+ de Raspberry Pi monta un Hailo-8 de 26TOPS o un Hailo-8L de 13TOPS, conectado por PCIe a una Raspberry Pi 5 cuya LPDDR4X de 32 bits mueve unos 17GB/s. El Coral de Google hace 4TOPS INT8 con 2W: 2 TOPS por vatio, con la limitación de que solo ejecuta modelos TensorFlow Lite cuantizados a enteros y que su memoria en chip obliga a modelos de unos pocos megabytes. Ninguno de los dos vale para un LLM, y ninguno lo pretende: su trabajo es correr una red de detección de objetos sobre una cámara a 30 fotogramas por segundo sin que la Pi se caliente, o clasificar el sonido de un micrófono en un dispositivo a pilas.

Coral: 4 TOPS ÷ 2 W = 2 TOPS/W · Jetson Thor: 1 035 TFLOPS FP4 ÷ 130 W ≈ 8 TFLOPS/W

La comparación de eficiencia engaña si no se mira la precisión: el Coral cuenta INT8 y el Thor, FP4, la mitad de bits y el doble de operaciones por vatio en el mismo silicio. La diferencia real está en lo que cabe: unos pocos megabytes de SRAM en chip (Google cita unos 8 MB para el Edge TPU) frente a 128 GB de LPDDR5X. Un modelo que no cabe en el acelerador se relee desde fuera en cada inferencia, y entonces la eficiencia del chip deja de contar.

Cómo decidir si te importa la NPU

Si tu trabajo es el que Windows o macOS ya hacen con la NPU (videollamadas, subtítulos, búsqueda local, redacción asistida), cualquier Copilot+ de 2024 lo cubre; los 80 TOPS del X2 solo añaden batería. Lo que sí cambia la experiencia es la RAM: 32 GB frente a 16 permiten tener un modelo de 4 000 millones de parámetros residente sin desalojar el navegador.

Si quieres ejecutar LLM en local en serio, la NPU no es el criterio. Lo son el ancho de banda y la capacidad: un Ryzen AI Max+ 395 con 128 GB a 256 GB/s, un M4 Max a 546 GB/s o una GPU discreta de 16-32 GB a 672-1 792 GB/s. Ahí el trabajo lo hace la GPU con cuantización Q4 o FP8 y la NPU se queda apagada. La calculadora de VRAM dice qué cabe; el comparador de GPUs, a qué velocidad.

Si diseñas un producto embebido, la cuenta es al revés: fija primero el presupuesto de energía y el modelo (¿cabe en la SRAM de un Coral, en un Hailo, o necesita los 128 GB de un Thor?) y solo después mira los TOPS.

Lo que debes recordar

  • La NPU es una malla de MAC INT8 con memoria local y sin planificación dinámica: eficiencia por operación en cargas pequeñas y repetitivas, no potencia bruta.
  • En un portátil los tres motores comparten LPDDR5X de 128 bits (120-154 GB/s; 228 en el X2 Elite Extreme). Ese bus decide qué LLM corre y a cuánto: Phi Silica a 4 bits, 70 tokens/s teóricos y 20 medidos.
  • La NPU solo trabaja si la aplicación la usa vía Windows ML / ONNX Runtime (QNN, OpenVINO, Vitis AI) o Core ML. Recall, subtítulos, cámara y SLM de 1-4B sí; LLM de 8B en adelante, difusión y entrenamiento, no.
  • En el edge pasa lo mismo: Jetson Thor multiplica por doce el cálculo del Orin y solo por 1,33 el ancho de banda; Hailo y Coral rinden porque el modelo cabe en su memoria en chip.

Para mirar en una ficha técnica

  • NPU: TOPS (INT8): comprueba que es INT8 dense y de la NPU sola. Trampa: «AI TOPS de plataforma» que suman CPU + GPU + NPU (126 en Ryzen AI Max+, 222 en Panther Lake X9).
  • Memoria: tipo, MT/s y bus: LPDDR5X de 128 bits son 120-154 GB/s; 192 bits, 228; 256 bits, 256-273. Trampa: el fabricante rara vez imprime los GB/s; calcúlalos con bits × MT/s ÷ 8 000.
  • Capacidad de RAM: soldada y no ampliable. 16 GB limitan a modelos de 4B; 64-128 GB permiten 30B-70B a velocidad moderada. Trampa: «AI PC» con 8 GB.
  • Pila de software: busca «Windows ML», «QNN», «OpenVINO», «Vitis AI» o «Core ML» en la documentación de tu aplicación. Trampa: si no aparece, la NPU no hará nada por ti.
  • Jetson y módulos edge: el pico va con sparsity, y en FP4 en Thor; divide entre dos para dense. Mira la potencia configurable y el ancho de banda LPDDR, no el titular.

Fuentes

  1. Qualcomm — Snapdragon X2 Elite product brief (PDF) — tabla de SKU: NPU Hexagon 80 u 85 TOPS INT8, LPDDR5x a 152 GB/s (128 bits) y 228 GB/s (X2E-96/94, 192 bits).
  2. Qualcomm — Snapdragon X Elite product brief (PDF) — NPU 45 TOPS INT8, LPDDR5X-8448 de 128 bits a 135 GB/s, Adreno 4,6 TFLOPS FP32 (vía src/data/cpus.json).
  3. Intel — Core Ultra X9 388H, especificaciones (ARK) — NPU Peak TOPS (Int8) 50, GPU Arc B390 122 TOPS INT8, LPDDR5X-9600, 25 W base / 80 W turbo.
  4. Microsoft Learn — Copilot+ PCs developer guide — requisito de más de 40 TOPS en la NPU, plataformas admitidas, acceso vía Windows ML / ONNX Runtime y cuantización a INT8.
  5. Microsoft — Phi Silica, small but mighty on-device SLM — cuantización de pesos a 4 bits y activaciones a 16 bits, «hasta 20 tokens/s», 230 ms al primer token, contexto 2k, ejecución en las NPU Snapdragon X.
  6. AMD — Ryzen AI Max+ 395, especificaciones — NPU XDNA 2 «hasta 50 TOPS», «hasta 126 TOPS» de plataforma, LPDDR5X-8000 de 256 bits (vía src/data/gpus.json).
  7. Apple — M4 Pro y M4 Max, nota de prensa — Neural Engine de 16 núcleos (38 TOPS en la familia M4), 546 GB/s en M4 Max (vía src/data/cpus.json).
  8. NVIDIA — Jetson Thor — T5000: 2 070 TFLOPS FP4 sparse, 128 GB LPDDR5X de 256 bits, 273 GB/s, 40-130 W.
  9. NVIDIA — Jetson AGX Orin technical brief (PDF) — 170 TOPS INT8 sparse en GPU + 105 en DLA, LPDDR5 de 256 bits a 204,8 GB/s, 15-60 W (vía src/data/gpus.json).
  10. Raspberry Pi — AI HAT+ — Hailo-8 26 TOPS y Hailo-8L 13 TOPS, desde 70 $.
  11. Google Coral — Edge TPU FAQ — 4 TOPS INT8 con 2 W (2 TOPS/W), solo modelos TensorFlow Lite cuantizados a enteros.
  12. Nootecnia — src/data/memory-tech.json — anchos de banda LPDDR5X-7500/8000/8533/9600 con sus ejemplos oficiales (Lunar Lake 136,5 GB/s, Panther Lake 153,6 GB/s, DGX Spark 273 GB/s).

Escribe para buscar en artículos, herramientas y glosario. Esc para cerrar.