Este Microcontrolador de US$ 8 Está Executando um Modelo de Linguagem Localmente!

Transcript

00:00:00Este é um modelo de linguagem de 28,9 milhões de parâmetros gerando texto agora mesmo, palavra por palavra,
00:00:08em um chip que custa cerca de oito dólares. Não há Wi-Fi, nada está sendo enviado para um servidor,
00:00:14tudo está acontecendo dentro de um ESP32S3, um microcontrolador com menos memória RAM do que um computador
00:00:22dos anos 90. Isso é insano. Como isso é realmente possível? Qual é a mágica por trás disso e como podemos
00:00:29construir algo semelhante? Bem, essas são ótimas perguntas que vamos analisar no vídeo de hoje.
00:00:34Vai ser muito divertido, então vamos direto ao assunto. O ESP32S3 é um chip que oferece
00:00:46512 kilobytes de SRAM, e essa é a quantidade de memória rápida com a qual esse chip pode computar. Normalmente,
00:00:54se você tentasse executar um LLM dentro dele, o modelo inteiro teria que caber bem ali.
00:01:00O último modelo de linguagem que alguém conseguiu rodar em um chip como este chegou ao limite de 260.000 parâmetros. Então este
00:01:08contém cerca de 110 vezes mais, e a pessoa que conseguiu isso é o desenvolvedor ucraniano Slava S. Então
00:01:16qual é o truque de mágica? Como eles fizeram isso? Como couberam um modelo de 28,9 milhões de parâmetros em um chip de 8 dólares?
00:01:24Bem, a solução alternativa vem de uma ideia que o Google usou no Gemma. É chamada de embeddings por camada. A maioria
00:01:31dos parâmetros de um modelo de linguagem não calcula nada. Eles ficam em uma tabela de embeddings que é apenas lida.
00:01:37Se a maioria dos seus parâmetros só é consultada, eles não precisam de memória rápida. Então você pode se dar ao luxo de
00:01:44deixar essa tabela em uma memória flash lenta e barata e apenas puxar as linhas que o token atual precisa. E a
00:01:52pequena parte que realmente calcula e pensa sobre o próximo token, a cabeça de atenção e o feed forward, permanece na SRAM.
00:01:59Certo, essa é a parte do processamento. Mas a questão continua: Como encaixar um modelo tão grande em um chip tão pequeno?
00:02:05A tabela de 25 milhões de linhas fica na memória flash. E essa é a maior parte de todos os 28,9 milhões de parâmetros
00:02:12do modelo. E a memória flash é barata e enorme neste chip específico. Ele tem 16 megabytes dela.
00:02:20Então, em vez de tentar espremer essa tabela nos mesmos 512 kilobytes de SRAM,
00:02:26ela simplesmente fica armazenada na flash. Nós tiramos cerca de seis linhas dela, uma para cada uma das seis camadas do modelo.
00:02:33Isso dá aproximadamente 450 bytes no total. Agora, antes que você fique muito empolgado, preciso mencionar o fato de que
00:02:40este é um modelo muito simples e limitado. Ele não será o típico LLM no estilo GPT. Ele não vai gerar código
00:02:47ou responder a perguntas sobre tópicos difíceis. Porque se você tentasse treinar um modelo normal desse tamanho
00:02:53em um conjunto de dados normal, 28 milhões de parâmetros gerariam apenas desconexões. Mas este modelo em si foi treinado no
00:03:01Tiny Stories, um conjunto de dados criado por pesquisadores da Microsoft, escrito deliberadamente simples o suficiente para que
00:03:08até mesmo um modelo minúsculo, de alguns milhões de parâmetros, possa aprender a escrevê-las com coerência. E rodá-lo em C puro,
00:03:15em um chip sem sistema operacional e sem interpretador Python, vem do famoso projeto
00:03:22Llama2.c de Andrei Karpathy, que nos mostrou que é possível treinar um pequeno modelo de linguagem e executar
00:03:28a inferência nele usando nada além de algumas centenas de linhas de C portátil. E esse é o modelo no qual todo este
00:03:35projeto foi construído. Sem o Karpathy, isso provavelmente nem seria possível. Então é assim que funciona em poucas
00:03:40palavras. Agora vamos tentar construí-lo por conta própria e rodá-lo no chip para ver como ele se comporta.
00:03:47Para realmente construir isso nós mesmos, a primeira coisa que você precisa é do hardware certo, especificamente um ESP32S3
00:03:54com 16 megabytes de flash e 8 megabytes de PSRAM. Essa é a variante N16R8. E isso é realmente
00:04:03importante, porque lembra de quando falamos sobre aquela tabela de 25 milhões de linhas que fica na flash? Bem, por si só,
00:04:10depois de treinada e exportada, ela ocupa cerca de 15 megabytes. Mas placas com 4 ou 8 megabytes de flash
00:04:17simplesmente não vão suportá-la. Então, se você está comprando uma placa para acompanhar o vídeo, essa é a especificação que você deve
00:04:22verificar primeiro. Quando examinei as instruções originais do projeto, a configuração estava espalhada
00:04:28em alguns arquivos diferentes e presumia um bom conhecimento que eu não tinha antes de começar. Então,
00:04:34em vez de orientar você exatamente como foi escrito, montei um único script direto que faz
00:04:40tudo. Verifica a placa, instala o toolchain, prepara os dados, treina, exporta, verifica,
00:04:47compila e grava tudo de uma só vez. Então vamos executar esse script. E um aviso rápido,
00:04:55se você estiver acompanhando, o script inteiro leva cerca de 25 minutos para terminar. E provavelmente é o
00:05:00mesmo tempo que levaria fazendo passo a passo. É só porque há muitos comandos
00:05:05separados que você precisa monitorar. E a maior parte do tempo é gasta no treinamento do modelo Tiny Stories.
00:05:11Isso leva cerca de 13 minutos no meu MacBook. E assim que o treinamento for concluído, você verá os LEDs no painel
00:05:18começarem a piscar. Isso é uma indicação de que estamos prestes a carregar o modelo. E assim que for carregado,
00:05:24aqui podemos ver o primeiro exemplo básico de uma história sobre uma garotinha. E, de fato,
00:05:29estamos obtendo esses nove tokens por segundo. Mas você notará que, em um determinado ponto,
00:05:33ele reiniciará a história novamente. Então o modelo entra em algum tipo de loop. E se você quiser
00:05:39dar a ele um prompt personalizado, também incluí um script de exemplo que você pode usar para rodar seus próprios
00:05:44prompts personalizados. Para este exemplo, vamos começar uma história sobre um robô. E outra coisa a notar é que se você
00:05:50mudar o prompt, terá que regravar o ESP32 novamente. Essa é uma limitação deste método.
00:05:56Ele só pode reproduzir um prompt pré-gravado por vez. Como você pode ver,
00:06:02nós temos uma menção ao robô na história. E a história é de fato um pouco diferente desta vez.
00:06:08Mas note o que acontece após o final do parágrafo. Voltamos à história da menininha.
00:06:13Não tenho ideia de por que isso está acontecendo. Mas, claramente, o modelo tende a voltar para aquela
00:06:19história específica sobre a garotinha. Vamos fazer outro exemplo. Desta vez, vamos usar a
00:06:24famosa frase que é exibida logo no início de todo filme do Star Wars. E vamos ver onde isso
00:06:30nos leva. Este é um exemplo interessante. Podemos ver que o modelo imediatamente desvia de volta para a
00:06:36narrativa da garotinha novamente. E estou assumindo que, para um modelo desse tamanho, ele nem entende
00:06:42o que é uma galáxia. Provavelmente é por isso que está ignorando nosso prompt específico neste caso. E
00:06:47mais uma vez, vemos que o próximo parágrafo começa a mesma história. Portanto, embora esse experimento seja
00:06:53impressionante e ver um modelo produzir nove tokens por segundo em um microchip minúsculo seja realmente incrível,
00:06:59ainda é uma prova de conceito muito limitada. Como vimos, não importa o que você pergunte ao modelo, ele
00:07:06sempre voltará a contar histórias, porque é para isso que foi treinado. Mas se você achou este teste
00:07:11interessante, eu também fiz outro vídeo em uma área semelhante, onde testei se um Raspberry
00:07:18Pi de primeira geração conseguiria rodar um LLM de verdade localmente. Então dê uma olhada nesse vídeo se estiver interessado. É isso,
00:07:24pessoal. É assim que se roda um modelo de linguagem de 28,9 milhões de parâmetros em um chip ESP32. Nós
00:07:32testamos. Funciona. Parabéns ao Slava por criar este projeto. Mas o que você achou deste experimento?
00:07:38Você vê algum exemplo do mundo real onde tal implementação possa ser útil? Deixe seus
00:07:43comentários na seção abaixo. E pessoal, se vocês gostam desse tipo de análise técnica,
00:07:48por favor me avisem deixando o seu gostei abaixo do vídeo. E também não se esqueçam de
00:07:53se inscrever no nosso canal. Aqui foi o Andres da Betterstack e vejo vocês nos próximos vídeos.

