Flujos de trabajo para FPGA con IA local
Mete un modelo de IA en tu flujo de FPGA. En tu GPU, sin que el código salga de tu red.
Monta en tu propia máquina un servidor de inferencia, un agente que respeta tu guía de estilo Verilog y un pipeline de GitLab en el que un modelo local lee los informes de Yosys y los fallos de iverilog en cada commit. Sin pagar por token y sin subir una línea de código a ningún sitio.
Mira gratis el módulo 0
La presentación completa del curso: de qué va, de qué no va, qué hardware usamos y qué vas a ver en cada módulo.
El problema
Tu código no puede salir de la empresa. El de tu cliente, todavía menos. Así que Copilot, Claude o ChatGPT están fuera de la mesa, aunque todo el mundo hable de ellos.
Y cuando buscas cómo montarlo en local, encuentras dos cosas: tutoriales de «instala Ollama y chatea» que se quedan en la superficie, y promesas de «tu propio Claude en casa» que se desmoronan en cuanto le pasas un módulo de verdad.
Ninguna de las dos te dice lo que importa: qué cabe en tu tarjeta, qué modelo sirve para qué, y dónde aporta de verdad un modelo local en un flujo de FPGA.
Lo que este curso no te va a vender
Un modelo que cabe en una tarjeta de escritorio no va a escribir tu controlador de memoria de una tacada. Te lo digo en el minuto tres del curso, no al final.
Donde un modelo local gana de calle es dentro de un flujo de trabajo: tareas acotadas, repetitivas, con entrada y salida estructuradas, que se ejecutan cientos de veces sin que nadie mire. Leer el informe de síntesis de cada commit. Clasificar los fallos de la regresión nocturna. Revisar el estilo de cada fichero. Ahí un modelo de 12B no tiene nada que envidiarle a uno frontera, y además es gratis y privado.
Este curso va de llevarte hasta ahí.
Qué te llevas
Al terminar tienes funcionando en tu máquina:
Un servidor de inferencia medido, no copiado
Ollama para empezar y BeeLlama para exprimir los 16 GB: un solo servidor con seis configuraciones de modelo que se cargan bajo demanda, y la caché cuantizada para que quepa el contexto.
Tu propia tabla de decisión de modelos
Sacada de un banco de pruebas que compila, simula y comprueba el estilo de lo que genera cada modelo. Nada de «este me gusta más».
Opencode trabajando contra tu GPU
Un agente de terminal con comandos y skills que imponen tu guía de estilo y comprueban el resultado antes de dar el trabajo por hecho.
Dos flujos de análisis con Yosys e iverilog
La herramienta da los datos y el modelo solo pone las palabras. Siguen funcionando, con un informe de respaldo, si el modelo se cae.
Un MCP y una skill
Le dan al modelo una herramienta determinista para diseñar filtros biquad, y el procedimiento para usarla en tu proyecto.
Un pipeline de GitLab completo
Lint, síntesis, regresión, informe de IA y página de estado en cada push. La IA nunca decide si el build pasa.
Con números de verdad
El curso no te pide fe. Todo se mide en una RTX 5060 Ti de 16 GB, y se te enseña a medirlo en la tuya.
- Por qué un modelo que cabe con 4K de contexto revienta con 32K, y cómo la caché cuantizada de BeeLlama lo resuelve. En f16, la caché del modelo de 14B ocupa unos 6 GB a 32K tokens.
- Seis configuraciones de modelo, la misma especificación. Compilan tres. Los dos que «cumplen el estilo» son ficheros vacíos. El modelo de 27B con razonamiento tarda once minutos y no escribe una línea. Solo uno compila, pasa su test y cumple la especificación.
- Un MoE de 26B que genera a 66 tokens por segundo, casi el doble que un denso de 12B, y por qué eso contradice lo que dice todo el mundo de los MoE en escritorio.
- Un modelo de 27B que se inventa una ganancia de −30 dB al resumir lo que le devolvió la herramienta, y una skill de una página escrita para que no vuelva a pasar.
El temario
Parte 1 · La infraestructura
| Módulo | Qué aprendes | Lab |
|---|---|---|
| 0 · Presentación | Qué esperar de verdad de la IA local, y qué no | — |
| 1 · IA local en un flujo FPGA | El presupuesto de VRAM: pesos, KV cache y por qué solo una parte se puede calcular | Entorno y línea base de VRAM |
| 2 · Ollama | El camino rápido, el Modelfile y la API compatible con OpenAI | Ollama y el coste del contexto |
| 3 · llama.cpp y BeeLlama | GGUF, n-gpu-layers, cuantización de la caché y servidor multi-modelo | Medir f16 frente a kvarn4 |
| 4 · El zoo de modelos | Instruct, thinking, densos y MoE; cuál para qué | Banco de pruebas de seis configuraciones |
| 5 · Opencode | Proveedores, permisos, agentes Plan/Build y comandos | Un comando que impone tu guía de estilo |
Parte 2 · Donde está el valor
| Módulo | Qué aprendes | Lab |
|---|---|---|
| 6 · IA local en flujos de análisis | El patrón generador-intérprete: la herramienta calcula, el modelo explica | Informe de síntesis con Yosys · Triaje de regresiones con iverilog |
| 7 · MCP y skills | Darle herramientas al modelo, y la receta para usarlas | Un MCP de filtros biquad y una skill para él |
| 8 · CI/CD | Un pipeline donde la IA informa y nunca decide | GitLab, runner y prueba de degradación |
| 9 · Buenas prácticas y límites | Qué delegar, qué no, y cómo mantenerlo vivo | Proyecto final con tu propio diseño |
Qué incluye
- +3 h de vídeo: 10 módulos de teoría y 9 laboratorios grabados paso a paso.
- Una guía escrita por laboratorio, con todos los comandos, para seguirlo a tu ritmo sin pausar el vídeo.
- El kit del curso, listo para copiar a tu proyecto: una guía de estilo Verilog escrita para personas y para modelos y su comprobador automático; cinco comandos de Opencode (escribir RTL, escribir testbenches, revisar RTL, informe de síntesis y triaje); dos skills (estilo Verilog y diseño de filtros con MCP); los scripts de análisis, el cliente de inferencia sin dependencias y el banco de pruebas de modelos; y el
models.inicon los seis presets, la configuración de Opencode, eldocker-composede GitLab, la imagen del runner y el pipeline. - Una chuleta de una página con las fórmulas, reglas y decisiones de todo el curso.
- Un proyecto final con seis entregables comprobables para llevar todo el flujo a un diseño tuyo.
Para quién es
- Ingenieros de FPGA y SoC que quieren meter IA en su flujo sin mandar el código de sus clientes a un servicio externo.
- Equipos con requisitos de confidencialidad: defensa, médico, industrial, cualquier proyecto con un NDA firmado.
- Quien ya usa Claude Code o Copilot y quiere saber qué parte de ese flujo puede llevarse a una máquina propia.
- Responsables técnicos que necesitan cifras reales de coste, tiempo y calidad antes de proponerlo en su empresa.
Para quién no es
- Si buscas entrenar modelos o entender redes neuronales: aquí no se entrena nada.
- Si esperas que un modelo local diseñe tu sistema por ti: el curso te explica por qué eso no va a pasar.
- Si no tienes, ni puedes conseguir, una GPU NVIDIA: lee las preguntas frecuentes.
Qué necesitas
- Una GPU NVIDIA con 16 GB de VRAM, 32 GB de RAM y unos 200 GB libres en un SSD.
- Linux. El curso usa Ubuntu 24.04.
- Docker, solo para GitLab en el último laboratorio.
- Verilog a nivel de escribir un módulo y su testbench, y Linux a nivel de usuario.
- De inteligencia artificial, nada: todo lo necesario se explica en el módulo 1.
Las herramientas son libres. No necesitas ninguna licencia ni ninguna suscripción.
Tu profesor
Pablo Trujillo
Ingeniero con más de diez años desarrollando proyectos con FPGA y SoC, especializado en dispositivos y herramientas de AMD. Autor de controlpaths.com, donde publica contenido técnico sobre FPGA, y ponente en conferencias internacionales. Los dos servidores MCP del curso, biquad2rtl y el del Red Pitaya, son proyectos suyos publicados en GitHub.
Preguntas frecuentes
¿Necesito 16 GB de VRAM sí o sí?
Es la tarjeta para la que está diseñado el curso y con la que se mide todo. Con 12 GB sigues el método completo bajando un escalón de modelo, y la calculadora del laboratorio 01 te dice qué cabe antes de descargar nada. Lo que se resiente es el trabajo como agente (laboratorios 05 y 08), que necesita un modelo con tool calling fiable, y en el curso ese modelo es el de 27B. Con 8 GB, los flujos de análisis de los módulos 6 y 8 se pueden montar con un modelo más pequeño; el trabajo como agente, no.
¿Sirve una GPU de AMD o un Mac?
El curso usa CUDA, y BeeLlama se distribuye compilado para CUDA. Con AMD o con Apple Silicon la teoría y los flujos de análisis valen igual, pero tendrás que adaptar la instalación del servidor por tu cuenta, y eso no está cubierto en los laboratorios.
¿Y en Windows?
El curso está grabado en Ubuntu 24.04.
Trabajo con AMD/Xilinx, Intel, Lattice o Microchip. ¿Me sirve?
Sí. Los flujos usan Yosys e iverilog, que no dependen de fabricante, y el patrón es el mismo para los informes de Vivado o de Quartus. El módulo 9 deja apuntado cómo extenderlo a informes de timing.
¿No es más fácil pagar una suscripción a un modelo en la nube?
Para escribir código una vez, sí, y el curso te lo dice así. Para una tarea que se ejecuta en cada commit de todo el equipo, el modelo local es gratis por ejecución, no depende de que nadie cambie precios y, sobre todo, no saca el código de tu red. Si tu código no puede salir, no hay alternativa.
Los modelos cambian cada pocos meses. ¿No se queda viejo el curso?
El curso no te da una lista de modelos para memorizar: te da un banco de pruebas para decidir tú, con tus datos, cuándo te conviene cambiar. El método no caduca.
¿Cuánto tiempo necesito?
El vídeo dura algo más de tres horas. Haciendo los laboratorios, que es donde se aprende, cuenta con un par de fines de semana, más el proyecto final.
Eso es lo que te llevas
La IA local no brilla cuando le haces preguntas. Brilla cuando la pones dentro de un proceso que ya funcionaba sin ella y le quitas a una persona el trabajo repetitivo, en tu máquina, sin coste por ejecución y sin que el código salga de tu red.