Modelo de linguagem no ESP32-S3 chega a 406 tokens/s, 18 vezes mais rápido
O microcontrolador ESP32-S3, que custa algumas centenas de rublos, consegue rodar uma Llama-2 minúscula de 260 mil parâmetros, mas os projetos conhecidos chegavam a cerca de 19 tokens por segundo. O autor converteu os pesos para int8, escreveu kernels em assembly para as instruções vetoriais PIE, colocou o segundo núcleo para trabalhar e reescreveu a atenção. O resultado: 406 tokens por segundo, contra 22,5 da versão ingênua em um único núcleo. O texto gerado foi verificado e coincide com a referência. Para quem desenvolve sistemas embarcados, a conclusão é simples: primeiro comprima os pesos e escolha onde eles ficam na memória; só depois parta para o assembly.
Processado por IA de Habr AI; editado por Hamidun News
Rodar um modelo de linguagem em um microcontrolador de algumas centenas de rublos é mais um truque de hobby, mas esta análise serve para qualquer pessoa que precise extrair velocidade de um hardware limitado. O autor usou o ESP32-S3 (dois núcleos Xtensa LX7 de 240 MHz e 512 KB de SRAM interna) e o modelo stories260K, da coleção tinyllamas de Andrej Karpathy. É uma Llama-2 de verdade, com atenção, RoPE e SwiGLU, com apenas 259 328 parâmetros, treinada no conjunto de histórias infantis TinyStories. O conhecido projeto esp32-llm, de DaveBben, chegava a 19,13 tokens por segundo nesse chip. Aqui o resultado foi de 406 tokens por segundo, algo como 21 vezes mais rápido. Sem overclock e sem aceleradores externos.
Primeiro a verificação, depois a aceleração
Um erro no assembly não derruba o programa: ele estraga o texto em silêncio. E é difícil perceber, porque histórias sobre Lily e a bola vermelha não são nenhuma obra-prima nem quando tudo funciona. Por isso, o autor montou uma cadeia de verificações: uma referência em numpy; um simulador do firmware com a mesma quantização e a mesma ordem das operações de ponto flutuante; um motor em C no computador (idêntico ao simulador bit a bit em 200 passos); o emulador QEMU da Espressif; e, por fim, a placa real. Na placa, todos os modos geram os mesmos tokens que o simulador, e a divergência dos logits não passa de 5·10⁻⁸.
Quatro etapas de aceleração
int8 e o lugar dos pesos. Pesos em int8, com uma escala por linha da matriz, reduziram o modelo de 1013 para 274 KB. A qualidade quase não sofre: a perplexidade sobe 0,0%, e o pipeline completo com ativações em int8 e KV-cache fica em +0,7%. Já 4 bits são destrutivos: +24,4% com escala por linha e +14,5% com escala a cada 16 pesos. A migração para int8, ainda na mesma PSRAM, acelerou a geração em 2,5 vezes: o gargalo era a leitura da memória, não a aritmética. O flash via XIP quase não perde para a PSRAM (53,3 contra 55,3 tokens/s), e a SRAM interna rendeu mais 71,7.
Instruções vetoriais PIE. A extensão tem registradores de 128 bits e, com uma única instrução, ee.vmulas.s8.accx, multiplica 16 pares de int8 e soma o resultado ao acumulador. O compilador não gera esse tipo de código, então o kernel foi escrito em assembly. A dimensão do modelo, 64, cabe em quatro registradores, de modo que o vetor de entrada é carregado uma única vez. As matrizes Q, K e V foram fundidas em uma só, assim como W1 e W3: quatro multiplicações por camada em vez de sete. Resultado: 71,7 → 175,2 tokens/s.
Segundo núcleo. As matrizes são minúsculas, e um semáforo do FreeRTOS consumiria todo o ganho. Por isso, o segundo núcleo fica em espera ativa sobre um contador volatile e dorme fora da geração. Foi preciso desativar o watchdog timer. Resultado: 285,5 tokens/s, ×1,63. Não chegou a dobrar: RMSNorm, RoPE, SwiGLU e a escolha do token continuam sequenciais.
Atenção. Depois da aceleração das matrizes, ela passou a responder por 72% do tempo, um caso clássico da lei de Amdahl. O autor processa em uma única passada as duas cabeças de consulta que compartilham a mesma cabeça KV e divide o cálculo de modo que tudo caiba nos 16 registradores da FPU (no disassembly havia 81 acessos à pilha). A velocidade média em 128 tokens subiu para 406,1 tokens/s. Converter Q·K para inteiros não trouxe ganho: 403,6 contra 406,1.
A contabilidade dos kilobytes
A parte mais inesperada é a memória. Os pesos (274 KB), as ativações e o KV-cache (cerca de 360 bytes por token) precisam caber na SRAM. Após a inicialização do ESP-IDF, sobravam 335 KB, e o contexto cabia em 96 tokens.
Algumas medidas liberaram espaço: mover o código do FreeRTOS, do heap e do driver de flash da IRAM para o flash, usar um cache de instruções de 16 KB, reduzir os buffers de UART/USB e deixar a tabela RoPE no flash. Com isso, chegou-se a 363 KB e a um contexto de 160 tokens. A conclusão do autor: 260 mil parâmetros em int8 são quase o teto para a SRAM desse chip, e qualquer modelo maior terá de ser lido em boa parte do flash ou da PSRAM.
O que isso significa na prática
Sendo honesto: esse modelo não tem aplicação prática, só sabe compor histórias infantis, e o próprio autor admite isso. Em compensação, as lições são transferíveis. Quantização e o posicionamento correto dos pesos rendem mais do que truques engenhosos; a cada etapa o gargalo muda de lugar (memória, laço escalar, atenção e, agora, divisões e normalizações); e, sem verificação bit a bit, é arriscado fazer otimizações de baixo nível. O código, os kernels em assembly, o simulador e o script de medições estão no GitHub (nikuson/esp32-llm). O próximo objetivo do autor é rodar o stories15M direto do flash, um modelo 60 vezes maior.
- 18 de nov. de 2026LLM em VPS sem GPU: modelos de 4B classificam chamados com 90% de acerto em 3–5 s
- 18 de nov. de 2026Bonsai 2 27B compactado rodou a 17 tokens/s em placa de 2017, e o Qwen3 8B, a 32
- 18 de nov. de 2026OpenAI lança o GPT-6.2 Astra: segundo lugar no ranking e preço 20% menor
- 18 de nov. de 2026Após uma falha, agentes só revertem o trabalho em 47% dos casos, embora resolvam 84% das tarefas
Perguntas frequentes sobre a notícia
O que se sabe sobre Primeiro a verificação, depois a aceleração?
Um erro no assembly não derruba o programa: ele estraga o texto em silêncio. E é difícil perceber, porque histórias sobre Lily e a bola vermelha não são nenhuma obra-prima nem quando tudo funciona. Por isso, o autor montou uma cadeia de verificações: uma referência em numpy; um simulador do firmware com a mesma quantização e a mesma ordem das operações de ponto flutuante; um motor em C no computador (idêntico ao simulador bit a bit em 200 passos); o emulador QEMU da Espressif; e, por fim, a placa real.
O que se sabe sobre Quatro etapas de aceleração?
int8 e o lugar dos pesos. Pesos em int8, com uma escala por linha da matriz, reduziram o modelo de 1013 para 274 KB. A qualidade quase não sofre: a perplexidade sobe 0,0%, e o pipeline completo com ativações em int8 e KV-cache fica em +0,7%. Já 4 bits são destrutivos: +24,4% com escala por linha e +14,5% com escala a cada 16 pesos. A migração para int8, ainda na mesma PSRAM, acelerou a geração em 2,5 vezes: o gargalo era a leitura da memória, não a aritmética.
O que se sabe sobre A contabilidade dos kilobytes?
A parte mais inesperada é a memória. Os pesos (274 KB), as ativações e o KV-cache (cerca de 360 bytes por token) precisam caber na SRAM. Após a inicialização do ESP-IDF, sobravam 335 KB, e o contexto cabia em 96 tokens. Algumas medidas liberaram espaço: mover o código do FreeRTOS, do heap e do driver de flash da IRAM para o flash, usar um cache de instruções de 16 KB, reduzir os buffers de UART/USB e deixar a tabela RoPE no flash. Com isso, chegou-se a 363 KB e a um contexto de 160 tokens.
Test Frontier LLMs & Autonomous Agents in One Workspace
Run Claude Opus 5.5, GPT-6, Gemini 3.1, and DeepSeek side-by-side in Nomad AI (nomadnet.ai) — unified model routing, deep research, and multimodal workflows under one subscription.
O essencial da IA — uma vez por semana
Sete histórias que realmente importaram, escolhidas a dedo. Sem ruído nem releases.
Pronto! Verifique seu e-mail para a confirmação.