<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Osvaldo Rios Zambrano on Medium]]></title>
        <description><![CDATA[Stories by Osvaldo Rios Zambrano on Medium]]></description>
        <link>https://medium.com/@osvaldorioz?source=rss-2a458f33daac------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*tttjD7zvex6o4TzwXNDgdQ.jpeg</url>
            <title>Stories by Osvaldo Rios Zambrano on Medium</title>
            <link>https://medium.com/@osvaldorioz?source=rss-2a458f33daac------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 01:19:38 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@osvaldorioz/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Un MoE de 35B en CPU con un motor en C puro: un modelo propio para Copilot]]></title>
            <link>https://medium.com/@osvaldorioz/un-moe-de-35b-en-cpu-con-un-motor-en-c-puro-un-modelo-propio-para-copilot-7c059a110c1e?source=rss-2a458f33daac------2</link>
            <guid isPermaLink="false">https://medium.com/p/7c059a110c1e</guid>
            <category><![CDATA[moe]]></category>
            <category><![CDATA[c-language]]></category>
            <category><![CDATA[github-copilot]]></category>
            <dc:creator><![CDATA[Osvaldo Rios Zambrano]]></dc:creator>
            <pubDate>Thu, 19 Nov 2026 16:51:23 GMT</pubDate>
            <atom:updated>2026-11-19T21:55:16.097Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/316/1*Z9GsbKeFFmdFuv07wg-1FQ.png" /></figure><h3>La idea</h3><p>Un modelo de 35 mil millones de parámetros puede correr en una CPU común, sin GPU, si el motor está hecho a la medida del modelo. Eso es moe-engine: un motor de inferencia escrito en C11 puro, sin dependencias, para modelos Mixture-of-Experts. Arranca en menos de un segundo, sirve Qwen3.6–35B-A3B a 13.4 tokens por segundo en una laptop de 6 hilos y va a correr en OpenShift, donde no hay GPU.</p><p>Lo construí porque quería que GitHub Copilot usara un modelo que controlamos nosotros, para que el código de la empresa no saliera de nuestra infraestructura. Antes probé lo obvio en mi Mac M2 con 24 GB: Apple Foundation Models y después Qwen2.5-Coder con MLX. Ninguno alcanzó.</p><p>El resultado final es híbrido: Copilot (con GPT-6 Luna) orquesta y verifica, y el MoE escribe el código. En un microservicio completo eso costó alrededor de 2.4 créditos de Copilot, contra 5 a 6 si Copilot lo escribe solo.</p><h3>Por qué un modelo de 35B corre en CPU</h3><p>En CPU, generar texto está limitado por la memoria, no por el cálculo: por cada token el motor tiene que leer de RAM todos los pesos que participan. En un modelo denso participan todos; en un MoE, solo unos cuantos expertos.</p><p>Qwen3.6–35B-A3B tiene 35 mil millones de parámetros, pero solo unos 3 mil millones activos por token (eso significa “A3B”). Con cuantización de 4 bits, cada token lee alrededor de 2 GB en lugar de unos 20 GB. Con el ancho de banda de memoria de una laptop o un servidor común, eso es la diferencia entre más de 10 tokens por segundo y 2 o 3 (cifras aproximadas).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/713/1*5yP7sZE7DjxRIM_5Ah8V6w.png" /><figcaption>La RAM no se ahorra: el modelo completo ocupa unos 20 GB. Lo que se ahorra es lo que se lee en cada paso, y eso es lo que decide la velocidad.</figcaption></figure><p><strong>¿Es solo para modelos MoE?</strong> Sí, por diseño. Hoy soporta tres familias MoE: Qwen3-MoE (Qwen3-Coder-30B-A3B), Qwen3.6 (35B-A3B, híbrido con Gated DeltaNet) y Qwen3-Next (Coder-Next 80B-A3B). Sus optimizaciones (expertos por mmap, GEMM agrupado por experto) solo tienen sentido cuando cada token usa una fracción del modelo. Un modelo denso grande en CPU sería lento con cualquier motor, y para un denso chico ya hay opciones generales.</p><h3>El motor en C puro</h3><p>moe-engine es un solo binario en C11, sin dependencias, que lee los GGUF publicados tal cual y expone una API compatible con OpenAI. Está hecho solo para MoE en CPU, y eso le permite optimizar lo que un motor general no puede.</p><ul><li><strong>Arranque en menos de un segundo.</strong> El archivo del modelo se mapea con mmap en vez de copiarse a memoria: el proceso está listo de inmediato y el sistema operativo trae cada experto la primera vez que se usa. El page cache funciona como caché de expertos, así que los más usados se quedan en RAM. La primera petición con la caché fría es más lenta; las siguientes ya no.</li><li><strong>Kernels int8</strong> para Q4_K, Q5_K, Q6_K y Q8_0 en AVX2, AVX-512 y escalar, con resultados idénticos bit a bit sin importar el tamaño del lote.</li><li><strong>GEMM agrupado por experto en el prefill:</strong> agrupa los tokens por experto y lee cada experto una sola vez. El prefill subió entre 41% y 48%.</li><li><strong>Decodificación especulativa MTP</strong> para Qwen3.6: la cabeza MTP propone tokens y el modelo los verifica en un solo batch. Acepta el 82% de los borradores y la salida no cambia.</li><li><strong>Servidor listo para agentes:</strong> tool calls en el formato de OpenAI, también en streaming (7 de 7 pruebas de punta a punta), continuous batching con slots, cola con límite y reutilización de prefijo.</li></ul><p>Medido en una laptop con 6 hilos y cuantización Q4_K_M:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/709/1*Y3saQ7f9B3_XsfqHh1uHbA.png" /><figcaption>Elegí Qwen3.6–35B-A3B con MTP 2: usa la mitad de memoria que Coder-Next, es más rápido y Qwen reporta una calidad equivalente (SWE-bench Verified 73.4% contra 70.6%).</figcaption></figure><p>La validación es la de un componente crítico: 173 pruebas, AddressSanitizer + UBSan, builds escalar, x86–64-v3 y x86–64-v4, y comparación de logits contra PyTorch con un error de ~1e-4. La salida es la misma con un usuario o con varios, y con o sin especulación.</p><h3>moe-engine contra Ollama</h3><p>Ollama es la forma más cómoda de correr modelos locales, y por eso es la comparación natural. Son herramientas con objetivos distintos: Ollama es general y moe-engine es especializado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VrW8uvsvs4DmZ_5NuLuphw.png" /></figure><p>Los beneficios de escribirlo en C, para este caso:</p><ul><li><strong>Arranque inmediato.</strong> Un pod que se reinicia o escala en OpenShift está sirviendo en menos de un segundo, sin esperar a que se cargue el modelo.</li><li><strong>Superficie mínima.</strong> Sin runtime, sin recolector de basura y sin dependencias de terceros, la imagen es pequeña y la revisión de seguridad cubre solo nuestro código.</li><li><strong>Control total de la memoria.</strong> El acomodo de los expertos y el uso del page cache están pensados para MoE, no adaptados.</li><li><strong>Verificable.</strong> Los sanitizers y la comparación contra PyTorch funcionan sobre todo el motor, no sobre una capa encima de otro.</li></ul><p>Ollama sigue siendo la mejor opción para probar modelos distintos, usar GPU o trabajar en una laptop. moe-engine conviene cuando ya elegiste el modelo, solo hay CPU y lo vas a operar como un servicio.</p><h3>Antes del motor: Apple FM y Qwen en la Mac</h3><p>El primer plan fue usar lo que ya traía la Mac M2 de 24 GB. Los dos intentos dejaron infraestructura útil, pero no un modelo suficiente para código.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ypRJSxQFuhqTzhw82Ms2lQ.png" /></figure><p>De ahí salieron dos piezas que sí se quedaron: un servicio de agentes en Python que habla el protocolo de OpenAI, y herramientas que no le piden al modelo más de lo que puede dar (revisión de seguridad con reglas deterministas y evidencia verificada, y generación de código desde una especificación). Faltaba un modelo más grande que no necesitara GPU, y para eso está el moe-engine.</p><h3>Cómo se conecta a Copilot</h3><p>Copilot no cambia de modelo: llama al modelo propio como una herramienta MCP más. En la Mac todo vive en 127.0.0.1: Copilot CLI, un servidor MCP en Python (mcp_fm.py) y el servicio de agentes, que habla con cualquier motor compatible con OpenAI.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*25Te5A5rrWIMvB88R1tGMw.png" /><figcaption>Arquitectura original sin MoE</figcaption></figure><p>Con el motor en OpenShift la cadena de la Mac no cambia: el servicio de agentes solo apunta su URL al motor, alcanzable por la red interna y con clave de acceso. Para que las respuestas largas no se corten por inactividad en la red, el servicio pide los tokens en streaming.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Kss_W4S5GWZ4zT7S8uCMjA.png" /><figcaption>Arquitectura con MoE</figcaption></figure><p>Copilot CLI quedó con dos servidores MCP y elijo cuál usar en cada pedido: fm-agentes (Qwen 14B local, para cuando no hay red) y fm-moe (el MoE de 35B).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jjpPlNFeKTqdzNd6ROOrbg.png" /><figcaption>Validación de que Copilot está conectado al MoE</figcaption></figure><h3>La prueba: un microservicio completo y lo que costó</h3><p>Generar un microservicio completo con el esquema híbrido costó alrededor de 2.4 créditos de Copilot, entre 55% y 60% menos que dejar que Copilot lo escriba solo. El ejercicio fue un microservicio en Python + FastAPI con arquitectura hexagonal para k-means: 13 archivos y 37 pruebas en verde.</p><p>El reparto del trabajo:</p><ol><li>Una especificación en Markdown divide el servicio en fases: dominio, aplicación y adaptadores.</li><li>Copilot CLI (GPT-6 Luna) llama a fm_generar_codigo del servidor fm-moe con la especificación y los archivos de fases anteriores como contexto.</li><li>El MoE genera la fase en 6 a 7 minutos y escribe los archivos; nunca sobrescribe.</li><li>Copilot corre pytest, corrige lo mínimo y pasa a la siguiente fase.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gustVOv83G2msPJi3D-x9Q.png" /></figure><p>Copilot solo gasta créditos en orquestar y verificar; el código lo escribe el motor propio.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/913/1*MshnBiddFWGGcpHzf4TW2g.png" /><figcaption>Ejemplo del prompt para que Copilot ejecute la especificación (aqui va en la fase 2)</figcaption></figure><p>Los créditos se tomaron del contador de sesión de Copilot CLI. La Fase 3 ajustada sale del costo medido de la Fase 2, escalado entre 1.2 y 1.6 veces porque tiene más archivos y pruebas. El corte ya se corrigió dividiendo esa fase en dos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/745/1*mL81CX0Bxd8RGYNdI3pDrw.png" /></figure><p>La cifra de “Solo Copilot con Luna” se estimó con lo que hubiera costado si Luna creara todos los 13 archivos del servicio. Lo que no aparece en los créditos: unos 20 minutos de CPU del motor, que ya está aprovisionado, y la privacidad de que el código se genera en infraestructura propia.</p><p>Diagrama de secuencia</p><p>El spec fue previamente generado en otro flujo de SDD donde se procesó un PRD (Product Requirements Document). Este spec hay que separarlo por etapas para tener un control más fino sobre el código generado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GnkYeUY7nRL2n0eW7xNlfQ.png" /></figure><p>Arquitectura final híbrida Copilot-MoE</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3UEikCa_2Bg4a2gZLAYeWg.png" /></figure><h3>Lecciones y lo que sigue</h3><ol><li><strong>En CPU, el MoE correcto vale más que la GPU.</strong> Con 3B parámetros activos, un modelo de 35B corre a velocidad útil en hardware común.</li><li><strong>Un motor especializado se paga solo.</strong> Escrito en C para MoE, arranca en menos de un segundo, se despliega como un binario y se puede verificar por completo.</li><li><strong>Separa el orquestador del modelo.</strong> Copilot decide y verifica; el modelo propio genera como herramienta MCP. Así cambié de Apple FM a Qwen y al MoE de 35B sin tocar la integración.</li></ol><p>Lo que sigue:</p><ul><li>Desplegar moe-engine en OpenShift con MTP 2 (moe:0.7), con clave de acceso y sin exposición pública.</li><li>Apagar MTP automáticamente cuando haya muchos usuarios activos, porque con 4 usuarios ya no aporta.</li><li>Medir la calidad con unos 200 casos etiquetados y tareas reales de agentes con herramientas.</li><li>Kernels VNNI/AMX si los nodos de OpenShift los tienen.</li></ul><p>El resultado es un Copilot que sigue usando su propio modelo (en mi caso GPT-6 Luna), pero que delega la generación de código a un modelo que controlamos nosotros, corriendo en CPU sobre un motor que escrito en C puro vuela!.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7c059a110c1e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Lo que encontré al entrenar un nuevo modelo LFM3 de la familia Liquid AI para jugar Tetris]]></title>
            <link>https://medium.com/@osvaldorioz/lo-que-encontr%C3%A9-al-entrenar-un-nuevo-modelo-lfm3-de-la-familia-liquid-ai-para-jugar-tetris-8d1982b53a28?source=rss-2a458f33daac------2</link>
            <guid isPermaLink="false">https://medium.com/p/8d1982b53a28</guid>
            <category><![CDATA[lfm3]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[llama-cpp]]></category>
            <category><![CDATA[tetris]]></category>
            <dc:creator><![CDATA[Osvaldo Rios Zambrano]]></dc:creator>
            <pubDate>Mon, 02 Nov 2026 23:54:33 GMT</pubDate>
            <atom:updated>2026-11-03T00:34:18.566Z</atom:updated>
            <content:encoded><![CDATA[<p><em>¿Qué es LFM3? ¿cómo funciona su arquitectura tri-híbrida? ¿cómo lo afiné en una RTX 4060 para que jugara al nivel de un experto? y si es posible usar este tipo de modelos como un “System 1”.</em></p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FxaUnxbNBB44%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DxaUnxbNBB44&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FxaUnxbNBB44%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/949e80ed94a55e64a71a207185e1dba1/href">https://medium.com/media/949e80ed94a55e64a71a207185e1dba1/href</a></iframe><h3>Breve historia</h3><p>En un artículo anterior enfrenté a un modelo propio, <strong>tetris-s1</strong> (un encoder mmBERT-small de ~140M parámetros, entrenado para jugar Tetris), contra tres “System 1” generalistas: Laya, OpenJev y Jev (el servicio comercial de TypeSafe). Los tres jugaron <strong>al nivel del azar</strong> y perdieron en unas 25 piezas. Mi modelo jugó al nivel del experto y decidió más rápido que todos.</p><p>Esa comparación dejó abierta una pregunta: ¿los generalistas perdieron por su <strong>arquitectura</strong> o porque <strong>nadie les enseñó Tetris</strong>?</p><p>Pocos días después, el 27 de octubre de 2026, Liquid AI publicó <strong>LFM3</strong>, una familia de modelos de ~2B parámetros pensados para correr en el dispositivos como celulares y para afinarse (fine-tuning) en una sola GPU. Era el candidato ideal para responder la pregunta: tomar un LLM pequeño y moderno, medirlo tal cual, enseñarle Tetris con exactamente los mismos datos que usé para tetris-s1 y ponerlo a competir.</p><p>Spoiler: <strong>sin entrenar sacó 6%</strong> de acuerdo con el experto, peor que el azar. <strong>Después de una época de fine-tuning de 3 horas y media, empató a tetris-s1</strong> en calidad, aunque no en velocidad.</p><h3>Qué es LFM3</h3><p>LFM3 es la tercera generación de los <em>Liquid Foundation Models</em>. La familia tiene seis modelos open-weight de unos 2B parámetros, construidos sobre una misma columna vertebral:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ffR6eZ2RGxKLFXonfz_1FA.png" /></figure><p>Datos clave de LFM3–1.7B, según su <em>model card</em>:</p><ul><li><strong>1.73B parámetros</strong>, 24 capas, vocabulario de 128,000 tokens.</li><li><strong>Contexto de 256K tokens.</strong></li><li><strong>16 idiomas</strong>, entre ellos el español.</li><li><strong>Licencia LFM Open License v1.0</strong>, basada en Apache 2.0. El uso comercial es gratis para empresas con menos de 10 millones de dólares de ingresos anuales; la investigación no tiene límite.</li><li><strong>Variantes listas para usar:</strong> BF16, FP8, NVFP4, GGUF (llama.cpp, Ollama, LM Studio), MLX y ONNX. En Q4_0 pesa ~1 GB; en Q8_0, ~1.85 GB.</li><li><strong>Modo <em>thinking</em> activado por defecto:</strong> razona dentro de bloques &lt;think&gt; antes de responder. Este detalle me causó el problema más interesante del experimento.</li></ul><h3>La arquitectura tri-híbrida, a fondo</h3><p>La mayoría de los LLMs son pilas de capas de atención. LFM3 no: <strong>más de la mitad de sus capas son convoluciones</strong>, y la atención aparece solo donde hace falta. Liquid la llama tri-híbrida porque combina tres tipos de capa:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*odbbpChEDnofyg6f3C-aFA.png" /></figure><h3>El orden de las capas</h3><p>Las capas no están mezcladas al azar. Empieza con dos convoluciones; luego repite cinco veces un bloque de cuatro capas (<em>global → convolución → ventana → convolución</em>), y cierra con una global y una convolución. Nunca hay dos capas de atención seguidas:</p><pre> 1  conv          ┐<br> 2  conv          ┘ arranque<br> 3  GLOBAL        ┐<br> 4  conv          │<br> 5  ventana 256   │ bloque × 5   (capas 3 a 22)<br> 6  conv          ┘<br> …<br>23  GLOBAL        ┐<br>24  conv          ┘ cierre</pre><p>Cada capa, sea convolución o atención, va seguida de una red feed-forward SwiGLU (de 2,048 a 7,680 y de vuelta). Esas FFN concentran cerca de dos tercios de los parámetros.</p><p>Lo pude comprobar en mi propia conversión a GGUF. El convertidor de llama.cpp imprime las cabezas KV por capa como [0, 0, 4, 0, 4, 0, 4, …]: hay atención (4 cabezas KV) solo en las capas 3, 5, 7, …, 23, y convolución en las demás.</p><h3>La convolución corta con compuerta</h3><p>Es la pieza que hace a LFM3 tan eficiente. Por cada token:</p><ol><li><strong>Una sola proyección lineal sin sesgo</strong> convierte el vector de 2,048 dimensiones en tres de 2,048: <strong>B</strong>, <strong>C</strong> y <strong>x</strong> (en el GGUF se ve como shortconv.in_proj, de 2,048 → 6,144).</li><li><strong>Compuerta de entrada:</strong> B ⊙ x (producto elemento a elemento).</li><li><strong>Convolución causal <em>depthwise</em> con núcleo 7:</strong> cada canal mira solo los últimos 7 tokens (en el GGUF, shortconv.conv, de forma 7 × 2,048). LFM2 usaba núcleo 3.</li><li><strong>Compuerta de salida:</strong> C ⊙ z, seguida de una proyección de salida.</li></ol><p>La convolución es barata: su costo crece en línea recta con el ancho y no con el contexto, y al generar solo guarda un estado fijo de 6 posiciones. Con 13 capas de núcleo 7, la información viaja hasta ~79 tokens hacia atrás antes de que intervenga la atención.</p><h3>Las dos atenciones</h3><ul><li><strong>Ventana deslizante (5 capas):</strong> cada token mira los 256 anteriores. Su caché nunca pasa de esa ventana, sin importar cuánto crezca el contexto.</li><li><strong>Global (6 capas):</strong> mira todo el contexto, con <em>grouped-query attention</em> (16 cabezas de consulta, 4 de clave-valor, dimensión 128), normalización de Q y K, y RoPE parcial con θ = 1,000,000. En el GGUF aparece además un tensor attn_gate de 2,048 × 16: una compuerta aprendida por cabeza sobre la salida de la atención.</li></ul><h3>Por qué importa</h3><p>Solo las 6 capas globales necesitan un caché que crece con el contexto: ~12 KB por token, ~1.6 GB a 128K. Modelos comparables necesitan entre 2.7 y 3.5 veces más memoria para lo mismo. Y como la operación dominante es la convolución, el modelo es especialmente rápido en CPU y en celulares. Liquid reporta, en llama.cpp con Q4_0 y 32K de contexto, un <em>prefill</em> al menos 2.5 veces más rápido y una decodificación al menos 1.8 veces más rápida que los modelos con los que compara, en un AMD Ryzen AI Max+, un Apple M5 Max y un iPhone 17 Pro. Son cifras del fabricante que no he verificado.</p><p>En mi tarjeta nvidia RTX 4060, con Q8_0, medí <strong>~100 tokens/s de generación</strong> y un <em>prefill</em> de <strong>~2,500 tokens/s</strong> con prompts cortos como los de Tetris.</p><h3>Cómo lo entrenó Liquid</h3><p><strong>Preentrenamiento: 22 billones de tokens</strong></p><ul><li>Unos 15T de web y datos sintéticos, y luego 3T de código, matemáticas y ciencia a 4K de contexto.</li><li>Un <em>mid-training</em> con datos curados y más trazas de agentes y llamadas a herramientas, que extiende el contexto a 32K, 128K (500 mil millones de tokens) y 256K (50 mil millones).</li></ul><p><strong>Post-entrenamiento en cuatro etapas</strong></p><ol><li><strong>SFT</strong> con 1.75T de tokens de chat, razonamiento, herramientas y trazas agénticas.</li><li><strong>RL mixto</strong> en matemáticas, código, SQL y salidas estructuradas, con penalización por longitud.</li><li><strong>Destilación multi-dominio <em>on-policy</em>:</strong> seis maestros especializados (código, matemáticas, herramientas, contexto largo, agentes y flujos empresariales) destilados en un solo modelo.</li><li><strong>RL agéntico</strong> dentro de entornos de agentes reales.</li></ol><p><strong>Resultados que reporta Liquid</strong> (no verificados por mí):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/724/1*-Yh1tJad-EoOx4NLvWAShw.png" /></figure><p>El perfil es claro: <strong>muy fuerte en seguir instrucciones, usar herramientas y producir salidas estructuradas; débil en conocimiento enciclopédico.</strong> La propia <em>model card</em> recomienda combinarlo con búsqueda o RAG para tareas de conocimiento, y no usarlo para programación agéntica ni razonamiento complejo de muchos pasos. Está hecho para lo contrario: decisiones frecuentes, locales y bien delimitadas. Eso es exactamente un System 1.</p><h3>Arquitectura del LMF3</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XQsiDBWwSxrS98YCfh7tsg.png" /></figure><h3>Primera prueba: LFM3 tal cual viene de Hugging Face</h3><p>Usé el mismo benchmark de mi artículo anterior: un motor de Tetris con semillas fijas, un experto heurístico (El-Tetris, de Pierre Dellacherie) como referencia, y una pregunta por turno: <em>¿dónde coloco esta pieza?</em></p><p>Para LFM3 escribí un prompt de chat con el estado del tablero y las jugadas válidas:</p><pre>[system]  Eres un motor de decisiones de Tetris (tablero de 10 columnas x 20 filas).<br>          Recibes el estado y las jugadas válidas, y respondes SOLO con la clave de la<br>          mejor jugada, sin explicación. Clave rXcY: X = giros de 90° a la derecha de la<br>          pieza (0-3), Y = columna de su borde izquierdo (0-9). Prefiere jugadas que<br>          limpien líneas, no dejen huecos y mantengan el tablero bajo y parejo.<br>[user]    pieza: I<br>          siguiente: Z<br>          alturas: c0=3 c1=5 c2=4 c3=2 c4=2 c5=0 c6=0 c7=1 c8=4 c9=3<br>          huecos: ninguno<br>          jugadas válidas: r0c0 r0c1 … r1c8 r1c9<br>[assistant]  r1c0</pre><p>Para medir sin depender de cómo genera texto, puntué cada jugada válida por su log-probabilidad y tomé la más alta. Es una decisión restringida: nunca puede elegir una jugada imposible.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/744/1*rmAB8qz6ykTo5vSzLiavTg.png" /></figure><p>Peor que el azar (~9%) y <strong>seguro de sí mismo</strong>: elegía jugadas equivocadas con 62% de probabilidad en promedio. Es el mismo patrón que vi en los generalistas del artículo anterior. Un LLM generalista no sabe jugar Tetris por sí solo, por bien que siga instrucciones.</p><h3>El experimento: enseñarle Tetris con los mismos datos de tetris-s1</h3><p>La condición era que la comparación fuera justa: <strong>mismo experto, mismas partidas, mismo formato de estado</strong> que usé para entrenar a tetris-s1. Lo único distinto es el modelo.</p><h3>El problema, en concreto</h3><ul><li><strong>Estado:</strong> pieza actual, siguiente, altura de cada columna (c0=3 … c9=0) y huecos por columna. No se manda el tablero de 20×10: el tokenizer parte las cadenas de # y . en trozos de largo variable y se pierde la posición de cada columna (lo aprendí por las malas con tetris-s1).</li><li><strong>Acción:</strong> la colocación final, no teclas. Una clave rXcY con la rotación y la columna del borde izquierdo. Por turno hay entre 9 y 34 jugadas válidas, según la pieza.</li><li><strong>Etiqueta:</strong> la jugada que elige el experto.</li></ul><h3>El dataset</h3><ul><li><strong>600 partidas</strong> del experto, con 15% de jugadas aleatorias para visitar tableros variados (las mismas semillas que el dataset de tetris-s1).</li><li><strong>66,017 ejemplos</strong>, separados <strong>por partida</strong> para que tableros de una misma partida no caigan en train y en test: 53,326 de entrenamiento, 6,200 de validación y 6,491 de prueba.</li><li>Formato <em>prompt/completion</em> conversacional: el prompt son los mensajes system y user, y la completion es solo la clave, por ejemplo r1c4. Así <strong>la pérdida se calcula solo sobre la respuesta</strong>, no sobre los ~280 tokens del prompt.</li><li>Generarlo tardó 84 segundos.</li></ul><h3>El fine-tuning</h3><p>LoRA con TRL y PEFT en la RTX 4060 de 8 GB:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/861/1*IAoKuVg6RNBPT-uFEQzZqA.png" /><figcaption>Usé all-linear en lugar de nombrar capas a mano para no depender de los nombres internos de una arquitectura recién salida. Y el batch quedó en 4 por un detalle que no esperaba: con un vocabulario de 128,000 tokens, los logits de 16 secuencias de 384 tokens no caben en 8 GB de mi RTX 4060.</figcaption></figure><h3>El resultado offline</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/805/1*xb8NAzGHrPae4Nhy1uQGJQ.png" /><figcaption>De 6% a 74.6% en una sola época. Pero esa cifra sale del split de prueba del propio dataset, con tableros parecidos a los de entrenamiento. La prueba real era jugar.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f2yiRl6ZPcLP0u4p8KBS1g.png" /><figcaption>Pipeline Tetris</figcaption></figure><h3>De las pruebas al servidor: cuatro problemas que enfrenté</h3><p>Entrenar fue lo fácil. Servir el modelo con llama.cpp, mostró cuatro problemas:</p><p><strong>1. Código propio en el repositorio.</strong> LFM3 trae sus propios modeling_lfm3.py y lfm3_conv.py, así que hay que cargarlo con trust_remote_code=True. Conviene fijar la revisión del repo para que el código no cambie entre el entrenamiento y la conversión.</p><p><strong>2. El vocabulario grande se come la memoria.</strong> Mi primera evaluación pedía los logits de las 128,000 palabras en cada posición del prompt, para 34 jugadas a la vez: 2.8 GB solo de logits. Se resuelve con logits_to_keep, que pide los logits solo de las 2–3 posiciones que forman la respuesta.</p><p><strong>3. Versiones cruzadas al convertir a GGUF.</strong> La librería transformers 5 guarda el tokenizer con una clase (TokenizersBackend) que no entiende la versión 4.57 que instalan los requisitos del convertidor de llama.cpp. La solución fue copiar los archivos de tokenizer originales de Liquid al modelo fusionado. El fine-tuning no cambia el vocabulario, así que son idénticos.</p><p><strong>4. La plantilla de chat, y la lección más importante.</strong> Ya servido, el modelo respondía &lt;/think&gt;&lt;/think&gt;&lt;/think&gt;… en lugar de una jugada. La causa: con el modo <em>thinking</em>, la plantilla de Hugging Face termina el prompt con &lt;|im_start|&gt;assistant\n&lt;think&gt;\n, <strong>y eso fue lo que el modelo vio en entrenamiento</strong>: aprendió a escribir la jugada justo después de &lt;think&gt;. llama-server, con su propia plantilla y --reasoning-budget 0, le armaba un final distinto, y el modelo se perdía.</p><p>La solución fue exportar el prompt <strong>exacto</strong> del entrenamiento y mandárselo a llama-server por el endpoint crudo /completion, sin plantilla de chat. Además, una gramática GBNF restringe la salida a las claves válidas del turno:</p><pre>root ::= &quot;r0c0&quot; | &quot;r0c1&quot; | &quot;r1c0&quot; | … | &quot;r1c9&quot;</pre><p>Con eso responde r1c0 en ~100 ms, nunca devuelve una jugada inválida y no gasta tokens en razonar. <strong>La lección: en un modelo afinado, el prompt que llega en producción tiene que ser idéntico, byte por byte, al del entrenamiento.</strong> Las plantillas de chat y el manejo del razonamiento son los puntos donde más fácil se rompe.</p><h3>Resultados: LFM3 afinado contra tetris-s1</h3><p>Los dos corrieron en la misma sesión, en la misma máquina, con los mismos 300 tableros y las mismas 5 semillas. tetris-s1 corre en CPU (ONNX Runtime, detrás de MCP); LFM3, en la GPU (llama.cpp, Q8_0).</p><h3>Tableros fijos (300)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/762/1*59grqCF3VuwLgnGoNdMW-w.png" /></figure><h3>Partidas completas (200 piezas)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/794/1*ALM6oiEfkMzdmB4rdj2reg.png" /></figure><h3>Tetris arena</h3><p>En la arena visual, una partida de 500 piezas con las mismas piezas para los dos, terminó así:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/826/1*FPS_8382reY-eVjORn5rWg.png" /><figcaption>En la arena, LFM3 aparece más lento que en el benchmark porque los dos motores y el dibujo de la ventana corren a la vez en la misma máquina. Las cifras de latencia que valen son las del benchmark.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oUENvO58Vy6e_04DuyD4Ag.png" /></figure><h3>Cómo leerlo</h3><ul><li><strong>En calidad, empate.</strong> tetris-s1 acierta más veces la jugada exacta del experto y hace un poco más de líneas en promedio. LFM3 elige alternativas ligeramente mejores cuando no coincide (regret más bajo) y ganó la partida larga de la arena. Con 5 partidas por motor, las diferencias están dentro del ruido.</li><li><strong>LFM3 no necesitó DAgger.</strong> tetris-s1 en su primera ronda (42% de acuerdo) perdía a las 40 piezas, porque sus propios errores lo llevaban a tableros que nunca había visto; hizo falta DAgger para llegar a 74.7%. LFM3 terminó todas sus partidas desde la primera ronda. Mi hipótesis es que su preentrenamiento le da más robustez ante estados desconocidos.</li><li><strong>En velocidad gana el encoder.</strong> tetris-s1 decide unas 3 veces más rápido, en CPU contra GPU, con 12 veces menos parámetros y menos de un tercio de los tokens: sus opciones están fijas y cacheadas, y solo procesa el estado. LFM3 procesa el prompt completo en cada jugada.</li></ul><p>Para dimensionar el salto, este es el panorama completo, con las cifras del artículo anterior:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/902/1*f9uNfvAf3nM_3JNEGkVPmQ.png" /><figcaption>La respuesta a la pregunta del inicio es clara: <strong>lo que separaba a los generalistas de tetris-s1 no era la arquitectura, era el entrenamiento en la tarea.</strong> Un LLM generativo de propósito general, afinado con los mismos datos, llega al mismo nivel.</figcaption></figure><h3>Entonces, ¿que usar, un encoder especializado o un LLM afinado?</h3><p>Depende de qué necesites del System 1:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CVSsISwemt1iceZjDuy1nw.png" /><figcaption>Mi opinión: el encoder especializado sigue siendo la mejor opción <strong>cuando la decisión es repetitiva y conocida</strong>. LFM3 abre una opción intermedia que antes no era práctica: un modelo que se afina en una GPU nvidia en menos de 4 horas, alcanza la calidad del especialista, cabe en un celular y además conserva todo lo que sabe hacer un LLM.</figcaption></figure><h3>Cómo podría usarse LFM3</h3><ol><li><strong>System 1 local para agentes.</strong> Un agente grande (System 2) delega en LFM3 las decisiones frecuentes (clasificar, enrutar, elegir la siguiente herramienta) y solo escala lo difícil. LFM3 destaca justamente en instrucciones y herramientas (IFEval 96.7, BFCL 71.4) y corre local, sin costo por token.</li><li><strong>Motor de decisiones afinado, con salida restringida.</strong> Lo que hice con Tetris sirve para cualquier decisión con un conjunto finito de opciones: prompt fijo, dataset de ejemplos etiquetados, LoRA de unas horas y una gramática que obligue a responder solo con opciones válidas. Sale un clasificador que además puede explicar su respuesta si se lo pides.</li><li><strong>Extracción estructurada y llamadas a funciones en el dispositivo.</strong> Con un GGUF de ~1 GB, puede convertir texto en JSON o decidir qué función llamar sin mandar los datos a la nube. Eso importa cuando la información es privada.</li><li><strong>Decisiones calibradas zero-shot con d1–2B.</strong> Para quien no tenga datos para entrenar, Liquid publicó d1–2B: responde preguntas de sí o no, elección o calificación con probabilidades calibradas en una sola pasada. No lo probé en este experimento. Después de ver fracasar a tres generalistas en Tetris, sería el siguiente candidato a medir.</li><li><strong>Siempre con RAG para el conocimiento.</strong> Su punto débil es el conocimiento enciclopédico (Liquid reporta 7.07 en AA-Omniscience). Para preguntas de hechos, hay que darle los documentos en el prompt.</li></ol><h3>Lo que este experimento no demuestra</h3><ul><li><strong>Que LFM3 sea mejor o peor en general.</strong> Es una sola tarea, con un experto heurístico como maestro.</li><li><strong>Una comparación de hardware igual.</strong> tetris-s1 corrió en CPU y LFM3 en GPU. Falta medir LFM3 en CPU, donde Liquid promete su mayor ventaja.</li><li><strong>Diferencias finas de calidad.</strong> Con 300 tableros y 5 partidas por motor, 71% contra 74.7% y 75.8 contra 78 líneas son, en la práctica, un empate.</li><li><strong>Que no pueda mejorar.</strong> No probé una ronda de DAgger, ni más épocas, ni cuantización a 4 bits.</li><li><strong>Los benchmarks de Liquid.</strong> Los cité como los reporta el fabricante; no los verifiqué.</li></ul><h3>Cómo levanté LFM3 en llama.cpp</h3><p>Para servir el modelo usé llama.cpp, el mismo motor que hay detrás de Ollama y LM Studio. Corre modelos en formato GGUF en CPU o GPU, expone una API compatible con OpenAI y es la forma más directa de llevar LFM3 a una laptop o un servidor pequeño.</p><h3>1. Compilar una versión que conozca LFM3</h3><p>LFM3 salió el 27 de octubre, así que las compilaciones anteriores de llama.cpp no reconocen su arquitectura y fallan con unknown model architecture. Hice un clon aparte, solo para este modelo, y lo compilé con CUDA para la RTX 4060 (arquitectura 89):</p><pre>sudo apt install nvidia-cuda-toolkit<br>git clone https://github.com/ggml-org/llama.cpp llama.cpp.lfm3 &amp;&amp; cd llama.cpp.lfm3<br>cmake -B build -DGGML_CUDA=ON -DCMAKE_CUDA_ARCHITECTURES=89<br>cmake --build build --config Release -j$(nproc)<br>./build/bin/llama-cli --list-devices      # debe mostrar &quot;NVIDIA GeForce RTX 4060&quot;</pre><p>Aquí tuve el primer tropiezo: CMake no encontraba nvcc. La actualización de Ubuntu se había llevado el CUDA 12.6 que tenía instalado a mano, y además esa versión no es compatible con GCC 15. Lo resolví instalando el toolkit desde los repositorios de Ubuntu (nvidia-cuda-toolkit). Si CUDA no coopera, hay una alternativa: compilar con Vulkan (-DGGML_VULKAN=ON, que requiere libvulkan-dev y glslc).</p><p>La compilación que usé es la b12018-8956c769e.</p><h3>2. Probar el modelo base</h3><p>llama.cpp descarga el GGUF directamente de Hugging Face con -hf. Usé Q8_0 (~1.85 GB), que conserva casi toda la calidad y cabe de sobra en 8 GB:</p><pre># Chat en la terminal<br>./build/bin/llama-cli -hf LiquidAI/LFM3-1.7B-GGUF:Q8_0 -ngl 99 -c 32768 -fa on \<br>  --temp 0.1 --top-k 50 --repeat-penalty 1.1<br><br># Servidor con API compatible con OpenAI e interfaz web en http://localhost:8080<br>./build/bin/llama-server -hf LiquidAI/LFM3-1.7B-GGUF:Q8_0 -ngl 99 -c 32768 -fa on \<br>  --temp 0.1 --top-k 50 --repeat-penalty 1.1 --jinja --port 8080</pre><ul><li>-ngl 99 carga todas las capas en la GPU.</li><li>-fa on activa <em>flash attention</em>.</li><li>-c 32768 fija el contexto. Gracias a que solo 6 capas guardan caché completo, podría subir a 128K sin quedarme sin memoria.</li><li>--temp 0.1 --top-k 50 --repeat-penalty 1.1 son los parámetros que Liquid recomienda para uso general.</li><li>--jinja usa la plantilla de chat del modelo. Con --reasoning-budget 0 se desactiva el modo <em>thinking</em>.</li></ul><p>Para comprobar la API:</p><pre>curl http://localhost:8080/v1/chat/completions -H &quot;Content-Type: application/json&quot; \<br>  -d &#39;{&quot;messages&quot;:[{&quot;role&quot;:&quot;user&quot;,&quot;content&quot;:&quot;Hola, ¿quién eres?&quot;}]}&#39;</pre><p>En la RTX 4060 medí unos <strong>100 tokens/s de generación</strong> y respuestas correctas en español desde la primera prueba.</p><h3>3. Llevar el modelo afinado a GGUF</h3><p>El fine-tuning produce un adaptador LoRA, no un modelo que llama.cpp pueda leer. Hay que fusionarlo con el modelo base y convertir el resultado:</p><pre>python lfm/merge_lora.py --adapter runs/lfm3-tetris/adapter --out runs/lfm3-tetris/merged<br>python llama.cpp.lfm3/convert_hf_to_gguf.py runs/lfm3-tetris/merged \<br>  --outtype q8_0 --outfile runs/lfm3-tetris/lfm3-tetris-q8_0.gguf</pre><p>Aquí aparece el problema de versiones del tokenizer que conté antes. Si el convertidor falla en el paso <em>Set model tokenizer</em>, hay que copiar los archivos de tokenizer originales del repositorio de Liquid a la carpeta merged.</p><h3>4. Servirlo para Tetris</h3><p>Para el modelo afinado no uso la plantilla de chat del servidor. Le mando el prompt exacto del entrenamiento por el endpoint crudo /completion, así que no hacen falta --jinja ni --reasoning-budget. Con 4K de contexto sobra, porque cada jugada usa unos 300 tokens:</p><pre>./build/bin/llama-server -m runs/lfm3-tetris/lfm3-tetris-q8_0.gguf \<br>  -ngl 99 -c 4096 -fa on --port 8081</pre><p>Cada jugada es una petición como esta, con la gramática que limita la respuesta a las jugadas válidas del turno:</p><pre>POST /completion<br>{<br>  &quot;prompt&quot;: &quot;&lt;|startoftext|&gt;&lt;|im_start|&gt;system\nEres un motor de decisiones de Tetris…&lt;|im_end|&gt;\n&lt;|im_start|&gt;user\npieza: I\n…\njugadas válidas: r0c0 … r1c9&lt;|im_end|&gt;\n&lt;|im_start|&gt;assistant\n&lt;think&gt;\n&quot;,<br>  &quot;grammar&quot;: &quot;root ::= \&quot;r0c0\&quot; | \&quot;r0c1\&quot; | … | \&quot;r1c9\&quot;&quot;,<br>  &quot;temperature&quot;: 0,<br>  &quot;n_predict&quot;: 8<br>}</pre><p>La respuesta llega en ~100 ms con la clave elegida, por ejemplo &quot;content&quot;: &quot;r1c0&quot;. El servidor reporta un <em>prefill</em> de unos 2,500 tokens/s con prompts así de cortos, y la mayor parte de la latencia se va en procesar el prompt.</p><h3>Siguientes pasos</h3><ul><li><strong>LFM3 en CPU</strong>, para comparar contra tetris-s1 en el mismo hardware.</li><li><strong>Cuantización Q4_0</strong>, para medir cuánto se gana en velocidad y cuánto se pierde en calidad.</li><li><strong>Una ronda de DAgger</strong> con LFM3 jugando, a ver si supera a tetris-s1.</li><li><strong>d1–2B zero-shot</strong>, para saber si un modelo de decisión calibrado juega mejor que los generalistas sin entrenamiento.</li><li><strong>El modo explicativo:</strong> pedirle a LFM3 afinado que justifique su jugada, algo que el encoder no puede hacer.</li></ul><p><em>Stack: Python, PyTorch, Transformers, TRL y PEFT (fine-tuning), llama.cpp (servicio, GGUF Q8_0), RTX 4060 de 8 GB. Modelo: </em><em>LiquidAI/LFM3-1.7B. Experto: heurística El-Tetris de Pierre Dellacherie.</em></p><p><strong>Fuentes</strong></p><ul><li><a href="https://huggingface.co/LiquidAI/LFM3-1.7B">LiquidAI/LFM3–1.7B — model card en Hugging Face</a></li><li><a href="https://local-ai-zone.github.io/blog/lfm3-deep-dive.html">LFM3 deep dive — GGUF Discovery</a></li><li><a href="https://www.marktechpost.com/2026/10/27/liquid-ai-lfm3-open-weight-2b-multimodal-models/">Liquid AI LFM3: open-weight 2B multimodal models — MarkTechPost</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8d1982b53a28" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Voice Assistant That Doesn’t Burn Tokens]]></title>
            <link>https://medium.com/@osvaldorioz/a-voice-assistant-that-doesnt-burn-tokens-3c5c1159dc82?source=rss-2a458f33daac------2</link>
            <guid isPermaLink="false">https://medium.com/p/3c5c1159dc82</guid>
            <category><![CDATA[ai-voice-model]]></category>
            <category><![CDATA[tts]]></category>
            <category><![CDATA[stt]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[llm]]></category>
            <dc:creator><![CDATA[Osvaldo Rios Zambrano]]></dc:creator>
            <pubDate>Sun, 25 Oct 2026 23:56:07 GMT</pubDate>
            <atom:updated>2026-10-25T23:56:07.217Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Whisper, Gemma 4 E4B, Piper, and Chatterbox: how I built a “math tutor” you talk to and that answers back in Spanish, without sending a single byte to the cloud.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/874/1*H3dEwmolRtY5iNv-ifq2MQ.jpeg" /></figure><p>In this article I show how far you can get with open models running on a single machine with an NVIDIA GPU. The result is an assistant with a web interface: you press a button, ask a math question out loud, and a “Tutor” answers you in Spanish. Everything runs on my computer.</p><p>I also describe the architecture, the decisions I made at each stage, and the problems I solved along the way.</p><h3>The architecture in one line</h3><pre>🎙️ Human voice → Whisper large-v3-turbo (GPU) → Gemma 4 E4B (local) → Piper / Chatterbox → 🔊 Audio</pre><p>There are four models, and all four are downloaded once and then run offline:</p><ol><li><strong>Speech to text:</strong> Whisper large-v3-turbo with faster-whisper, on CUDA in float16.</li><li><strong>The brain:</strong> Gemma 4 E4B, served locally with Ollama, with a math teacher <em>skill</em>.</li><li><strong>Text to speech:</strong> Piper with the two Mexican voices that exist, es_MX-claude-high and es_MX-ald-medium, which are called Claudia and Aldo in the interface.</li><li><strong>Cloned voices (optional):</strong> Chatterbox Multilingual, which imitates anyone’s voice from 10 to 20 seconds of audio.</li></ol><p>On top of everything there is a small Flask server (app.py) and a single HTML page with a microphone button.</p><h3>Why everything local?</h3><p>Before getting into the code, it’s worth explaining why it mattered so much to me that nothing left the machine.</p><ul><li><strong>Privacy.</strong> Voice is biometric data. For me it’s essential that the audio never leaves the computer.</li><li><strong>Zero cost per use.</strong> You don’t pay per minute of audio or per token. Once the models are downloaded, you can use them all day.</li><li><strong>Predictable latency.</strong> You don’t depend on the network. With the GPU, Whisper transcribes a sentence in under a second.</li><li><strong>Full control.</strong> I can change the model, the <em>prompt</em>, and the vocabulary without depending on an external provider.</li><li><strong>Works without internet.</strong> You can literally disconnect from Wi-Fi after the first run.</li></ul><h3>Step 1: Listening with Whisper</h3><p>For transcription I used <a href="https://github.com/SYSTRAN/faster-whisper">faster-whisper</a>, a reimplementation of Whisper on top of CTranslate2 that is several times faster than the original.</p><p>I started with the small model on CPU, and it worked, but it got confused by words that sound alike. My favorite test sentence was &quot;Tengo tres gatitos que se llaman Pipo, Coco y Kiwi&quot; (&quot;I have three kittens named Pipo, Coco, and Kiwi&quot;), which small transcribed as &quot;Tengo tres <strong>latitos</strong>…&quot; (&quot;I have three little cans…&quot;). Switching to large-v3-turbo on the GPU fixed most of these errors and, as a bonus, brought the response time under one second.</p><pre>dispositivo = elegir_dispositivo(args.dispositivo)        # &quot;cuda&quot; if there&#39;s an NVIDIA GPU<br>tipo = &quot;float16&quot; if dispositivo == &quot;cuda&quot; else &quot;int8&quot;<br>modelo = WhisperModel(&quot;large-v3-turbo&quot;, device=dispositivo, compute_type=tipo)</pre><p>If the card is older than the RTX 20 series and doesn’t handle float16 efficiently, the program automatically falls back to int8.</p><h3>Three layers to bring Whisper closer to Mexican Spanish</h3><p>A bigger model helps, but it doesn’t solve everything. I added three simple mechanisms:</p><ol><li><strong>An initial context with vocabulary typical of Mexico.</strong> Whisper accepts an initial_prompt that biases the style and spelling of the transcription:</li></ol><pre>CONTEXTO_MX = (<br>    &quot;Transcripción en español de México. Ciudad de México, Guadalajara, Monterrey, &quot;<br>    &quot;Xochimilco, chamba, ahorita, órale, ¿qué onda?, camión, pesos.&quot;<br>)</pre><p><strong>2. A custom vocabulary file</strong> (vocabulario.txt), with one word per line, passed as hotwords. This is where proper names, pets, and terms you use often go.</p><p><strong>3. A corrections file</strong> (correcciones.txt) with rules like latitos =&gt; gatitos, applied to whole words after transcription.</p><p>Both files are re-read on every transcription, so you can edit them while the program is running. The full call looks like this:</p><pre>segmentos, _ = modelo.transcribe(<br>    ruta_audio,<br>    language=&quot;es&quot;,<br>    initial_prompt=CONTEXTO_MX,<br>    hotwords=vocabulario() or None,<br>    vad_filter=True,                    # skips silences<br>    beam_size=5,<br>    condition_on_previous_text=False,   # keeps one error from dragging into the next<br>)<br>texto = corregir(&quot; &quot;.join(s.text.strip() for s in segmentos))</pre><p>To use the GPU you don’t need to install the full CUDA Toolkit. The libraries NVIDIA publishes on PyPI are enough:</p><pre>pip install nvidia-cublas-cu12 &quot;nvidia-cudnn-cu12==9.*&quot;</pre><p>The problem is that, even when they’re installed, the system doesn’t always find them, and the libcublas.so.12 not found error doesn&#39;t show up until the first transcription. The fix was to preload them at startup by searching inside the nvidia package:</p><pre>def precargar_cuda():<br>    import nvidia<br>    for base in nvidia.__path__:<br>        for patron in (&quot;cublas/lib/libcublas*.so.*&quot;, &quot;cudnn/lib/libcudnn*.so.*&quot;):<br>            for lib in glob.glob(str(Path(base) / patron)):<br>                ctypes.CDLL(lib, mode=ctypes.RTLD_GLOBAL)</pre><p>On top of that, the program checks at startup whether cuBLAS is available. If it sees the GPU but not the libraries, it prints the exact command to install them and continues on CPU instead of failing mid-use. This saved me when I discovered I was running the program from the wrong virtual environment, one that didn’t have those libraries.</p><blockquote><strong><em>Tip:</em></strong><em> pin </em><em>av&lt;16 in your </em><em>requirements.txt. Newer versions of PyAV break audio decoding in faster-whisper 1.2.</em></blockquote><h3>Step 2: Thinking with Gemma 4 E4B, also local</h3><p>With the transcribed text, the next step is to generate an answer. Here I chose <strong>Gemma 4 E4B</strong>, Google DeepMind’s open model designed for edge devices. I run it with <a href="https://ollama.com/">Ollama</a>, which downloads it, quantizes it, and exposes an OpenAI-compatible API on localhost:</p><pre>ollama pull gemma4:e4b<br>ollama serve          # listens on http://localhost:11434</pre><p>Why E4B and not a bigger model?</p><ul><li><strong>It fits alongside Whisper and Chatterbox on the same GPU.</strong> It’s a small model (“effective” 4 billion parameters), so it leaves memory for the other models in the pipeline.</li><li><strong>It responds fast.</strong> For a spoken answer of four or five sentences, latency matters much more than the ability to write essays.</li><li><strong>It speaks Spanish well</strong> and follows style instructions with real discipline, which is exactly what a voice assistant needs.</li><li><strong>Apache 2.0 license</strong>, which lets you use and redistribute it without strange restrictions.</li></ul><p>Since Ollama speaks the same protocol as the OpenAI API, the Python client is minimal. The asistente.py module keeps the history of the last ten turns and re-reads the <em>skill</em> on every question:</p><pre>from openai import OpenAI<br><br>cliente = OpenAI(base_url=&quot;http://localhost:11434/v1&quot;, api_key=&quot;ollama&quot;)  # local, no real key<br><br>class Asistente:<br>    def __init__(self, archivo_skill, modelo=&quot;gemma4:e4b&quot;):<br>        self.modelo = modelo<br>        self.archivo_skill = archivo_skill<br>        self.historial = []<br><br>    def responder(self, texto):<br>        mensajes = [{&quot;role&quot;: &quot;system&quot;, &quot;content&quot;: self.archivo_skill.read_text()}]<br>        mensajes += self.historial[-20:]                 # last 10 turns<br>        mensajes.append({&quot;role&quot;: &quot;user&quot;, &quot;content&quot;: texto})<br>        r = cliente.chat.completions.create(<br>            model=self.modelo, messages=mensajes, temperature=0.4, max_tokens=400,<br>        )<br>        respuesta = r.choices[0].message.content.strip()<br>        self.historial += [{&quot;role&quot;: &quot;user&quot;, &quot;content&quot;: texto},<br>                           {&quot;role&quot;: &quot;assistant&quot;, &quot;content&quot;: respuesta}]<br>        return respuesta</pre><p>The api_key=&quot;ollama&quot; is just a placeholder the library requires. There&#39;s no account or external service behind it.</p><h3>The skill: writing for the ear, not the screen</h3><p>The most interesting part of this stage wasn’t the code but the system <em>prompt</em>, which lives in an editable file called profesor.md. An LLM normally answers with Markdown, bullet points, and LaTeX formulas. All of that sounds awful when a synthetic voice reads it out loud (&quot;asterisk asterisk x to the power of two…&quot;).</p><p>So the <em>skill</em> asks the model to write in order to be <strong>heard</strong>. The prompt is in Spanish because the assistant speaks Spanish:</p><pre>Eres &quot;Profe&quot;, un profesor de matemáticas paciente y amable que habla español de México.<br><br>Tus respuestas se van a ESCUCHAR, no a leer, porque se convierten a voz. Por eso:<br>- Responde en frases cortas y naturales, como si hablaras en clase. Máximo 6 frases,<br>  salvo que te pidan una explicación paso a paso.<br>- Nunca uses Markdown, viñetas, tablas, LaTeX, emojis ni símbolos raros.<br>- Escribe las operaciones con palabras: &quot;dos x al cuadrado más tres x menos cinco&quot;,<br>  &quot;la raíz cuadrada de dieciséis es cuatro&quot;, &quot;un medio&quot;, &quot;pi&quot;, &quot;por&quot;, &quot;entre&quot;.<br>- Si la solución tiene pasos, dilos con &quot;Primero…&quot;, &quot;Después…&quot;, &quot;Por último…&quot;.<br>- Al final, cuando sirva, haz una pregunta corta para comprobar que se entendió.</pre><p>In English, it says roughly this:</p><pre>You are &quot;Profe&quot;, a patient and kind math teacher who speaks Mexican Spanish.<br><br>Your answers will be HEARD, not read, because they are converted to speech. Therefore:<br>- Answer in short, natural sentences, as if you were talking in class. At most 6 sentences,<br>  unless you are asked for a step-by-step explanation.<br>- Never use Markdown, bullet points, tables, LaTeX, emojis, or unusual symbols.<br>- Write operations in words: &quot;two x squared plus three x minus five&quot;,<br>  &quot;the square root of sixteen is four&quot;, &quot;one half&quot;, &quot;pi&quot;, &quot;times&quot;, &quot;divided by&quot;.<br>- If the solution has steps, say them with &quot;First…&quot;, &quot;Then…&quot;, &quot;Finally…&quot;.<br>- At the end, when useful, ask a short question to check that it was understood.</pre><p>Another instruction turned out to be very useful: <em>“If something you heard doesn’t make sense, it may be a speech transcription error: interpret the most likely meaning or ask the user to repeat it.”</em> With that, the LLM becomes a second correction layer for the Whisper errors that the vocabulary and the rules don’t catch.</p><p>Since the file is re-read on every question, you can turn the Profe into a history tutor, a practice interviewer, a financial analyst, or whatever you want, without restarting anything.</p><h3>Step 3: Speaking in Spanish</h3><p>For the voice I tried several options and settled on <a href="https://github.com/OHF-Voice/piper1-gpl">Piper</a>. The reasons:</p><ul><li>It has voices trained with Spanish-speaking voice actors.</li><li>It’s a VITS model exported to ONNX, so lightweight that it generates audio almost in real time on CPU. It doesn’t even need the GPU (although it can use one with onnxruntime-gpu).</li><li>Each voice weighs about 100 MB and is downloaded only once.</li></ul><p>Other options sound great but didn’t fit: Kokoro has no voices with a Mexican accent, and XTTS doesn’t allow commercial use.</p><p>The limitation is that Piper has only <strong>two Mexican voices</strong>, but I only use Claudia. Aldo seems to have a problem, since it sounds very slow, so I didn’t include it:</p><pre>VOCES = {<br>    &quot;Claudia&quot;: &quot;es_MX-claude-high&quot;,<br>}</pre><p>Before synthesis, the text goes through a small normalization step so it’s read “the Mexican way”: $1,500.50 becomes &quot;1500.50 pesos&quot;, CDMX becomes &quot;Ciudad de México&quot;, Lic. becomes &quot;licenciado&quot;, and so on with other common abbreviations.</p><pre>def normalizar_mx(texto):<br>    texto = re.sub(r&quot;\$\s?([\d,]+(?:\.\d+)?)&quot;,<br>                   lambda m: m.group(1).replace(&quot;,&quot;, &quot;&quot;) + &quot; pesos&quot;, texto)<br>    for patron, reemplazo in {r&quot;\bCDMX\b&quot;: &quot;Ciudad de México&quot;,<br>                              r&quot;\bLic\.&quot;: &quot;licenciado&quot;, r&quot;\bDr\.&quot;: &quot;doctor&quot;}.items():<br>        texto = re.sub(patron, reemplazo, texto)<br>    return texto</pre><h3>Step 4: More Mexican voices with cloning (Chatterbox)</h3><p>Two voices aren’t enough. To get more, I integrated <a href="https://github.com/resemble-ai/chatterbox">Chatterbox Multilingual</a> by Resemble AI, MIT-licensed and with Spanish support. You give it 10 to 20 seconds of audio of a person speaking, and it generates any text in that voice.</p><p>The integration is deliberately simple: you put one audio file per voice in a folder, and the file name is the name that appears in the dropdown.</p><pre>voces_clonadas/<br>    Mariana.wav<br>    Andres.wav</pre><p>At startup, the program prepares each voice’s “conditionals” once and stores them. On each request it only activates the one it needs:</p><pre>self.modelo = ChatterboxMultilingualTTS.from_pretrained(device=&quot;cuda&quot;)<br>for audio in carpeta.iterdir():<br>    self.modelo.prepare_conditionals(str(audio))<br>    self.condiciones[audio.stem] = self.modelo.conds<br><br>def sintetizar_wav(self, nombre, texto, wav):<br>    with self.candado:                       # avoids mixing voices across requests<br>        self.modelo.conds = self.condiciones[nombre]<br>        audio = self.modelo.generate(texto, language_id=&quot;es&quot;)</pre><p>A few things worth knowing:</p><ul><li>The first run downloads about 3 GB. After that, like everything else, it runs offline.</li><li>On the GPU it takes about one second per sentence, slower than Piper, but still usable in conversation.</li><li>All the audio it generates carries an <strong>inaudible watermark</strong> (Perth), which I think is good practice.</li><li>Only use voices of people who have given you permission.</li></ul><h3>The most cryptic error of the project</h3><p>When loading Chatterbox I ran into this:</p><pre>self.watermarker = perth.PerthImplicitWatermarker()<br>TypeError: &#39;NoneType&#39; object is not callable</pre><p>The cause: the watermarking library imports pkg_resources, which setuptools 81 no longer includes. When that import fails, the library swallows the error and leaves the class as None. The fix is one line:</p><pre>pip install &quot;setuptools&lt;81&quot;</pre><p>Now the program imports that module directly before loading Chatterbox, so it shows the real cause if something fails. If the cloned voices can’t load, it warns you and keeps working with Claudia and Aldo instead of stopping.</p><h3>The interface: one button and nothing else</h3><p>The frontend is a single HTML page with no frameworks. It uses the browser’s MediaRecorder to record and talks to the Flask server through four routes:</p><ul><li>POST /transcribir receives the audio and returns the text (Whisper).</li><li>POST /preguntar receives the text and returns the Profe&#39;s answer (Gemma 4 E4B).</li><li>POST /hablar receives a text and a voice, and returns a WAV (Piper or Chatterbox).</li><li>POST /reiniciar clears the history to start a new conversation.</li></ul><p>The user flow is: you press the microphone (it turns red and pulses while recording), you speak, you press it again, your question appears as a bubble on the right, and the Profe’s answer appears on the left while it plays. You can tap any bubble to hear it again, pick the voice in the dropdown, and edit the greeting by tapping it.</p><p>The server listens only on 127.0.0.1, so not even other computers on your network can use it.</p><p>To start it:</p><pre>pip install -r requirements.txt<br>pip install nvidia-cublas-cu12 &quot;nvidia-cudnn-cu12==9.*&quot;     # NVIDIA GPU<br>pip install -r requirements-clonacion.txt                    # optional, cloned voices<br>ollama pull gemma4:e4b<br><br>python app.py --modelo large-v3-turbo --voz Aldo --saludo &quot;¡Qué gusto verte de nuevo!&quot;</pre><h3>What I learned</h3><p><strong>1. The bottleneck isn’t quality, it’s integration.</strong> Each model works well on its own. The hard part was getting them to coexist: PyTorch versions, CUDA libraries, setuptools, PyAV, and two virtual environments with different things installed. Much of the defensive code in app.py exists so that, when something is missing, the program says exactly what to install instead of failing with a cryptic error.</p><p><strong>2. Writing for voice is a different discipline.</strong> The <em>prompt</em> that asks the LLM to “say” the math in words did more for the experience than any technical tweak.</p><p><strong>3. A small, well-directed model is enough.</strong> Gemma 4 E4B turns out to be an excellent model for patiently explaining a quadratic equation. What really matters is a skill with good instructions and low latency.</p><p><strong>4. Localization matters.</strong> An initial_prompt with Spanish words, a custom vocabulary, and normalizing &quot;$&quot; to &quot;pesos&quot; are small details that let the assistant understand local expressions.</p><p><strong>5. Local no longer means “toy”.</strong> The whole pipeline fits on a consumer GPU, answers in a second, and you don’t pay for tokens or characters on every question.</p><p><em>Tools used: </em><a href="https://github.com/SYSTRAN/faster-whisper"><em>faster-whisper</em></a><em>, </em><a href="https://ollama.com/"><em>Ollama</em></a><em> with Gemma 4 E4B, </em><a href="https://github.com/OHF-Voice/piper1-gpl"><em>Piper</em></a><em>, </em><a href="https://github.com/resemble-ai/chatterbox"><em>Chatterbox</em></a><em>, and </em><a href="https://flask.palletsprojects.com/"><em>Flask</em></a><em>.</em></p><h3>References</h3><ul><li><a href="https://github.com/osvaldorioz-ris/voice2text">https://github.com/osvaldorioz-ris/voice2text</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3c5c1159dc82" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Microservicios híbridos con Python y C++ usando pybind11]]></title>
            <link>https://medium.com/@osvaldorioz/microservicios-h%C3%ADbridos-con-python-y-c-usando-pybind11-0f8983c47e13?source=rss-2a458f33daac------2</link>
            <guid isPermaLink="false">https://medium.com/p/0f8983c47e13</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[pybind11]]></category>
            <category><![CDATA[c-plus-plus-language]]></category>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[microservices]]></category>
            <dc:creator><![CDATA[Osvaldo Rios Zambrano]]></dc:creator>
            <pubDate>Wed, 21 Oct 2026 03:10:06 GMT</pubDate>
            <atom:updated>2026-10-22T17:13:30.361Z</atom:updated>
            <content:encoded><![CDATA[<h3>Por qué un microservicio híbrido</h3><p>Un microservicio híbrido deja en Python todo lo que cambia seguido (la API, la validación, la orquestación) y mueve a C++ solo el cálculo que cuesta CPU. pybind11 es el puente: convierte una función de C++ en un módulo que Python importa como cualquier otro.</p><p>La combinación que me ha funcionado es esta:</p><ul><li><strong>Python:</strong> FastAPI, modelos de entrada con Pydantic, manejo de errores HTTP, logs, acceso a bases de datos y a la nube.</li><li><strong>C++:</strong> ciclos sobre millones de valores, lógica que no se puede vectorizar con NumPy, estructuras de datos propias y código que debe soltar el GIL para correr en paralelo.</li></ul><p>En este artículo armo un servicio pequeño de punta a punta: una función de ventanas móviles en C++, su compilación a un módulo .so, y un endpoint de FastAPI que la usa. Todos los comandos están probados con Python 3.13, g++ 13.3, CMake 3.28 y pybind11 3.1.</p><h3>Por qué vale la pena: los números</h3><p>Cambiar una sola función de Python por su versión en C++, dentro del mismo servicio FastAPI, llevó el endpoint de 16 a 465 peticiones por segundo y bajó su latencia mediana de 57.6 ms a 2.0 ms. Con 8 clientes simultáneos la diferencia crece a 15 contra 849 peticiones por segundo, porque la versión en C++ usa los dos núcleos y la de Python no puede.</p><p>La prueba es una tarea típica de un servicio: encontrar el texto más parecido dentro de un catálogo de 1,000 cadenas, con distancia de Levenshtein. Los dos endpoints son idénticos salvo por una línea:</p><pre>@app.get(&quot;/py&quot;)<br>def endpoint_py(q: str):<br>    return {&quot;idx&quot;: py_best_match([q], catalogo)[0]}     # Python puro<br><br>@app.get(&quot;/cpp&quot;)<br>def endpoint_cpp(q: str):<br>    return {&quot;idx&quot;: lev.best_match([q], catalogo)[0]}    # C++ con pybind11</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/882/1*6bPK60cHMt88CcKiTmIOlQ.png" /><figcaption>Medido con uvicorn y httpx sobre localhost, en un Intel Xeon de 2 vCPU a 2.1 GHz, Python 3.13 y g++ 13.3 con -O3. Las dos versiones devuelven las mismas coincidencias.</figcaption></figure><p>En la práctica, esa diferencia decide cuántas réplicas pagas. Atender 800 peticiones por segundo en esta prueba requiere un contenedor con C++ y más de 50 con Python puro.</p><p>Tres efectos se suman para explicar el salto.</p><h3>1. C++ es 94× más rápido donde NumPy no ayuda</h3><p>Levenshtein es un doble ciclo en el que cada celda depende de las anteriores, así que no se puede convertir en una operación vectorizada de NumPy. Comparar 40 consultas contra 1,000 cadenas toma 2.71 s en Python puro y 29 ms en C++. El promedio móvil de la Parte 4 cuenta la misma historia: 33× más rápido que Python puro.</p><p>El núcleo de la versión en C++ es el mismo algoritmo, escrito como ciclos simples sobre memoria contigua:</p><pre>std::vector&lt;int&gt; best_match(const std::vector&lt;std::string&gt;&amp; consultas,<br>                            const std::vector&lt;std::string&gt;&amp; catalogo) {<br>    std::vector&lt;int&gt; salida(consultas.size());<br>    py::gil_scoped_release sin_gil;           // los hilos de Python siguen corriendo<br>    for (size_t q = 0; q &lt; consultas.size(); ++q) {<br>        int mejor = 1 &lt;&lt; 30, idx = -1;<br>        for (size_t c = 0; c &lt; catalogo.size(); ++c) {<br>            int d = levenshtein(consultas[q], catalogo[c]);<br>            if (d &lt; mejor) { mejor = d; idx = c; }<br>        }<br>        salida[q] = idx;<br>    }<br>    return salida;<br>}</pre><h3>2. El GIL: por qué Python no aprovecha el procesador</h3><p>El GIL (Global Interpreter Lock) es un candado dentro de CPython: solo un hilo a la vez puede ejecutar código Python. Los hilos sirven para esperar red o disco, pero no para repartir cálculo entre núcleos. En Python 3.13 estándar, repartir la búsqueda en 2 hilos la hizo más lenta, no más rápida (0.93×), porque los hilos se turnan el candado.</p><p>El código C++ puede soltar el GIL mientras no toque objetos de Python. Eso hace py::gil_scoped_release, y con él la misma búsqueda corrió 1.95× más rápido en 2 hilos. FastAPI ejecuta los endpoints def en un grupo de hilos, así que cada petición calcula en su propio núcleo. Por eso la capacidad de la versión en C++ crece con los clientes simultáneos, mientras la de Python se queda plana en 15 a 16 peticiones por segundo.</p><h3>¿Y si ya no hay GIL? Python 3.14 y 3.15</h3><p>Python ya tiene una versión sin GIL, pero todavía no es la versión que se instala comúnmente:</p><ul><li><strong>Python 3.13</strong> trajo la compilación sin GIL (<em>free-threaded</em>, ejecutable python3.13t) como experimento (<a href="https://peps.python.org/pep-0703/">PEP 703</a>).</li><li><strong>Python 3.14</strong> la volvió oficialmente soportada, pero opcional: la versión normal sigue teniendo GIL (<a href="https://peps.python.org/pep-0779/">PEP 779</a>, aceptado en junio de 2025).</li><li><strong>Python 3.15</strong>, publicado el 9 de octubre de 2026, sigue con dos compilaciones separadas. Los instaladores oficiales de macOS ya incluyen la versión sin GIL y llega un ABI estable para extensiones sin GIL (<a href="https://www.python.org/downloads/release/python-3150/">notas de la versión</a>).</li><li>Volverla la opción por defecto requiere otro PEP. Thomas Wouters, del equipo de CPython, estimó a título personal que ocurrirá después de 3.16 (2027) y antes de 3.20 (2031) (<a href="https://lwn.net/Articles/1078367/">LWN</a>).</li></ul><p>La pregunta importante es si quitar el GIL hace innecesario el C++. Lo medí: instalé Python 3.14.6 sin GIL y corrí la misma búsqueda en la misma máquina de 2 vCPU.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/886/1*poQLRCMgoT0zCjm7UXSNog.png" /><figcaption>Tiempo por consulta contra un catálogo de 1,000 cadenas; menos es mejor.</figcaption></figure><p>Sin GIL, Python sí escala: 2 hilos lo hacen 1.78× más rápido. Pero cada núcleo sigue ejecutando el mismo intérprete lento. Con 2 hilos, Python sin GIL tarda 32.6 ms por consulta y C++ tarda 0.31 ms: 105× de diferencia. Quitar el GIL resuelve el paralelismo, no la velocidad por núcleo, y la velocidad por núcleo era el factor grande (unas 95 veces). Con GIL o sin él, mover el ciclo caliente a C++ sigue siendo la mejor opción.</p><p>Hay un detalle práctico. Si cargas en Python sin GIL un módulo que no declara ser compatible, Python vuelve a activar el GIL para todo el proceso y lo avisa:</p><pre>RuntimeWarning: The global interpreter lock (GIL) has been enabled to load module &#39;lev&#39;,<br>which has not declared that it can run safely without the GIL.</pre><p>En pybind11 la declaración es un argumento extra en el módulo. Antes de agregarlo, revisa que tu C++ no comparta variables globales mutables entre hilos:</p><pre>PYBIND11_MODULE(lev, m, py::mod_gil_not_used()) {<br>    m.def(&quot;best_match&quot;, &amp;best_match);<br>}</pre><p>Se compila con el mismo comando de la Parte 2, usando el intérprete sin GIL. El sufijo cambia a .cpython-314t-x86_64-linux-gnu.so; la t indica <em>free-threaded</em>, y un .so compilado para 3.14 normal no carga en 3.14t.</p><h3>3. Sin red entre la API y el cálculo</h3><p>La alternativa habitual es poner el C++ en su propio microservicio. Eso agrega un salto de red a cada petición. En esta misma máquina, una ida y vuelta por localhost a un endpoint mínimo de FastAPI tomó 1.3 ms en la mediana y 2.6 ms en el p99, antes de hacer cualquier trabajo. Llamar una función a través de pybind11 cuesta unos 100 nanosegundos, alrededor de 10,000 veces menos. Un servidor HTTP en C++ recortaría parte de ese tiempo, pero siguen siendo factores a considerar la serialización, la red y un servicio más que desplegar y monitorear.</p><h3>Python es un lenguaje pegamento, y así se diseñó</h3><p>Combinar Python con un lenguaje compilado no es un truco: es para lo que Python se pensó. En 1998, Guido van Rossum describió a Python como el pegamento que conecta componentes escritos en C y C++. El código donde importa el desempeño se queda en el lenguaje compilado, y Python controla el flujo y la configuración (<a href="https://www.python.org/doc/essays/omg-darpa-mcc-position/">ensayo en python.org</a>). La wiki de Python dedica una página entera a ese tema(<a href="https://wiki.python.org/moin/AdvocacyWritingTasks/GlueLanguage">Python as a Glue Language</a>).</p><p>Las librerías que hacen rápido a Python siguen ese patrón, y no todas usan C++:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/744/1*wGgARYlqSsnmLONCBYrVEA.png" /></figure><p>Cada import numpy ya es un sistema híbrido: el código en Python llama a C y a Fortran sin que se note. Incluso el ejemplo de este artículo valida con Pydantic, cuyo núcleo está en Rust. pybind11 solo da la misma herramienta para tu propio código: cuando el cálculo que te frena no existe en ninguna librería, lo escribes tú en C++ y lo importas igual.</p><p>Por eso no conviene reescribir todo el servicio en C++. Ganarías velocidad, pero perderías FastAPI, Pydantic, los drivers de bases de datos, los SDK de la nube y la productividad del equipo. Con pybind11 solo el ciclo pesado pasa a C++, normalmente unas decenas de líneas. Todo lo demás se queda en Python.</p><p>La regla que sigo es simple: primero perfilar, y llevar a C++ solo la función que domina el tiempo. Si esa función es una operación vectorizable, NumPy suele bastar. Si es lógica secuencial o con estado, la ganancia va de 30× a 100× por llamada, más paralelismo real, con GIL o sin él.</p><h3>Arquitectura</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nfBo1ysQPxwpWPshz_ZonQ.png" /><figcaption>La petición entra por FastAPI, pasa por el enlace de pybind11 y llega al núcleo en C++; todo ocurre en el mismo proceso, así que no hay latencia de red ni serialización entre lenguajes.</figcaption></figure><h3>Parte 1: el núcleo en C++</h3><p>El ejemplo calcula dos indicadores de una serie diaria: un promedio móvil que ignora días sin dato (NaN) y un cuantil empírico. Es el tipo de cálculo que aparece en pronóstico de demanda, monitoreo o detección de anomalías.</p><p>La estructura del proyecto queda así:</p><pre>hibrido/<br>├── src/<br>│   └── ventanas.cpp      # núcleo de cálculo + enlace pybind11<br>├── CMakeLists.txt        # compilación con CMake (opcional)<br>├── app.py                # microservicio FastAPI<br>└── Dockerfile</pre><p>El archivo src/ventanas.cpp tiene cuatro bloques. Se revisan uno por uno.</p><h3>1.1 Encabezados</h3><pre>#include &lt;pybind11/pybind11.h&gt;   // núcleo de pybind11<br>#include &lt;pybind11/numpy.h&gt;      // py::array_t, para arreglos de NumPy<br>#include &lt;pybind11/stl.h&gt;        // conversión automática list &lt;-&gt; std::vector<br><br>#include &lt;algorithm&gt;<br>#include &lt;cmath&gt;<br>#include &lt;stdexcept&gt;<br>#include &lt;vector&gt;<br><br>namespace py = pybind11;</pre><p>stl.h es el que permite que una lista de Python llegue como std::vector&lt;double&gt; sin escribir código de conversión. numpy.h da acceso directo a la memoria de un arreglo de NumPy.</p><h3>1.2 Funciones puras de C++</h3><p>Estas funciones no saben que existe Python. Se pueden probar con un main() o con GoogleTest como cualquier código C++.</p><pre>// Promedio móvil que ignora NaN (días sin dato)<br>std::vector&lt;double&gt; promedio_movil(const double* x, std::size_t n, std::size_t ventana) {<br>    std::vector&lt;double&gt; salida(n, std::nan(&quot;&quot;));<br>    double suma = 0.0;<br>    std::size_t validos = 0;<br>    for (std::size_t i = 0; i &lt; n; ++i) {<br>        if (!std::isnan(x[i])) { suma += x[i]; ++validos; }<br>        if (i &gt;= ventana &amp;&amp; !std::isnan(x[i - ventana])) { suma -= x[i - ventana]; --validos; }<br>        if (i + 1 &gt;= ventana &amp;&amp; validos &gt; 0) salida[i] = suma / validos;<br>    }<br>    return salida;<br>}<br><br>// Cuantil empírico con interpolación lineal (ignora NaN)<br>double cuantil(std::vector&lt;double&gt; v, double q) {<br>    v.erase(std::remove_if(v.begin(), v.end(), [](double d) { return std::isnan(d); }), v.end());<br>    if (v.empty()) return std::nan(&quot;&quot;);<br>    std::sort(v.begin(), v.end());<br>    double pos = q * (v.size() - 1);<br>    std::size_t lo = static_cast&lt;std::size_t&gt;(std::floor(pos));<br>    std::size_t hi = std::min(lo + 1, v.size() - 1);<br>    return v[lo] + (pos - lo) * (v[hi] - v[lo]);<br>}</pre><p>El promedio móvil usa una suma acumulada que suma el valor que entra y resta el que sale. Es O(n) sin importar el tamaño de la ventana, y en Python puro ese mismo ciclo es lento.</p><h3>1.3 El envoltorio para Python</h3><p>Aquí se decide cómo se ve la función desde Python. Recibe un arreglo de NumPy, valida, suelta el GIL y devuelve otro arreglo.</p><pre>py::array_t&lt;double&gt; py_promedio_movil(<br>        py::array_t&lt;double, py::array::c_style | py::array::forcecast&gt; x,<br>        std::size_t ventana) {<br>    if (x.ndim() != 1) throw std::invalid_argument(&quot;x debe ser un arreglo 1D&quot;);<br>    if (ventana == 0) throw std::invalid_argument(&quot;ventana debe ser mayor que 0&quot;);<br>    auto buf = x.request();<br>    const double* ptr = static_cast&lt;const double*&gt;(buf.ptr);<br>    std::size_t n = static_cast&lt;std::size_t&gt;(buf.shape[0]);<br><br>    std::vector&lt;double&gt; r;<br>    {<br>        py::gil_scoped_release sin_gil;   // otros hilos de Python siguen trabajando<br>        r = promedio_movil(ptr, n, ventana);<br>    }<br>    return py::array_t&lt;double&gt;(r.size(), r.data());<br>}</pre><p>Tres detalles importan:</p><ul><li>c_style | forcecast: si llega un arreglo de enteros o no contiguo, pybind11 lo convierte a float64 contiguo. Si ya viene así, no copia nada y C++ lee la misma memoria que NumPy.</li><li>gil_scoped_release: mientras C++ calcula, el intérprete puede atender otras peticiones. Solo es seguro porque dentro de ese bloque no se toca ningún objeto de Python.</li><li>std::invalid_argument llega a Python como ValueError. pybind11 traduce las excepciones estándar solo.</li></ul><h3>1.4 La declaración del módulo</h3><pre>PYBIND11_MODULE(ventanas, m) {<br>    m.doc() = &quot;Cálculos de ventanas móviles en C++&quot;;<br>    m.def(&quot;promedio_movil&quot;, &amp;py_promedio_movil, py::arg(&quot;x&quot;), py::arg(&quot;ventana&quot;),<br>          &quot;Promedio móvil que ignora NaN&quot;);<br>    m.def(&quot;cuantil&quot;, &amp;cuantil, py::arg(&quot;valores&quot;), py::arg(&quot;q&quot;),<br>          &quot;Cuantil empírico con interpolación lineal&quot;);<br>}</pre><p>El primer argumento, ventanas, es el nombre con el que Python hará import. <strong>Tiene que coincidir con el nombre del archivo </strong><strong>.so</strong>; si no, Python lanza ImportError: dynamic module does not define module export function. py::arg permite llamar con nombres desde Python: ventanas.cuantil(valores=x, q=0.9).</p><h3>Parte 2: compilar el C++</h3><p>El resultado de compilar es un solo archivo, ventanas.cpython-313-x86_64-linux-gnu.so, que Python carga como módulo. Hay dos formas de llegar a él.</p><h3>2.1 Instalar lo necesario</h3><pre># Compilador y encabezados de Python (Ubuntu/Debian)<br>sudo apt install build-essential python3-dev cmake<br><br># pybind11 y las librerías del servicio<br>python3 -m pip install pybind11 numpy fastapi uvicorn</pre><h3>2.2 Compilar a mano, con un solo comando</h3><p>Es la forma más directa y la mejor para entender qué pasa:</p><pre>c++ -O3 -Wall -shared -std=c++17 -fPIC \<br>    $(python3 -m pybind11 --includes) \<br>    src/ventanas.cpp \<br>    -o ventanas$(python3 -c &quot;import sysconfig; print(sysconfig.get_config_var(&#39;EXT_SUFFIX&#39;))&quot;)</pre><p>Cada parte del comando hace esto:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iL1MKgF6H7ImvDLHb_80VQ.png" /></figure><p>Lo que imprime --includes en mi máquina:</p><pre>-I/usr/include/python3.13 -I/usr/local/lib/python3.13/dist-packages/pybind11/include</pre><p><strong>Cuidado con el sufijo.</strong> La documentación de pybind11 usa $(python3-config --extension-suffix). En mi máquina, python3 era 3.13, pero python3-config respondía con el sufijo de 3.12 (.cpython-312-...so). El módulo compilaba bien y luego Python no lo encontraba. Preguntarle el sufijo al mismo python3 con sysconfig evita ese error.</p><p>Para confirmar que salió bien:</p><pre>$ ls -la *.so<br>-rwxr-xr-x 1 root root 263264 Oct 20 19:24 ventanas.cpython-313-x86_64-linux-gnu.so</pre><h3>2.3 Compilar con CMake</h3><p>Cuando el proyecto crece (varios .cpp, librerías externas, pruebas), conviene CMake. Este CMakeLists.txt hace lo mismo que el comando anterior:</p><pre>cmake_minimum_required(VERSION 3.18)<br>project(ventanas LANGUAGES CXX)<br><br>set(CMAKE_CXX_STANDARD 17)<br>set(CMAKE_CXX_STANDARD_REQUIRED ON)<br>if(NOT CMAKE_BUILD_TYPE)<br>  set(CMAKE_BUILD_TYPE Release)<br>endif()<br><br>find_package(Python COMPONENTS Interpreter Development.Module REQUIRED)<br>execute_process(COMMAND &quot;${Python_EXECUTABLE}&quot; -m pybind11 --cmakedir<br>                OUTPUT_VARIABLE pybind11_DIR OUTPUT_STRIP_TRAILING_WHITESPACE)<br>find_package(pybind11 CONFIG REQUIRED)<br><br>pybind11_add_module(ventanas src/ventanas.cpp)</pre><p>pybind11_add_module ya pone -shared, -fPIC, los encabezados y el sufijo correcto. Para compilar:</p><pre>cmake -S . -B build -DPython_EXECUTABLE=$(which python3)<br>cmake --build build -j<br>cp build/ventanas*.so .</pre><p>Pasar -DPython_EXECUTABLE fija el intérprete. Sin eso, CMake puede encontrar otro Python del sistema y compilar para la versión equivocada, el mismo problema del sufijo.</p><h3>Parte 3: cómo se unen el C++ y el Python</h3><p>La unión ocurre en una sola línea: import ventanas. No hay HTTP, sockets ni serialización entre los dos lenguajes. El .so se carga dentro del mismo proceso de Python, y la llamada a ventanas.promedio_movil(x, 3) es una llamada a función.</p><h3>3.1 Cómo encuentra Python el .so</h3><p>Python busca el módulo en las carpetas de sys.path, igual que un .py. La primera es la carpeta del script, así que basta con dejar el .so junto a app.py. Si vive en otro lugar, se agrega la ruta:</p><pre>export PYTHONPATH=/ruta/a/la/carpeta/del/so:$PYTHONPATH</pre><p>El nombre del archivo tiene tres partes y las tres importan:</p><pre>ventanas . cpython-313-x86_64-linux-gnu . so<br>   │              │                        │<br>   │              │                        └─ librería compartida de Linux<br>   │              └─ intérprete, versión y arquitectura<br>   └─ nombre de PYBIND11_MODULE(ventanas, m)</pre><p>Un .so compilado para Python 3.12 no carga en 3.13, y uno de x86_64 no carga en ARM. Por eso el .so se compila en la misma imagen o máquina donde va a correr.</p><h3>3.2 Probarlo desde la consola</h3><pre>&gt;&gt;&gt; import numpy as np, ventanas<br>&gt;&gt;&gt; ventanas.promedio_movil(np.array([1, 2, np.nan, 4, 5, 6.0]), 3)<br>array([nan, nan, 1.5, 3. , 4.5, 5. ])<br>&gt;&gt;&gt; ventanas.cuantil([1, 2, 3, 4, 5], 0.9)<br>4.6<br>&gt;&gt;&gt; ventanas.promedio_movil(np.array([1.0, 2.0]), 0)<br>ValueError: ventana debe ser mayor que 0<br>&gt;&gt;&gt; help(ventanas.cuantil)      # muestra la firma y el docstring de C++</pre><p>El NaN del tercer día no rompe el promedio: la ventana de los días 1 a 3 promedia solo 1 y 2.</p><h3>3.3 El microservicio</h3><p>app.py es FastAPI normal. La única diferencia con un servicio 100 % Python es la línea del import y las dos llamadas marcadas con # C++:</p><pre># app.py<br>import numpy as np<br>from fastapi import FastAPI, HTTPException<br>from pydantic import BaseModel, Field<br><br>import ventanas  # el .so que compilamos<br><br>app = FastAPI(title=&quot;Servicio híbrido Python + C++&quot;)<br><br><br>class Serie(BaseModel):<br>    valores: list[float | None] = Field(..., min_length=1)<br>    ventana: int = Field(7, gt=0)<br>    q: float = Field(0.9, ge=0, le=1)<br><br><br>@app.get(&quot;/salud&quot;)<br>def salud():<br>    return {&quot;estado&quot;: &quot;ok&quot;, &quot;motor&quot;: ventanas.__doc__}<br><br><br>@app.post(&quot;/indicadores&quot;)<br>def indicadores(s: Serie):<br>    # Python: validar y convertir<br>    x = np.array([np.nan if v is None else v for v in s.valores], dtype=np.float64)<br>    try:<br>        pm = ventanas.promedio_movil(x, s.ventana)   # C++<br>        cq = ventanas.cuantil(x.tolist(), s.q)         # C++<br>    except ValueError as e:<br>        raise HTTPException(status_code=422, detail=str(e))<br>    # Python: armar la respuesta<br>    return {<br>        &quot;promedio_movil&quot;: [None if np.isnan(v) else round(float(v), 4) for v in pm],<br>        &quot;cuantil&quot;: None if np.isnan(cq) else round(cq, 4),<br>    }</pre><p>El reparto de responsabilidades queda limpio. Pydantic rechaza una ventana de 0 antes de llegar a C++, y C++ vuelve a validar por si otro código lo llama directo. Los None del JSON se vuelven NaN para C++, y los NaN de regreso se vuelven None para el JSON.</p><p>Uso def y no async def a propósito. FastAPI corre los def en un grupo de hilos; como C++ suelta el GIL, varias peticiones pueden calcular al mismo tiempo en núcleos distintos. Con async def, el cálculo bloquearía el ciclo de eventos.</p><h3>3.4 Levantar el servicio</h3><pre>uvicorn app:app --host 0.0.0.0 --port 8000</pre><pre>$ curl -s -X POST localhost:8000/indicadores \<br>    -H &quot;Content-Type: application/json&quot; \<br>    -d &#39;{&quot;valores&quot;:[120,95,null,130,160],&quot;ventana&quot;:3,&quot;q&quot;:0.9}&#39;<br>{&quot;promedio_movil&quot;:[null,null,107.5,112.5,145.0],&quot;cuantil&quot;:151.0}</pre><h3>Parte 4: probar y medir</h3><h3>4.1 Pruebas</h3><p>Las pruebas se escriben en pytest y cubren las dos capas: el módulo C++ directo y el endpoint completo.</p><pre># test_servicio.py<br>import math<br>import numpy as np<br>from fastapi.testclient import TestClient<br><br>import ventanas<br>from app import app<br><br>cliente = TestClient(app)<br><br><br>def test_cpp_ignora_nan():<br>    r = ventanas.promedio_movil(np.array([1, 2, np.nan, 4.0]), 2)<br>    assert math.isnan(r[0]) and r[1] == 1.5 and r[2] == 2.0 and r[3] == 4.0<br><br><br>def test_endpoint():<br>    r = cliente.post(&quot;/indicadores&quot;, json={&quot;valores&quot;: [120, 95, None, 130, 160], &quot;ventana&quot;: 3, &quot;q&quot;: 0.9})<br>    assert r.status_code == 200<br>    assert r.json() == {&quot;promedio_movil&quot;: [None, None, 107.5, 112.5, 145.0], &quot;cuantil&quot;: 151.0}<br><br><br>def test_ventana_invalida():<br>    assert cliente.post(&quot;/indicadores&quot;, json={&quot;valores&quot;: [1, 2], &quot;ventana&quot;: 0}).status_code == 422</pre><pre>$ python3 -m pytest -q test_servicio.py<br>...                                                  [100%]<br>3 passed in 0.37s</pre><h3>4.2 ¿Cuánto se gana?</h3><p>Medí el promedio móvil de 28 días sobre un millón de valores con 5 % de NaN (mejor de 5 corridas, una sola máquina):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/625/1*xZe7Ke41YuAwlbpfauq4-Q.png" /><figcaption>El resultado de C++ coincide valor por valor con el de Python puro (np.allclose con equal_nan=True).</figcaption></figure><p>¿Qué se puede leer de esta tabla?: contra Python puro, C++ gana por mucho; contra pandas, gana poco más de 2×. Si tu cálculo ya cabe en una operación vectorizada de NumPy o pandas, quizá no necesitas C++. Donde C++ gana es en la lógica que no se vectoriza: reglas con estado, ciclos con condiciones que dependen del paso anterior, búsquedas en estructuras propias, o cuando necesitas soltar el GIL para atender peticiones en paralelo.</p><h3>Parte 5: empaquetar en Docker</h3><p>Como el .so depende de la versión de Python y de la arquitectura, lo compilo dentro de Docker, en la misma imagen base que va a producción. Uso dos etapas: la primera trae el compilador y la segunda solo el resultado.</p><pre># Etapa 1: compilar el módulo C++<br>FROM python:3.12-slim AS compilador<br>RUN apt-get update &amp;&amp; apt-get install -y --no-install-recommends g++ \<br>    &amp;&amp; rm -rf /var/lib/apt/lists/*<br>RUN pip install --no-cache-dir pybind11<br>WORKDIR /build<br>COPY src/ src/<br>RUN c++ -O3 -Wall -shared -std=c++17 -fPIC \<br>      $(python -m pybind11 --includes) src/ventanas.cpp \<br>      -o ventanas$(python -c &quot;import sysconfig; print(sysconfig.get_config_var(&#39;EXT_SUFFIX&#39;))&quot;)<br><br># Etapa 2: imagen final, sin compilador<br>FROM python:3.12-slim<br>WORKDIR /app<br>RUN pip install --no-cache-dir numpy fastapi uvicorn<br>COPY --from=compilador /build/ventanas*.so ./<br>COPY app.py .<br>EXPOSE 8000<br>CMD [&quot;uvicorn&quot;, &quot;app:app&quot;, &quot;--host&quot;, &quot;0.0.0.0&quot;, &quot;--port&quot;, &quot;8000&quot;]</pre><pre>docker build -t hibrido .<br>docker run -p 8000:8000 hibrido</pre><p>Las dos etapas usan la misma imagen base (python:3.12-slim), así que el sufijo del .so coincide con el intérprete final. La imagen que llega a producción no trae g++ ni los encabezados, solo el .so de unos cientos de KB. Si el clúster corre en ARM (Graviton en AWS, por ejemplo), basta construir con docker buildx build --platform linux/arm64.</p><h3>Ejemplos en mis repositorios</h3><p>El mismo patrón lo he usado en cuatro microservicios publicados en GitHub. Todos exponen el cálculo de C++ a través de un endpoint de FastAPI, y cada uno muestra una variante distinta de compilación o despliegue.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HCmoa808hQsSt-GWePnDnw.png" /></figure><h3>py-levenshtein: el comando a mano en producción</h3><p>Es el más cercano al ejemplo de este artículo. El núcleo vive en levenshtein_core.cpp, separado del enlace en binding.cpp, que declara PYBIND11_MODULE(levdes, m). El script .s2i/bin/assemble compila con el mismo comando de la Parte 2, ahora con dos archivos fuente:</p><pre>g++ -O3 -Wall -shared -std=c++14 -fPIC $(python3 -m pybind11 --includes) \<br>    binding.cpp levenshtein_core.cpp \<br>    -o /opt/app-root/src/python/levdes.so</pre><p>Después agrega esa carpeta a PYTHONPATH, y main.py hace import levdes. Las dependencias se instalan desde la carpeta wheels/ con pip install --no-index, así que la imagen se construye sin salida a internet.</p><h3>py-factor-analysis: pybind11 con Eigen</h3><p>Aquí la compilación la hace setuptools con el ayudante de pybind11:</p><pre># setup.py<br>from setuptools import setup<br>from pybind11.setup_helpers import Pybind11Extension<br><br>setup(<br>    name=&quot;fa_module&quot;,<br>    ext_modules=[Pybind11Extension(<br>        &quot;fa_module&quot;, [&quot;factor_analysis.cpp&quot;],<br>        include_dirs=[&quot;/usr/include/eigen3&quot;],<br>        extra_compile_args=[&quot;-O3&quot;],<br>    )],<br>)</pre><pre>python3.12 setup.py build_ext --inplace</pre><p>--inplace deja el .so junto al código, listo para import fa_module. El C++ recibe la matriz de NumPy, la pasa a Eigen para la covarianza y su descomposición, y regresa los factores como arreglo de NumPy.</p><h3>py-isomap-torch: C++ con tensores de PyTorch</h3><p>El módulo incluye &lt;torch/torch.h&gt; y recibe tensores de PyTorch directamente: im.isomap(X_torch, k, d). Para compilar contra LibTorch, setup.py usa CppExtension y BuildExtension de torch.utils.cpp_extension, que agregan solos las rutas y librerías de Torch. El Dockerfile corre python setup.py build_ext --inplace y luego levanta uvicorn.</p><h3>py-cosine-similarity: Python embebido dentro de C++</h3><p>Este invierte la dirección. La clase de C++ CosineSimilarity, expuesta con py::class_, llama desde C++ a sentence_transformers para cargar el modelo, generar los embeddings y calcular la similitud con util.cos_sim. FastAPI crea una sola instancia al arrancar, así el modelo se carga una vez. La carpeta yaml/ trae BuildConfig, ImageStream, Deployment, Service y Route para desplegarlo en OpenShift con oc apply y oc start-build.</p><p>Los cuatro siguen la idea central del artículo: Python atiende HTTP y prepara los datos, y C++ hace el cálculo detrás de un import.</p><h3>Errores comunes y lo que aprendí</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vHboc4TSCY6Z6b7MWV9z9w.png" /></figure><p>Sugerencias:</p><ol><li><strong>Separar el C++ puro del enlace.</strong> Las funciones de cálculo no incluyen nada de pybind11; solo los envoltorios lo conocen. Así el núcleo se prueba y se reutiliza fuera de Python.</li><li><strong>Medir antes de migrar.</strong> Si NumPy o pandas ya resuelven el cálculo con una operación vectorizada, la ganancia de C++ es pequeña. Vale la pena cuando la lógica es secuencial o tiene estado.</li><li><strong>Compilar donde se ejecuta.</strong> El .so está atado al intérprete y a la arquitectura. Compilarlo en el mismo Dockerfile elimina toda una familia de errores.</li></ol><p>El patrón escala bien: el mismo esqueleto sirve para un motor de reglas, un parser binario o el ciclo de inferencia de un modelo pequeño. Python sigue siendo la cara del servicio, y C++ hace el trabajo pesado detrás de un import.</p><h3>Referencias</h3><ul><li><a href="https://pybind11.readthedocs.io/">Documentación de pybind11</a></li><li><a href="https://pybind11.readthedocs.io/en/stable/compiling.html">pybind11: compilar a mano y con CMake</a></li><li><a href="https://fastapi.tiangolo.com/">FastAPI</a></li><li><a href="https://github.com/osvaldorioz/py-cosine-similarity">https://github.com/osvaldorioz</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0f8983c47e13" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A 140M-parameter model on CPU vs.]]></title>
            <link>https://medium.com/@osvaldorioz/a-140m-parameter-model-on-cpu-vs-2762c4c47e71?source=rss-2a458f33daac------2</link>
            <guid isPermaLink="false">https://medium.com/p/2762c4c47e71</guid>
            <category><![CDATA[pytorch]]></category>
            <category><![CDATA[system-1-and-system-2]]></category>
            <category><![CDATA[model-training]]></category>
            <category><![CDATA[jevs]]></category>
            <category><![CDATA[tetris]]></category>
            <dc:creator><![CDATA[Osvaldo Rios Zambrano]]></dc:creator>
            <pubDate>Fri, 09 Oct 2026 18:01:13 GMT</pubDate>
            <atom:updated>2026-10-18T05:51:51.675Z</atom:updated>
            <content:encoded><![CDATA[<h3>A 140M-parameter model on CPU vs. three general-purpose System 1 engines: what I learned training a specialized “System 1” to play Tetris</h3><p><em>How a small encoder, trained by distillation, decided ~20× faster than a general-purpose engine and played at expert level, and the three failed attempts that came first.</em></p><iframe src="https://cdn.embedly.com/widgets/media.html?url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DaKqibBaw10s&amp;type=text%2Fhtml&amp;schema=youtube&amp;display_name=YouTube&amp;src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FaKqibBaw10s" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/a73977977ee3996eeeab5b1663ad5402/href">https://medium.com/media/a73977977ee3996eeeab5b1663ad5402/href</a></iframe><h3>Context: System 1 and System 2 in agentic systems</h3><p>Agentic systems increasingly split the work into two levels, borrowing Kahneman’s idea:</p><ul><li><strong>System 2:</strong> a large LLM that reasons, plans and explains. It is slow and expensive, but flexible.</li><li><strong>System 1:</strong> a small model that makes typed decisions in a single forward pass. It picks among options, places something on a scale or answers yes/no, with a calibrated probability. It is fast and cheap.</li></ul><p>Projects like <strong>Laya</strong> and <strong>OpenJev</strong> offer a <em>general-purpose</em> System 1: a single model that answers any typed question (choice, score, noul) posed on the fly, with no task-specific training. That is very convenient. But at work I had already built a <em>specialized</em> System 1: a small encoder fine-tuned for a fixed set of business decisions, with confidence thresholds that hand off to System 2 whatever it cannot resolve.</p><p>That led to the question behind this experiment:</p><blockquote><strong><em>Does a small encoder, specialized in one task, decide faster than a general-purpose System 1 engine? And at what cost in quality?</em></strong></blockquote><p>I needed a task with an objective, indisputable quality metric, where speed actually matters. I chose <strong>Tetris</strong>.</p><h3>Why Tetris</h3><p>Tetris is close to an ideal testbed for a decision engine:</p><ul><li><strong>Every turn is a typed decision.</strong> Where to place the piece is a choice among a finite number of moves.</li><li><strong>Quality is measurable beyond dispute:</strong> lines cleared, pieces survived, and how closely each move matches an expert’s.</li><li><strong>Decisions compound.</strong> A bad move leaves holes that make the next ones harder. A model that does well on “clean” boards but cannot recover loses quickly. This turned out to be key.</li><li><strong>Speed is visible.</strong> When two engines play side by side, the faster one places more pieces in the same amount of time.</li></ul><h3>Experimental design</h3><h3>The game and the action space</h3><p>I implemented a deterministic Tetris in Python: a 10×20 board, the 7 standard pieces and a seeded 7-bag randomizer, so every engine plays exactly the same sequence.</p><p>A move is the pair <strong>(rotation, column)</strong>: the piece is rotated 0 to 3 times and dropped with its left edge in one of the 10 columns. That gives <strong>40 fixed options</strong>, from r0c0 to r3c9. On any given turn only a subset is valid; depending on the piece, between 9 and 34.</p><h3>The expert</h3><p>As teacher and referee I used the <strong>El-Tetris</strong> heuristic (Pierre Dellacherie): it scores each move with six features of the resulting board (landing height, eroded cells, row and column transitions, holes and wells). It plays almost perfectly: in my tests, <strong>398 lines out of a possible 400 in 1,000 pieces</strong>.</p><h3>The contenders</h3><p>All three AI engines are queried the same way: an <strong>MCP</strong> server with a choice-style tool that receives the board state, an instruction and the options.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/944/1*2zYkaLYuT3_arfEc85oR_w.png" /><figcaption>All the AI engines are queried the same way, with the choice decision protocol (over MCP or over HTTP at /v1/systemone): they receive the board state, an instruction and the options.</figcaption></figure><h3>The model: a small encoder with cached options</h3><h3>Why mmBERT-small</h3><p>I chose jhu-clsp/mmBERT-small, a BERT-family encoder with the ModernBERT architecture, for five reasons:</p><ol><li><strong>It runs well on CPU.</strong> At ~140M parameters, a decision takes a few tens of milliseconds.</li><li><strong>It is an encoder, not a generator.</strong> Deciding does not require writing text. An encoder reads the whole state bidirectionally in a single pass.</li><li><strong>It is multilingual</strong>, so the same pipeline serves English/Spanish-language business tasks.</li><li><strong>Its size suits a mid-sized dataset:</strong> it fine-tunes in minutes on a GPU.</li><li><strong>It exports cleanly to ONNX:</strong> parity with PyTorch was around 1e-6.</li></ol><h3>The decision architecture</h3><p>On top of the encoder sits a decision head built on two core ideas:</p><ol><li><strong>The state is encoded once per decision.</strong> The options (the 40 moves) are encoded separately and <strong>cached</strong>, because they never change. Each turn only the board is processed: <strong>85 tokens</strong>.</li><li><strong>Each option “reads” the state</strong> via cross-attention and competes with the others via self-attention. Because the 40 options are fixed and their identity matters, each position also gets its own embedding (an extension I called <em>positional choice</em>) and a direct classification path over the pooled state, as in classic BERT fine-tuning.</li></ol><p>This is the structural difference from the general-purpose engines. Laya and OpenJev receive state, question and options together on every call; in my measurements, Laya processed <strong>284 tokens per decision</strong> versus 85 for my model.</p><h3>The data: distilling the expert</h3><p>The dataset generates itself:</p><ol><li>The expert plays <strong>1,000 games</strong> of up to 200 pieces, with <strong>15% random moves</strong> to visit a variety of boards.</li><li>For each state, the label is not just the best move but the <strong>expert’s distribution over the valid moves</strong>: softmax(score / T). This is distillation: the model also learns which moves are &quot;almost as good.&quot;</li><li>The split is <strong>by game</strong> (80/10/10), so states from the same game never end up in both training and evaluation.</li></ol><p>Result: <strong>89,110 training states</strong> and <strong>11,613 validation states</strong>.</p><h3>Training: three failed attempts and one good one</h3><p>This was the most instructive part.</p><h3>Attempt 1: the model that didn’t look at the board (11.8%)</h3><p>In the first version, the board was sent as text, row by row, with # for filled cells and . for empty ones:</p><p>…##…..<br>..####….<br>.######…</p><p>After training, the model matched the expert’s move <strong>11.8%</strong> of the time. To know whether that was good or bad, I computed a trivial baseline: always pick the expert’s most frequent move <strong>for that piece, without looking at the board</strong>. That baseline scores <strong>13.8%</strong>.</p><p>The model had learned “what you usually do with a T,” but it ignored the board.</p><p>To rule out an impossible task, I trained a simple neural network (MLP) that receives only the piece and the 10 column heights as numbers: <strong>65% accuracy</strong>. The information was there; the problem was how I presented it to the model.</p><p><strong>The diagnosis:</strong> the tokenizer splits strings like ...##..... into chunks of varying length, and the model loses track of which column each cell is in.</p><h3>Attempt 2: named columns (17% → 42%)</h3><p>I changed the state representation so that every column had a name:</p><p>{“pieza”: “T”, “siguiente”: “S”,<br> “alturas”: “c0=0 c1=0 c2=2 c3=3 c4=3 c5=2 c6=1 c7=0 c8=0 c9=0”,<br> “huecos”: “c3=1”}</p><p><em>(Field names are in Spanish: piece, next piece, column heights, and holes.)</em></p><p>The options use the same labels: <em>“rotated 90°, left edge at c4.”</em> That lets attention align each option with its column. I also added the direct classification path to the head.</p><p>The first epoch gave 17%, which was worrying. But the model was simply a late starter:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/366/1*z_TOteR79EbpLygcGXX5-A.png" /><figcaption><strong>Lesson:</strong> don’t judge a fine-tune by its first epoch.</figcaption></figure><h3>Attempt 3: good on fixed boards, terrible at playing</h3><p>At 41.7%, the model chose reasonable moves on individual boards: its <em>regret</em> (how much score it loses versus the best move) dropped from 61 (random) to 19. But in real games it <strong>lost after 40 pieces</strong>, almost as fast as chance.</p><p>This is the classic imitation-learning problem, <strong>distribution shift</strong>. The dataset comes from expert games, where boards are almost always clean. When the model makes a mistake, it reaches messy boards it has never seen, makes more mistakes, and loses.</p><h3>The fix: DAgger + longer training</h3><p><strong>DAgger</strong> (<em>Dataset Aggregation</em>) targets exactly that:</p><ol><li>The model plays <strong>400 games</strong> (with 30% expert moves mixed in so it doesn’t die too early).</li><li>The expert <strong>labels every board the model visits</strong>, including the ones the model itself made messy.</li><li>The model is retrained on the original dataset plus the new one, this time for <strong>8 epochs</strong>.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/682/1*-JqfwP0R7W1CGoZy6Tl-ZA.png" /><figcaption>With a single round of DAgger, the model went from losing after 40 pieces to playing <strong>practically on par with the expert</strong>.</figcaption></figure><h3>A deployment detail: INT8 isn’t always worth it</h3><p>I exported to ONNX and tried dynamic INT8 quantization. For this model it was a disaster: it agreed with FP32 on only <strong>0–89%</strong> of decisions, depending on the version, in exchange for a mere 10–20% latency saving. The pipeline measures that agreement on every export and falls back to FP32 if INT8 doesn’t clear 98%.</p><h3>How I measured: a fair benchmark</h3><p>Comparing speed across different services is easy to get wrong. These were the rules:</p><ol><li><strong>Same boards for everyone.</strong> The first test uses 300 fixed boards, identical for every engine: latency and agreement with the expert, compared directly.</li><li><strong>Same games.</strong> The second test plays 5 games of up to 200 pieces with the same seeds for everyone.</li><li><strong>The network is subtracted.</strong> For each MCP engine I measure the session <em>ping</em> (a round-trip message with no inference) and report <strong>net latency</strong> = latency − ping. That way Laya isn’t penalized for living in Azure.</li><li><strong>MCP vs. MCP.</strong> My model was also measured behind an MCP server, not only in-process.</li><li><strong>Warm-up.</strong> The first calls are not measured.</li><li><strong>A format that favors the opponent.</strong> Laya and OpenJev only receive <strong>the moves that are valid</strong> on that turn, which is how they work best.</li></ol><h3>Results</h3><h3>Speed</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1002/1*woeuOa4-CgGpV9AXOLix3A.png" /><figcaption>¹ Laya running on a mini PC on my local network (CPU, no GPU); measured in the arena over full games, not on the 300 fixed boards. ² 300-fixed-board benchmark. It includes the internet round trip, which I couldn’t subtract, so the model’s own time is lower.</figcaption></figure><h3>Quality</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/856/1*M4deWsRxhAQ-E24rxVpZOA.png" /><figcaption>My model <strong>plays at expert level</strong>. Laya, zero-shot, <strong>plays at the level of chance</strong>: it loses after about 23 pieces, even sooner than the random player.</figcaption></figure><h3>And OpenJev: on Azure and on an RTX 4060, the same result</h3><p>In a first test against the OpenJev 2B deployment on Azure, each decision took <strong>~4.3 s</strong>. I assumed the deployment wasn’t using the right acceleration, so I brought it up on my own machine, with an <strong>NVIDIA RTX 4060</strong>, next to my model running on CPU.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rKdk9ltHMriO03NsXfihGg.png" /></figure><p><strong>On a local GPU the performance was practically the same as on Azure.</strong> The deployment wasn’t the problem. The cause of the latency became clear when I timed it against the number of options:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/389/1*vbQ-ZctjUiwbyM7KI_sukQ.png" /></figure><p><strong>Latency grows linearly with the number of options, ~153 ms each</strong>: OpenJev evaluates the options one by one. A move with a single possible option took 168 ms. It isn’t missing acceleration; it’s the architecture. For a 17-option decision it processed <strong>2,791 input tokens</strong>, against 84 for my model.</p><p>On quality, on 9 of 9 different boards <strong>it picked r0c0, the first option in the list</strong>, with confidences of 0.08 to 0.26. In the arena it lost in 29 pieces without clearing a line (the random player lasts ~26), with a p50 latency of <strong>3,188 ms on GPU</strong> against <strong>36 ms for my model on CPU</strong>: about 90 times slower.</p><h3>And Jev, the commercial System 1</h3><p>Laya and OpenJev are open projects. To close the comparison I also tested <strong>Jev 1.13</strong>, TypeSafe’s hosted service, which defines the choice/score/noul protocol all these engines use. I queried it through its public API from my machine with the same benchmark: 300 fixed boards and full games of up to 500 pieces.</p><p>I added a variant that <strong>shuffles the order of the options every turn</strong>. If an engine chooses by content, shuffling shouldn’t change its performance; if it chooses by position, it shows.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/998/1*H-L2LMQjleXgH7Lr0pGW7g.png" /></figure><p>Three readings:</p><ul><li><strong>Jev is by far the fastest general-purpose engine:</strong> ~125 ms including the internet round trip, against ~700 ms for Laya on CPU and ~3,200 ms for OpenJev on GPU. Even so, my model decides ~4× faster.</li><li><strong>With moves in the game’s own format, it plays at random.</strong> 9% agreement (the random player gets 9.3%) and game over at ~23 pieces. On the isolated test it picked r0c0, the first option, with 0.15 probability. Shuffling the order changes nothing: it isn&#39;t choosing by content.</li><li><strong>With described options, it plays well.</strong> Unlike Laya, Jev does follow the “more lines, zero holes, lower height” priority: 65% agreement and full 500-piece games. But that 65% is essentially the four-line rule that sorts the same figures (66–68%). Jev reads the consequences the benchmark computes for it well, but adds no judgment beyond them.</li></ul><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FSnDNtPIPy1Y%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DSnDNtPIPy1Y&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FSnDNtPIPy1Y%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/7d72414c33e60545f977d89cc9ba0718/href">https://medium.com/media/7d72414c33e60545f977d89cc9ba0718/href</a></iframe><h3>The same move, two requests</h3><p>To make the design difference visible, here is the same board sent to both engines through the same Jev endpoint (POST /v1/systemone): an I piece with these heights, where the expert plays <strong>r1c0</strong> (the vertical I in column 0).</p><p>piece I · next Z · heights c0=3 c1=5 c2=4 c3=2 c4=2 c5=0 c6=0 c7=1 c8=4 c9=3 · no holes</p><p><strong>OpenJev</strong> receives only the turn’s 17 valid moves:</p><pre>curl -s -w &#39;\n⏱  %{time_total}s\n&#39; http://127.0.0.1:8000/v1/systemone \<br>  -H &#39;Content-Type: application/json&#39; -d &#39;{<br>  &quot;state&quot;: {&quot;pieza&quot;: &quot;I&quot;, &quot;siguiente&quot;: &quot;Z&quot;,<br>            &quot;alturas&quot;: &quot;c0=3 c1=5 c2=4 c3=2 c4=2 c5=0 c6=0 c7=1 c8=4 c9=3&quot;,<br>            &quot;huecos&quot;: &quot;ninguno&quot;},<br>  &quot;questions&quot;: {&quot;jugada&quot;: {<br>    &quot;type&quot;: &quot;choice&quot;,<br>    &quot;instructions&quot;: &quot;Elige dónde colocar la pieza actual en el tablero de Tetris: rotación (giros de 90° a la derecha) y columna de su borde izquierdo, para limpiar líneas y no dejar huecos.&quot;,<br>    &quot;criteria&quot;: {<br>      &quot;r0c0&quot;: &quot;sin girar, borde izquierdo en c0&quot;, &quot;r0c1&quot;: &quot;sin girar, borde izquierdo en c1&quot;,<br>      &quot;r0c2&quot;: &quot;sin girar, borde izquierdo en c2&quot;, &quot;r0c3&quot;: &quot;sin girar, borde izquierdo en c3&quot;,<br>      &quot;r0c4&quot;: &quot;sin girar, borde izquierdo en c4&quot;, &quot;r0c5&quot;: &quot;sin girar, borde izquierdo en c5&quot;,<br>      &quot;r0c6&quot;: &quot;sin girar, borde izquierdo en c6&quot;,<br>      &quot;r1c0&quot;: &quot;girada 90°, borde izquierdo en c0&quot;, &quot;r1c1&quot;: &quot;girada 90°, borde izquierdo en c1&quot;,<br>      &quot;r1c2&quot;: &quot;girada 90°, borde izquierdo en c2&quot;, &quot;r1c3&quot;: &quot;girada 90°, borde izquierdo en c3&quot;,<br>      &quot;r1c4&quot;: &quot;girada 90°, borde izquierdo en c4&quot;, &quot;r1c5&quot;: &quot;girada 90°, borde izquierdo en c5&quot;,<br>      &quot;r1c6&quot;: &quot;girada 90°, borde izquierdo en c6&quot;, &quot;r1c7&quot;: &quot;girada 90°, borde izquierdo en c7&quot;,<br>      &quot;r1c8&quot;: &quot;girada 90°, borde izquierdo en c8&quot;, &quot;r1c9&quot;: &quot;girada 90°, borde izquierdo en c9&quot;<br>    }}}}&#39; | python -m json.tool</pre><p><em>(The payload is in Spanish because that is the language the model was trained in; the instruction asks it to pick the rotation and the left-edge column so as to clear lines and leave no holes.)</em></p><p><strong>My model</strong> receives the same state, but always the same question: the <strong>40 fixed options</strong> (4 rotations × 10 columns) plus &quot;positional&quot;: true. That is its contract: the server checks the question by its hash and, if it changes, answers with a <em>fallback</em>. Impossible moves are discarded afterwards, when choosing.</p><pre>curl -s -w &#39;\n⏱  %{time_total}s\n&#39; http://127.0.0.1:8020/v1/systemone \<br>  -H &#39;Content-Type: application/json&#39; -d &#39;{<br>  &quot;state&quot;: {&quot;pieza&quot;: &quot;I&quot;, &quot;siguiente&quot;: &quot;Z&quot;,<br>            &quot;alturas&quot;: &quot;c0=3 c1=5 c2=4 c3=2 c4=2 c5=0 c6=0 c7=1 c8=4 c9=3&quot;,<br>            &quot;huecos&quot;: &quot;ninguno&quot;},<br>  &quot;questions&quot;: {&quot;jugada&quot;: {<br>    &quot;type&quot;: &quot;choice&quot;,<br>    &quot;instructions&quot;: &quot;Elige dónde colocar la pieza actual en el tablero de Tetris: rotación (giros de 90° a la derecha) y columna de su borde izquierdo, para limpiar líneas y no dejar huecos.&quot;,<br>    &quot;criteria&quot;: {<br>      &quot;r0c0&quot;: &quot;sin girar, borde izquierdo en c0&quot;, &quot;r0c1&quot;: &quot;sin girar, borde izquierdo en c1&quot;,<br>      &quot;r0c2&quot;: &quot;sin girar, borde izquierdo en c2&quot;, &quot;r0c3&quot;: &quot;sin girar, borde izquierdo en c3&quot;,<br>      &quot;r0c4&quot;: &quot;sin girar, borde izquierdo en c4&quot;, &quot;r0c5&quot;: &quot;sin girar, borde izquierdo en c5&quot;,<br>      &quot;r0c6&quot;: &quot;sin girar, borde izquierdo en c6&quot;, &quot;r0c7&quot;: &quot;sin girar, borde izquierdo en c7&quot;,<br>      &quot;r0c8&quot;: &quot;sin girar, borde izquierdo en c8&quot;, &quot;r0c9&quot;: &quot;sin girar, borde izquierdo en c9&quot;,<br>      &quot;r1c0&quot;: &quot;girada 90°, borde izquierdo en c0&quot;, &quot;r1c1&quot;: &quot;girada 90°, borde izquierdo en c1&quot;,<br>      &quot;r1c2&quot;: &quot;girada 90°, borde izquierdo en c2&quot;, &quot;r1c3&quot;: &quot;girada 90°, borde izquierdo en c3&quot;,<br>      &quot;r1c4&quot;: &quot;girada 90°, borde izquierdo en c4&quot;, &quot;r1c5&quot;: &quot;girada 90°, borde izquierdo en c5&quot;,<br>      &quot;r1c6&quot;: &quot;girada 90°, borde izquierdo en c6&quot;, &quot;r1c7&quot;: &quot;girada 90°, borde izquierdo en c7&quot;,<br>      &quot;r1c8&quot;: &quot;girada 90°, borde izquierdo en c8&quot;, &quot;r1c9&quot;: &quot;girada 90°, borde izquierdo en c9&quot;,<br>      &quot;r2c0&quot;: &quot;girada 180°, borde izquierdo en c0&quot;, &quot;r2c1&quot;: &quot;girada 180°, borde izquierdo en c1&quot;,<br>      &quot;r2c2&quot;: &quot;girada 180°, borde izquierdo en c2&quot;, &quot;r2c3&quot;: &quot;girada 180°, borde izquierdo en c3&quot;,<br>      &quot;r2c4&quot;: &quot;girada 180°, borde izquierdo en c4&quot;, &quot;r2c5&quot;: &quot;girada 180°, borde izquierdo en c5&quot;,<br>      &quot;r2c6&quot;: &quot;girada 180°, borde izquierdo en c6&quot;, &quot;r2c7&quot;: &quot;girada 180°, borde izquierdo en c7&quot;,<br>      &quot;r2c8&quot;: &quot;girada 180°, borde izquierdo en c8&quot;, &quot;r2c9&quot;: &quot;girada 180°, borde izquierdo en c9&quot;,<br>      &quot;r3c0&quot;: &quot;girada 270°, borde izquierdo en c0&quot;, &quot;r3c1&quot;: &quot;girada 270°, borde izquierdo en c1&quot;,<br>      &quot;r3c2&quot;: &quot;girada 270°, borde izquierdo en c2&quot;, &quot;r3c3&quot;: &quot;girada 270°, borde izquierdo en c3&quot;,<br>      &quot;r3c4&quot;: &quot;girada 270°, borde izquierdo en c4&quot;, &quot;r3c5&quot;: &quot;girada 270°, borde izquierdo en c5&quot;,<br>      &quot;r3c6&quot;: &quot;girada 270°, borde izquierdo en c6&quot;, &quot;r3c7&quot;: &quot;girada 270°, borde izquierdo en c7&quot;,<br>      &quot;r3c8&quot;: &quot;girada 270°, borde izquierdo en c8&quot;, &quot;r3c9&quot;: &quot;girada 270°, borde izquierdo en c9&quot;<br>    },<br>    &quot;positional&quot;: true<br>  }}}&#39; | python -m json.tool</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/774/1*nMfx3Rsi1-1jWylaeBKBiA.png" /><figcaption>The payloads show where the difference comes from. My model always receives the same question, so its options are already encoded in a cache and each call only processes the state. OpenJev receives the question as new text every time and evaluates each option separately; that is why its time grows with the number of options.</figcaption></figure><h3>Seeing is believing: the arena</h3><p>To show the difference, I built a <strong>visual arena in pygame</strong>: two boards playing the same pieces, each driven by its own engine, each with a panel showing score, lines, <em>think ms</em> and the last move with its probability.</p><p>In independent mode, each side advances as fast as its engine responds. The effect is immediate: while Laya “thinks” about one piece (~1 s), my model has already placed twenty, and placed them well.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F2VwBaPrFASw%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D2VwBaPrFASw&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2F2VwBaPrFASw%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/a247ccb529a972ba556efb969c179524/href">https://medium.com/media/a247ccb529a972ba556efb969c179524/href</a></iframe><h3>What this experiment shows, and what it doesn’t</h3><p>I want to be precise about the conclusion. I put my model up against three very different general-purpose System 1 engines: <strong>Laya</strong> (open source, on a local CPU), <strong>OpenJev 2B</strong> (open source, on an RTX 4060) and <strong>Jev 1.13</strong> (TypeSafe’s commercial service, in the cloud).</p><p><strong>It does show:</strong></p><ul><li><strong>That a small, specialized encoder served on CPU decides faster than all three.</strong> About 15× faster than Laya on a local CPU (46 ms vs. ~705 ms), about 90× faster than OpenJev even with a GPU (36 ms vs. ~3,200 ms), and 3 to 4× faster than Jev (~125 ms, internet included).</li><li><strong>That specialization through distillation (plus DAgger) brings that small model up to expert level,</strong> while all three generalists, given moves in the game’s own format, play at chance level. Laya gets 12% agreement and Jev 9% (the random player gets 9.3%). All three lose within 20 to 30 pieces without clearing lines.</li><li><strong>That more hardware doesn’t close the gap.</strong> OpenJev on an RTX 4060 took practically as long as on Azure and still played at random. Its latency grows with every option (~153 ms per option), so the problem is the design, not the deployment.</li><li><strong>That the commercial service doesn’t close it either.</strong> Jev is the fastest generalist, but it chooses just as badly and doesn’t improve when the options are shuffled (7.5%). It isn’t choosing by content.</li><li><strong>That the generalists share a position bias.</strong> Faced with a question they don’t understand, Laya, OpenJev and Jev tend to pick the first option in the list.</li></ul><p><strong>It doesn’t show:</strong></p><ul><li><strong>That the generalists are bad models.</strong> None of them was trained for Tetris: they are built to answer new questions with no prior training, and semantic text tasks are where they perform. Tetris is an extreme case because it requires spatial reasoning from numbers. A fair quality comparison would be against a generalist fine-tuned on the same dataset; Laya ships tools to do exactly that.</li><li><strong>That none of them can play with help.</strong> When the benchmark describes each move’s consequence (lines, holes, height), Jev does play well: 65% agreement and full games. Laya couldn’t take advantage of those descriptions. But with them the benchmark is already doing almost all the work: a four-line rule over the same figures does just as well (66–68%).</li><li><strong>A same-hardware comparison.</strong> My model and OpenJev ran on my laptop (my model on the CPU, OpenJev on its GPU), Laya on a mini PC on my network, and Jev in TypeSafe’s cloud. Net latency removes the network when it can be measured, but not processor differences, and Jev’s time includes the internet.</li><li><strong>That the result generalizes to every task.</strong> What generalizes is the design: when the questions are fixed and there is data to train on, a small specialized model wins on both speed and quality. When the questions change on every call, the advantage goes to the generalist. In my work I use both: the specialist for known decisions and the generalist for new ones.</li></ul><p><strong>Where each advantage comes from:</strong></p><ul><li><strong>Speed:</strong> from the design. Fixed options are cached, so my model processes ~85 tokens per decision. Laya processes ~270–330 (state, question and options together on every call), Jev ~840 and OpenJev ~2,800, because it evaluates each option separately. And from size: ~140M parameters vs. 322–421M for Laya and 2,000M for OpenJev. TypeSafe doesn’t publish Jev’s size.</li><li><strong>Quality:</strong> from training, through expert distillation and DAgger. None of the three generalists had seen a game of Tetris before this test.</li></ul><h3>Lessons</h3><ol><li><strong>Always compare against a trivial baseline.</strong> 11.8% looked like a “bad but learning” model. Against the “guess by piece” baseline (13.8%), it was a model that wasn’t looking at the board. That number changed the diagnosis.</li><li><strong>Check that the task is learnable with a simple model.</strong> The MLP at 65% separated “the information isn’t there” from “I’m presenting it wrong.”</li><li><strong>Representation matters more than the model.</strong> The tokenizer was destroying the spatial structure. Naming each column mattered more than any hyperparameter.</li><li><strong>Don’t judge a fine-tune by its first epoch.</strong> It went from 15% to 42% between the first and third.</li><li><strong>Getting single moves right isn’t the same as knowing how to play.</strong> The model at 41% accuracy lost after 40 pieces. Chained decisions need DAgger or something equivalent.</li><li><strong>Evaluate quantization by decision agreement, not just latency.</strong> INT8 looked free and broke the model.</li><li><strong>In service benchmarks, subtract the network and use the same transport.</strong> Otherwise you’re measuring your internet connection, not the model.</li></ol><h3>The full pipeline</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*szoXqrUuyrL312hXtpVfMA.png" /></figure><p><em>Stack: Python, PyTorch and Transformers (training), ONNX Runtime (CPU inference), FastAPI and MCP (serving), pygame (arena). Base model: </em><em>jhu-clsp/mmBERT-small. Expert: Pierre Dellacherie&#39;s El-Tetris heuristic.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2762c4c47e71" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>