Description

A developer got a 28.9-million-parameter language model running entirely offline on an $8 ESP32-S3 microcontroller, a chip with just 512KB of RAM, using a memory trick borrowed from Google's Gemma architecture called Per-Layer Embeddings. In this video we break down how the trick actually works, reproduce the entire training and flashing process ourselves from a bare board, and put the model through some prompt tests of our own, including one it stubbornly refuses to follow. If you're curious how far you can push AI onto hardware that was never meant to run it, this one's for you. 🔗 Relevant Links Esp32-ai: https://github.com/slvDev/esp32-ai build_and_flash.sh: https://gist.github.com/andrisgauracs/ce459630660f82cf4ca7e43aa81604c7 run_prompt.sh: https://gist.github.com/andrisgauracs/e84b842d0f5e301485ecbf6654b0838e ❤️ More about us Radically better observability stack: https://betterstack.com/ Written tutorials: https://betterstack.com/community/ Example projects: https://github.com/BetterStackHQ 📱 Socials Twitter: https://twitter.com/betterstackhq Instagram: https://www.instagram.com/betterstackhq/ TikTok: https://www.tiktok.com/@betterstack LinkedIn: https://www.linkedin.com/company/betterstack 📌 Chapters: 00:00 Running an LLM on an $8 Chip 00:43 The ESP32’s Memory Problem 01:12 How Did They Make It Work? 01:30 The Per-Layer Embedding Trick 02:04 Fitting 28.9 Million Parameters 02:36 What This Tiny LLM Can Actually Do 02:58 TinyStories and Karpathy’s llama2.c 03:41 Building It Ourselves 03:47 Choosing the Right ESP32 04:23 The One-Shot Installation Script 04:52 Training and Flashing the Model 05:24 Testing the LLM at 9 Tokens per Second 05:38 Trying Custom Prompts 06:21 The Star Wars Prompt Test 06:51 Is an ESP32 LLM Actually Useful? 07:23 Final Thoughts

Community Posts

No posts yet. Be the first to write about this video!

Write about this video