Rodei um LLM Local num Raspberry Pi de 12 Anos (E Funcionou!)
BBetter Stack
Computing/SoftwareConsumer Electronics
Transcript
00:00:00Este é o Raspberry Pi de primeira geração, lançado em 2014.
00:00:05Ele tem um processador single-core de 700 MHz e 512 MB de RAM.
00:00:12Para os padrões modernos, isso é basicamente uma calculadora.
00:00:16Mas hoje, vamos ver se conseguimos levar este hardware de 12 anos
00:00:21ao seu limite absoluto, rodando um grande modelo de linguagem localmente.
00:00:26Neste vídeo, mostrarei qual é o modelo minúsculo que você pode rodar no Raspberry Pi,
00:00:30veremos como ele se comporta e ensinarei como instalar as dependências necessárias
00:00:35para que você mesmo possa testar.
00:00:37Vai ser muito divertido, então vamos mergulhar nisso.
00:00:40Honestamente, eu não achei que seria possível encontrar um modelo
00:00:47enxuto o suficiente para esta arquitetura.
00:00:49Mas depois de pesquisar, acabei encontrando um candidato.
00:00:52Conheçam o Falcon H1 Tiny.
00:00:54É um modelo incrivelmente compacto com apenas 90 milhões de parâmetros.
00:00:59Foi desenvolvido pelo Technology Innovation Institute em Abu Dhabi
00:01:03especificamente para explorar os limites inferiores extremos da modelagem de linguagem.
00:01:08Mas como eles conseguiram fazer um modelo tão pequeno?
00:01:10Existe algum tipo de ingrediente técnico mágico por trás disso?
00:01:13Bem, na verdade não.
00:01:14Eles estão usando basicamente a mesma arquitetura híbrida de Transformer + Mamba
00:01:19que empresas como a IBM usaram em seus modelos minúsculos Granite 4.
00:01:24Sobre os quais também fiz um vídeo, caso queira conferir.
00:01:27Mas aqui está o detalhe.
00:01:28Para espremer este modelo na memória com sucesso, precisamos falar sobre quantização.
00:01:33Os modelos Falcon estão disponíveis em versões de 2-bit, 4-bit e 8-bit.
00:01:38Você pode ficar tentado a experimentar a quantização IQ (Importance Quantization) ultra-leve.
00:01:43Mas aqui está o problema.
00:01:45Esses novos métodos dependem de uma manipulação de bits complexa
00:01:49que exige instruções de CPU modernas para ser eficiente.
00:01:52No nosso chip ARMv6 antigo no Raspberry Pi, isso não vai funcionar.
00:01:57Em vez disso, temos que optar pelos modelos Q4 da velha guarda,
00:02:01que é o padrão ouro para o nosso caso.
00:02:04Ele utiliza um método de quantização legado de tamanho médio
00:02:07que o processador do Pi consegue realmente processar sem travar.
00:02:11Ele nos dá a melhor relação inteligência por megabyte, mantendo a lógica intacta.
00:02:17Mas fazer este modelo rodar neste Raspberry Pi de 1ª geração não é tarefa simples.
00:02:22Como o Pi utiliza a arquitetura ARMv6,
00:02:26ele não possui as instruções NEON modernas das quais quase todas as bibliotecas de IA dependem.
00:02:31Felizmente, existe o llama.cpp que podemos usar para realizar a inferência.
00:02:36Para isso, precisamos compilar seu binário especificamente para o nosso ARMv6.
00:02:42Se você tentasse compilá-lo diretamente no Pi,
00:02:45o compilador provavelmente levaria umas 18 horas para terminar.
00:02:49Isso se ele não travasse antes por falta de memória.
00:02:53Então, para contornar isso, precisamos ser um pouco criativos.
00:02:56Precisamos compilar esses binários no nosso notebook usando o dockcross,
00:03:02visando especificamente o conjunto de instruções ARMv6 com a unidade VFP ativada,
00:03:08e depois copiá-los via SSH para partirmos direto para a inferência.
00:03:13É exatamente isso que vamos fazer agora.
00:03:15Primeiro, instalamos o sistema operacional mais leve possível usando o Raspberry Pi Imager.
00:03:22Em uma placa com apenas 512 MB de RAM, cada megabyte conta.
00:03:28Escolhi o Raspberry Pi OS Lite, versão 32-bit,
00:03:32pois não tem interface gráfica e consome uma fração mínima da memória
00:03:38que o sistema padrão utiliza, deixando quase toda a RAM livre para o modelo.
00:03:44Outra nota importante: use as configurações avançadas
00:03:47para pré-configurar o Wi-Fi e ativar o SSH.
00:03:51Nessas placas antigas, é muito mais fácil gerenciar tudo remotamente,
00:03:55para não ter que lutar com o terminal local lento.
00:03:58Agora, com o Pi ligado e o SSH acessado, precisamos resolver o problema do ARMv6.
00:04:05Se tentássemos compilar o llama.cpp aqui,
00:04:08o Pi literalmente passaria o próximo dia e meio apenas processando headers.
00:04:13Então, faremos isso em um notebook comum para ganhar tempo e processamento.
00:04:18Vamos clonar o código-fonte do llama.cpp e criar um diretório
00:04:23específico para armazenar o build que usaremos no nosso Raspberry Pi.
00:04:28Agora, temos outro problema.
00:04:29Meu Mac usa ARMv8, que é a versão 64-bit, não o ARMv6 de 32-bit.
00:04:37E eles possuem conjuntos de instruções diferentes.
00:04:40Para compilar o binário para o Pi, usamos o dockcross,
00:04:45que é um toolchain de compilação cruzada que roda no Mac,
00:04:48mas gera binários para a arquitetura legada do Pi.
00:04:53Em seguida, configuramos o build.
00:04:55E aqui precisamos ser extremamente precisos.
00:04:58Temos que passar algumas flags bem específicas.
00:05:00Primeiro, desativamos as shared libs para criar um único binário portátil.
00:05:05Depois, desativamos o NEON porque o Pi não tem essas instruções matemáticas modernas.
00:05:10E desativamos o OpenMP para manter o consumo de memória o mais baixo possível.
00:05:15Estamos removendo qualquer luxo moderno
00:05:18para garantir que o binário seja compatível com a placa antiga do Pi.
00:05:22Se iniciarmos o build, em cerca de dois minutos teremos um binário
00:05:26do llama-completion pronto e otimizado para ser copiado para o Pi.
00:05:31Agora vou usar o SSH para me conectar ao Pi pela rede,
00:05:35criar um novo diretório nele e usar SCP para copiar nosso binário customizado.
00:05:42Resta apenas uma última coisa.
00:05:44Vamos baixar os modelos Falcon legados quantizados de 2-bit, 4-bit e 8-bit,
00:05:50pois vamos testar todos eles sequencialmente.
00:05:53Depois os copiamos para a pasta de modelos no Pi, um por um, pela rede.
00:05:58Agora vem a parte divertida.
00:05:59Vamos para o Pi e executar nosso primeiro teste de inferência.
00:06:03Começaremos pela compressão mais agressiva, o modelo quantizado de 2-bit.
00:06:07E aqui precisamos rodar este comando longo.
00:06:10Basicamente o que estou fazendo é dar um prompt simples,
00:06:13“Olá, como vai você?”, limitando a saída a 32 tokens.
00:06:18Especificamos exatamente uma thread porque, bem, é só o que temos.
00:06:22E mantemos o tamanho do contexto minúsculo em 128 tokens para economizar cada byte de RAM.
00:06:29Mas a flag mais importante aqui é “no M map”.
00:06:32Normalmente, o llama.cpp usa mapeamento de memória, o que é ótimo para GPUs potentes,
00:06:38mas um pesadelo para a placa do Pi.
00:06:41Em um sistema 32-bit com apenas 512 megabytes de RAM,
00:06:45o M map pode falhar se não encontrar um bloco contíguo de endereços.
00:06:50Ao desativá-lo, forçamos o carregamento do modelo direto no heap,
00:06:55o que nos dá um controle muito mais estável da nossa memória limitada.
00:06:58Dito isso, vamos rodar o comando.
00:07:00E aí estão eles, nossos primeiros tokens.
00:07:03Como podemos ver, a versão de 2-bit está sofrendo bastante.
00:07:08Primeiro, ele processa um único token a cada três segundos aproximadamente,
00:07:14o que já era esperado em um Raspberry Pi antigo.
00:07:18Mas o mais grave é que a resposta é um completo absurdo.
00:07:21Em um modelo de 90 milhões de parâmetros, os pesos estão tão comprimidos
00:07:25que a lógica linguística basicamente entrou em colapso.
00:07:28Mal faz sentido, mas tecnicamente está funcionando.
00:07:32Agora vamos ver o que acontece se trocarmos pelo modelo de 4-bit.
00:07:35Vejam só, agora recebemos uma saudação coerente de volta.
00:07:40Isso é um sucesso!
00:07:42Temos agora um modelo de IA real rodando localmente no Pi
00:07:47e respondendo de forma lógica aos nossos comandos.
00:07:49Muito bom!
00:07:50Vamos forçar um pouco mais.
00:07:53Vejamos se o Pi aguenta um modelo de 8-bit.
00:07:56Desta vez vou perguntar algo mais inteligente,
00:07:59como qual é a capital da Albânia?
00:08:02E bem, a resposta está errada, pois a capital da Albânia é Tirana
00:08:08e o que ele disse claramente não está correto.
00:08:10Mas se eu pergunto qual a capital da Bélgica, ele responde corretamente.
00:08:15Isso nos mostra algo muito interessante.
00:08:17Parece que a redução para 90 milhões de parâmetros tem seu preço.
00:08:22Ele pode ter conhecimento preciso sobre países maiores e populares,
00:08:26mas falta informação sobre países e temas menos conhecidos.
00:08:31E essa é a natureza do conhecimento.
00:08:33Existe um limite de saber que você consegue colocar em 90 milhões de parâmetros.
00:08:38De qualquer forma, o resultado é super legal.
00:08:41E é uma confirmação de que sim, existem modelos de IA pequenos
00:08:46e leves o suficiente para rodar em um Raspberry Pi de 12 anos.
00:08:50É rápido?
00:08:51Claro que não.
00:08:52É preciso?
00:08:53Pode não ser.
00:08:54Você deveria usar isso em produção?
00:08:55Provavelmente não.
00:08:57A menos que queira construir um robô muito, muito, muito lento.
00:09:02Mas o mais importante é sabermos que é teoricamente possível.
00:09:06Basicamente, era tudo o que eu queria provar neste vídeo.
00:09:09E, para ser honesto, este experimento foi muito divertido.
00:09:13Então, aqui está, pessoal.
00:09:14Estes são os modelos Falcon H1 Tiny.
00:09:17Provavelmente os menores modelos de IA disponíveis atualmente.
00:09:20E agora sabemos que eles são pequenos o suficiente para rodar num Raspberry Pi de 1ª geração,
00:09:25o que é fantástico.
00:09:27Não canso de celebrar o quão incrível é esse fato.
00:09:30Embora a aplicação prática seja inútil, ainda é muito legal.
00:09:35Contem-me, pessoal, se vocês têm algum pensamento engraçado,
00:09:37comentários ou observações sobre o que acabaram de ver.
00:09:40Postem na seção de comentários aqui embaixo.
00:09:42E se vocês gostam desse tipo de análise técnica,
00:09:45por favor, deixem seu joinha clicando no botão de curtir abaixo do vídeo.
00:09:49E também não se esqueçam de se inscrever no nosso canal.
00:09:51Aqui é o Andris, da Better Stack, e vejo vocês nos próximos vídeos.