La herramienta que facilita poner un NPU en FPGA — el mercado FPGA es el objetivo prioritario; ASIC es un objetivo a largo plazo
Define el NPU en YAML y hazlo funcionar en un FPGA real. Una pila NPU inference-first que con una sola hoja de spec valida, sintetiza y pone en marcha un NPU pequeño sobre FPGAs de la familia Zynq.
3 NPUs verificados en silicio sobre FPGA real. Con el mismo compilador, keyword spotting, diagnóstico industrial de fallos y un LLM pequeño (FFN-on-NPU) se han demostrado en silicio sobre una placa real (QMTECH XC7Z020, familia Zynq-7000) — no es simulación.
spec → compile → bitstream → FPGA real, desde una sola CLI. 145 operadores (18 grupos), cuantización INT4/INT8, 6 targets de placa y 15 subcomandos CLI públicos cubren todo el ciclo en el mismo flujo.
Mismo compilador, misma placa (QMTECH XC7Z020, Zynq-7000): 3 NPUs distintos sintetizados y medidos en silicio
DS-CNN + GRU de 16 capas + FC cuantizado en INT8. IP NPU de grafo completo (kws_npu_top) sintetizado a 90 MHz @ DSP 45% / BRAM 24%.
| Precision | 11/11 (coincidencia 100% CPU ↔ NPU) |
|---|---|
| Aceleracion | 8.07× vs CPU (3.17 ms/inferencia) |
| Streaming | 200 frames en 5.166 s · 38.7 inf/s |
Arranque xsdb de 6 etapas + UART: precisión 11/11 · aceleración 8.07× · confianza por palabra clave.
FFT de vibracion → 3×Conv1D + MaxPool + GAP + 2×FC en INT8. IP bearing_npu_top a 90 MHz @ DSP 86% / BRAM 12%.
| Precision | 40/40 (coincidencia 100% CPU ↔ NPU) |
|---|---|
| Aceleracion | 11.13× vs CPU (≈4 ms/inferencia, 252 inf/s) |
| Monitor en tiempo real | 200 ventanas · recall 100% · falsas alarmas 0% |
Demo 1 — Validación de precisión. Tabla de clasificación de 40 muestras de test (ciclos CPU/NPU por clase, aceleración 11.13×).
Demo 2 — Monitor en tiempo real. Stream de 200 ventanas (clase de fallo · confianza, recall 100% · 0 falsas alarmas).
nanoGPT 10.77M (D=384 · 6 capas, TinyShakespeare). Solo el FFN (fc1 → gelu → fc2) se descarga al NPU; el resto corre en ARM — configuracion hibrida L2 con un LLM corriendo en la XC7Z020.
| Verificacion | Coincidencia bit a bit 5/5 entre CPU y NPU |
|---|---|
| Recursos | DSP 9% · BRAM 2% · LUT 17% (solo FFN) |
| Significado | Demuestra que es viable particionar la inferencia de un LLM en una placa Zynq-7000 |
Demo 1 — Identidad bit a bit. 5 prompts × 16 chars — verificación de coincidencia bit a bit 5/5 CPU↔NPU.
Demo 2 — Stream en vivo. Generación de 50 chars del prompt ROMEO — inferencia en vivo híbrida FFN-on-NPU.
※ Los tres proyectos son resultados sobre silicio real (no simulacion), sintetizados tal cual los emite el compilador de EulerNPU. Placa: QMTECH XC7Z020 CLG484-1 (Zynq-7000), reloj de PL 90–100 MHz, PS ARM Cortex-A9. El mercado FPGA es en sí mismo el objetivo prioritario, y el mismo flujo del compilador se extiende a objetivos ASIC como paso a largo plazo.
Sobre los 3 verificados en silicio, 4 dominios de ejemplo en experimentación con el mismo compilador
Lectura en tiempo real de frames de cámaras edge con un VLM pequeño — detección/clasificación de anomalías y generación de texto de resumen. Grafo de spec con Vision Encoder + Cross Attention + head LLM.
Perfil de SoC para inferencia de percepción y política de baja latencia en humanoides y brazos robóticos. Combinación de Vision Encoder + Multimodal + head de política, con compresión de caché KV incluida.
Stack de percepción vehicular — ejemplo de spec que utiliza BEV Projection multi-cámara + PointCloud + Trajectory Predict del grupo de operadores Autonomy.
Perfil de inferencia on-device alineado con el dominio automotriz de EulerAtlas — simulación de red de política con el perfil de placa ax1_sim.
* Los 4 ejemplos anteriores son demos de referencia para verificar la cobertura del compilador y del simulador. La verificación real en silicio se limita a los 3 anteriores (KWS · Bearing · nanoGPT).
FPGA como mercado objetivo prioritario. El mismo flujo del compilador se extiende a ASIC como paso a largo plazo.
145 operadores, 10 DType, desde spec.yaml hasta la inferencia en FPGA
Sistematización en 18 grupos de todas las operaciones necesarias para la inferencia NPU. Cobertura de arquitecturas recientes — attention eficiente (FlashAttention · GQA), vision encoder, MoE/Sparse, Diffusion, Speculative Decoding.
| Core Math | MatMul, Add, Mul, Div, Sqrt y otras operaciones matematicas basicas |
|---|---|
| Activation | ReLU, GELU, SiLU, Sigmoid, Softmax, etc. |
| Normalization | LayerNorm, RMSNorm, BatchNorm, GroupNorm |
| Conv/Vision | Conv2D, DepthwiseConv, Pool, Resize, Patch |
| Sequence/Attention | ScaledDotProduct, MultiHeadAttention, RoPE, ALiBi |
| Efficient Attention NEW | FlashAttention, SlidingWindowAttention, MultiQueryAttention(GQA) |
| MoE/Sparse | TopKRouter, ExpertDispatch, LoadBalanceLoss |
| Recurrent | LSTM, GRU, SRU |
| Graph | Concat, Split, Reshape, Transpose, Gather, Scatter |
| Multimodal | CrossAttention, VisionProjection, AudioMel |
| Vision Encoder NEW | PatchEmbed, ClsTokenPrepend, ImageNorm |
| Diffusion NEW | TimestepEmbed, NoiseSample, DDIMStep, CFGScale, FlowMatchStep |
| Speculative Decoding NEW | TokenAcceptance, DraftVerify, PrefixCacheLookup/Store |
| Quantization | Quantize, Dequantize, FakeQuantize, PackInt4/UnpackInt4 |
| Mamba/SSM | SelectiveScan, Discretize, SSMConv |
| Cache Compress | KVCacheCompress, SlidingWindow, H2O |
| Autonomy | PointCloud, BEVProject, TrajectoryPredict |
Se clasifican en 3 niveles segun los requisitos de precision y rendimiento.
| Tier 0 (obligatorio) | fp32, int32 — soportados en todos los operadores |
|---|---|
| Tier 1 (recomendado) | fp16, bf16, int8, uint8 — soportados en la mayoria de operadores |
| Tier 2 (extendido) | int16, int4, fp8_e4m3, fp8_e5m2 — operadores especificos |
| cpu_ref | Referencia NumPy del host (ejecucion inmediata sin dependencias) |
|---|---|
| npu_sim | Simulacion funcional + traza de ejecucion + estimacion de ciclos/MAC/latencia por operador |
| zynq_ps | Ejecucion en el ARM PS de Zynq |
| zynq_pl_stub | Analisis/emulacion del offload a la PL del FPGA |
| Zynq-7000 | XC7Z020 (verificado en silicio, AXI-Lite MMIO) |
|---|---|
| Zynq UltraScale+ | ZU3EG · ZU7EV · ZU9EG (target INT4 / alto rendimiento) |
| Kria SOM | XCK26 / KV260 (kit de desarrollo para IA en el borde) |
| ax1_sim | Perfil de inferencia on-device para automoción (simulación) |
Desde la especificacion YAML hasta el archivo .npuart desplegable
El archivo de especificacion YAML declarativo se valida, transforma a IR y optimiza antes de compilarse al formato .npuart (NPU Archive).
| Entrada | spec.yaml — definicion declarativa del grafo computacional |
|---|---|
| Validacion | Compatibilidad de operadores, tipos de datos, inferencia de formas |
| IR | Representacion intermedia — optimizacion de grafos, fusion de operadores |
| Salida | Binario .npuart — cargable directamente en el runtime |
Los archivos .npuart compilados se pueden ejecutar en el simulador o en hardware FPGA Zynq-7020.
| Simulador | Simulacion con precision de ciclo, soporte de analisis de rendimiento |
|---|---|
| FPGA | Runtime Zynq-7020 AXI-Lite MMIO |
| Perfilado | Latencia por capa, ancho de banda de memoria, reporte de utilizacion |
Unico punto de entrada eulernpu — 15 subcomandos cubren todo el flujo de trabajo (con soporte --lang ko|en|zh|ja|es)
| Comando | Descripcion |
|---|---|
eulernpu info | Muestra la plataforma, los operadores soportados y la informacion de dtype |
eulernpu validate | Valida el grafo de operadores de spec.yaml (JSON-Schema + 23 reglas semanticas) |
eulernpu migrate-spec NEW | Migracion automatica de specs 0.4 → 0.5 |
eulernpu compile | Compila spec.yaml a un artefacto .npuart |
eulernpu run | Ejecuta el artefacto .npuart en los backends cpu_ref/npu_sim/zynq |
eulernpu sim | Simulacion funcional + estimacion de ciclos/MAC/latencia |
eulernpu generate NEW | Generacion autorregresiva de tokens (KV cache) |
eulernpu quantize NEW | Cuantizacion de pesos INT8/INT4 (--weight-bits 4) |
eulernpu profile | Perfilado del tiempo de ejecucion y uso de memoria por operador |
eulernpu explain | Offload a PL + plan de memoria, visualizacion del schedule del grafo |
eulernpu board smoke | Verifica la conexion de la placa FPGA y el funcionamiento basico |
eulernpu calibrate | Recoleccion y aplicacion de datos de calibracion para cuantizacion |
eulernpu benchmark | Ejecuta benchmarks de latencia/throughput |
eulernpu replay | Reproduce una traza de ejecucion guardada |
eulernpu compress-cache | Aplica y valida la configuracion de compresion de KV cache |
Filosofia central de diseno de EulerNPU
Archivos de especificacion YAML definen el grafo computacional — sin necesidad de codigo de bajo nivel, el compilador maneja todas las optimizaciones.
La matriz de capacidades verifica tipos de datos y restricciones de hardware de cada operador antes de compilar, previniendo errores en tiempo de ejecucion.
Verifique la correctitud y el rendimiento con el simulador de precision de ciclo antes de desplegar en FPGA.
Aprenda EulerNPU rapidamente con guias paso a paso
Tutoriales proximamente.
Instale EulerNPU y compile su primer modelo
Python 3.10+, NumPy
Opcional: importacion ONNX, placas Zynq-7000 / UltraScale+ (target FPGA)
Desde especificacion YAML hasta despliegue FPGA, con una sola CLI.
Comenzar en GitHub Contactenos