Um modelo local de 125 bilhões de parâmetros em uma GPU de 16 GB: rápido, mas é inteligente?

Autoria: Zero to MVP · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: A 125B Local Model on a 16GB GPU: Fast, But Is It Smart? · Canal: Zero to MVP · 06:47 · Assistir no YouTube

Tópicos: Agentes de IA, Avaliação e benchmarks de IA, Inferência e otimização de modelos, Infraestrutura e hardware de IA, Modelos locais e open source

Resumo

O vídeo testa o Strata, que permite executar localmente um modelo Frontier de 125 bilhões de parâmetros usando uma GPU com 16 GB de VRAM, e avalia tanto a velocidade quanto a qualidade das respostas. Na RTX 4060 Ti, o modelo alcança uma média de cerca de 65 tokens por segundo, mas exige bastante memória RAM do sistema e praticamente dedica o computador à execução. Com o agent Pi, ele conclui com sucesso tarefas de criação de uma página com relógio e de um editor de pixel, mas não consegue finalizar uma ilusão 3D de uma pirâmide feita com caracteres. A impressão inicial é positiva, embora o autor pretenda continuar testando o modelo.

Pontos-chave

O teste foi feito em uma RTX 4060 Ti com 16 GB de VRAM e um sistema com 128 GB de RAM.
Segundo o vídeo, o Strata precisa de 64 GB de RAM do sistema para executar o modelo.
O modelo é descrito como uma mistura de especialistas com mais de 24.000 especialistas, dos quais 10 são usados para gerar cada token.
A geração alcançou uma média de cerca de 65 tokens por segundo no hardware testado.
Durante a execução, o modelo usou cerca de 36 a 40 GB de RAM do sistema e manteve a GPU totalmente ocupada.
Usando o agent Pi, o modelo criou com sucesso uma página com relógio, cronômetro e timer.
O modelo também produziu um editor de pixel funcional em cerca de 5 minutos e 20 segundos.
A tarefa de criar uma pirâmide com aparência tridimensional usando caracteres não foi concluída com sucesso.

Capítulos

Início	Capítulo	Resumo
00:00	Apresentação do teste e requisitos de hardware	O autor apresenta o Strata, escolhe a RTX 4060 Ti e explica os requisitos de memória e a arquitetura de mistura de especialistas.
01:31	Execução local e medição de velocidade	O autor compila e inicia o Strata, mostra o uso de recursos do sistema e mede uma média de cerca de 65 tokens por segundo.
03:06	Testes de programação: relógio e editor de pixel	Com o agent Pi, o modelo conclui uma página com relógio, cronômetro e timer e, em seguida, cria um editor de pixel funcional.
05:12	Teste da pirâmide 3D e conclusões iniciais	O modelo não conclui a ilusão tridimensional de uma pirâmide feita com caracteres, mas o autor avalia positivamente os resultados gerais e promete novos testes.

Citações

Uma boa GPU, por si só, não é suficiente. Você também precisa de muita RAM. — 01:01

A geração de tokens é ótima, mas estou muito mais interessado na qualidade das respostas do modelo nesta configuração. — 02:35

Não esperava que o modelo concluísse essa tarefa com sucesso logo na primeira tentativa. — 04:39

Infelizmente, o modelo não conseguiu realizar essa tarefa, mas, para ser justo, é uma tarefa muito difícil. — 06:16

Apesar do meu ceticismo inicial, tanto esta forma de executar o modelo quanto o próprio modelo tiveram um desempenho muito bom. — 06:47

Conceitos e entidades

Strata (ferramenta): Projeto usado no vídeo para executar localmente um modelo de 125 bilhões de parâmetros.
Frontier (modelo): Modelo de 125 bilhões de parâmetros mencionado no vídeo e testado por meio do Strata.
Mixture of Experts (conceito): Arquitetura descrita no vídeo em que apenas uma parte dos especialistas é ativada para gerar cada token.
RTX 4060 Ti (ferramenta): GPU com 16 GB de VRAM usada para executar os testes.
Pi (ferramenta): Agent minimalista e extensível usado para enviar as tarefas ao modelo.
GitHub (empresa): Plataforma onde o autor disponibiliza o repo de prompts usado nos testes.
Opus 5.5 (modelo): Modelo citado como comparação anterior para a tarefa da pirâmide tridimensional.
GPT-6 (modelo): Modelo citado como comparação anterior para a tarefa da pirâmide tridimensional.
Anthropic (empresa): Empresa cujos modelos o autor menciona usar para tarefas mais difíceis.
OpenAI (empresa): Empresa cujos modelos o autor menciona usar para tarefas mais difíceis.

Tradução completa (pt-BR)

00:00 Há alguns dias, foi lançado um projeto chamado Strata que permite executar o modelo Frontier de 125 bilhões de parâmetros, o 3.8 flash next, em uma GPU comum com 16 ou até 12 gigabytes de VRAM. É claro que eu não podia simplesmente ignorar algo assim. Então, decidi testar por conta própria. No entanto, não estou tão interessado apenas em fazer o modelo funcionar, mas em saber se ele consegue lidar com tarefas práticas de verdade. No momento, tenho duas GPUs que serviriam para

00:30 o teste de hoje. Uma é uma RTX 4060 Ti com 16 gigabytes de RAM, e a outra é uma Radeon com 32 gigabytes. Vou escolher a primeira, porque ela está bem mais próxima do que você encontraria em um PC comum. E esse é exatamente o tipo de hardware para o qual o projeto de hoje foi desenvolvido. Há também um ponto importante. O próprio Strata precisa de 64 gigabytes de RAM do sistema para executar o 3.8 flash next. Tenho 128

01:01 gigabytes instalados, então é mais do que suficiente. No entanto, se você também quiser tentar executá-lo, tenha isso em mente. Uma boa GPU, por si só, não basta. Você também precisa de bastante RAM. Agora, só algumas palavras sobre como é possível executar um modelo de 125 bilhões de parâmetros em uma GPU comum. O motivo é que ele é um modelo de mistura de especialistas, ou seja, é composto por um grande número de especialistas. Ele tem mais de 24.000 especialistas, mas apenas 10 deles são usados para gerar

01:31 cada token. Então, a cada etapa, apenas cerca de 6 bilhões de parâmetros ficam realmente ativos, em vez dos 125 bilhões. Certo, chega de teoria, vamos à prática. Conecto-me ao computador pelo SSH e inicio o servidor. O Strata ainda não tem uma versão pronta para Linux, e as versões disponíveis atualmente são apenas para Windows. Então, compilo o agent por conta própria. O carregamento do modelo leva cerca de 30 segundos. Aliás, o Strata praticamente assume o controle do computador inteiro. No momento, o agent está usando

02:03 36 GB de RAM do sistema só para ele. A memória de vídeo está quase totalmente ocupada. Portanto, não é um serviço em segundo plano que roda junto com outras cargas de trabalho. Enquanto o Strata está em execução, o computador fica praticamente dedicado a ele. Para medir o desempenho do modelo no meu hardware, escrevi um script em Python que faz o benchmark. Ele usa dois prompts. Um pede uma resposta em texto, enquanto o outro pede que o modelo escreva código. Depois, envia várias solicitações ao modelo para que eu possa obter médias significativas.

02:35 Certo, obtive uma média de cerca de 65 tokens por segundo. Considerando que minha GPU é mais fraca do que a usada pelos autores do projeto, o resultado é bem próximo do que eles relataram. No entanto, como eu disse no começo, a velocidade de geração de tokens é ótima, mas estou muito mais interessado na qualidade das respostas do modelo nessa configuração. Então, vamos passar a alguns testes práticos. Para os testes, vou usar meu repo com uma coleção de prompts. Eles estão organizados do mais simples ao mais complexo, e eu

03:06 vou passar por eles nessa ordem. Aliás, esse repo está disponível no GitHub, então você pode baixá-lo e fazer seus próprios experimentos. Vou usar o Pi como agent. Gosto muito dele por ser minimalista e extensível. Para o primeiro teste, vou usar uma tarefa em que o modelo precisa criar uma página HTML com relógio, cronômetro e temporizador. É um teste bastante simples para um modelo tão grande, então serve mais para verificar se o modelo realmente funciona na minha máquina. E, como essa é a

03:38 tarefa mais fácil, não vou criar nenhum plano e simplesmente vou pedir que ele implemente o projeto com base na descrição. Certo, o modelo terminou o trabalho bem rápido. Vamos ver o que conseguimos. Sim, está tudo como deveria. Há um relógio, o cronômetro funciona e [bufa] também há um temporizador. É, está tudo ótimo. O teste mais fácil foi aprovado. Vamos passar a algo mais difícil. Em seguida, vou para uma tarefa de dificuldade média. O objetivo é criar um editor de pixels. Mais uma vez,

04:09 mudo para o agent Pi e peço que implemente o projeto, ainda sem criar um plano de implementação antes. Vamos ver se o modelo consegue dar conta. Aliás, enquanto o modelo trabalha, vou mostrar o uso do sistema. Como podem ver, a GPU está totalmente ocupada. Ignorem o segundo gráfico; ele mostra a GPU integrada. Cerca de 40 GB de RAM do sistema estão sendo usados, e aproximadamente metade dos núcleos da CPU está totalmente ocupada. Certo, o modelo terminou o trabalho.

04:39 Levou 5 minutos e 20 segundos. Muito bom para um modelo local, mas vamos conferir o resultado. Certo, está como deveria. Deixe-me ver se funciona. Sim, parece que o editor de pixels está funcionando. Dá para mudar as ferramentas e as cores, e não parece haver nenhum erro. Ótimo. Não esperava que o modelo concluísse essa tarefa com sucesso logo de primeira. Bem, nesse caso, vou passar a tarefas ainda mais difíceis, do tipo que costumo dar a modelos da Anthropic e da OpenAI. E

05:12 a terceira tarefa será incomum. Ela vai testar a capacidade dos modelos de se orientar no mundo e compreendê-lo. Nessa tarefa, os modelos precisam criar a imagem de uma pirâmide usando caracteres de texto que, quando impressos em uma folha de papel comum, criariam uma ilusão 3D. Em outras palavras, a pirâmide deve parecer tridimensional quando vista de um ângulo. Mais uma vez, envio esse prompt ao Pi e espero pelo resultado. Enquanto o modelo trabalha, vou mostrar como Opus 5.5 e GPT-6 resolveram

05:45 essa tarefa. Você pode ver os detalhes no meu vídeo recente, em que comparei e testei esses modelos. Na época, gostei mais da versão do Opus. Certo, vamos voltar ao modelo de hoje. Ele terminou a tarefa e gerou vários arquivos. O primeiro é um script em Python. Parece que o modelo o usou para gerar as imagens. Depois vêm as próprias imagens. Vamos abrir o arquivo PNG. É, dá para ver que o modelo entendeu a tarefa corretamente e

06:16 até começou a seguir na direção certa. Mas ainda não conseguiu concluir a tarefa com sucesso. Vamos também conferir o arquivo SVG. Sim, é mais ou menos a mesma coisa aqui, mas parece haver também algum erro no arquivo. O arquivo de texto basicamente mostra a mesma coisa. Certo, infelizmente o modelo não conseguiu dar conta dessa tarefa, mas, para ser justo, ela é muito difícil. Ainda assim, no geral, foi uma tentativa muito boa. Bem, acho que já podemos tirar algumas conclusões. Apesar do meu ceticismo inicial, tanto

06:47 essa maneira de executar o modelo quanto o próprio modelo tiveram um desempenho muito bom. Eu esperava algo pior. É claro que essas ainda não são minhas conclusões finais, e vou continuar testando tudo isso nas próximas semanas. Mas minhas primeiras impressões são muito positivas. E é isso por hoje. Não se esqueça de se inscrever no canal e na minha newsletter semanal sobre TI e IA. O link está na descrição. Até breve. Fiquem bem.

Transcrição original

[00:00] A few days ago, a project called Strata was released that let you run the 125 billion parameter Frontier model when 3.8 flash next on a regular GPU with 16 or even 12 gigabytes of video RAM. Of course, I could not just ignore something like this. So, I decided to try it myself. However, I’m not as interested in simply getting the model running as I am in whether it can actually handle practical tasks. Right now, I have two GPUs that would work for

[00:30] today’s test. One is an RTX 4060 Ti with 16 gigabytes of RAM, and the other is Radeon with 32 gigabytes. I will choose the first one because it is much closer to what you would find in a typical PC. And that is exactly the kind of hardware today’s project is targeting. There is also one important point. Strata itself requires 64 gigabytes of system RAM to run when 3.8 flash next. I have 128

[01:01] gigabytes installed, so that is more than enough. However, if you want to try running it as well, keep this in mind. A good GPU alone is not enough. You also need a lot of RAM. Now, just a few words about how it is even possible to run 125 billion parameter model on a regular GPU. The reason is that this is a mixture of expert model, meaning it consists of a large number of experts. It has more than 24,000 experts, but only 10 of them are used to generate

[01:31] each token. So, at every step, only around 6 billion parameters are actually active rather than all 125 billion. Okay, enough theory, and let us move on to practice. I connect to the desktop over SSH and start the server. Strata does not have ready-made Linux built yet, and the releases currently only include Windows. So, I build the agent myself. Loading the model itself takes around 30 seconds. By the way, Strata basically takes over the entire computer. Right now, the agent is using

[02:03] her own 36 GB of system RAM. Video memory is almost completely full. So, this is not a background service that runs alongside with other workloads. While Strata is running, the computer is basically dedicated to it. To measure the model’s performance on my hardware, I wrote a Python script that benchmarks it. It uses two prompts. One requires a text response, while the other asks the model to write code. And then, it sends several requests to the model so that I can get meaningful average numbers.

[02:35] Okay, I got an average of around 65 tokens per second. Considering that my GPU is weaker than the one used by the project’s authors, the result is quite close to what they reported. However, as I said at the beginning, token generation speed is great, but I am much more interested in how good the model’s answers are in this configuration. So, let us move on to some practical tests. For the tests, I will use my repository with a collection of prompts. They are grouped from simple to complex, and I

[03:06] will go through them in that order. By the way, this repository is available on GitHub, so you can download it and experiment with it yourself. I will use Pi as the agent. I really like it because of how minimal and extensible it is. So, for the first test, I will use a task where the model needs to create an HTML page with a clock, stopwatch, and timer. This is a fairly simple test for such a large model, so it is more of a check that the model actually works on my machine at all. And since this is the

[03:38] easiest task, I will not create any plan and will simply ask it to implement the project based on the description. Okay, the model finished the work pretty quickly. So, let us see what we got. Yes, everything looks the way it should. There is a clock, the stopwatch works, and [snorts] there is also a timer. Yeah, everything looks great. The easiest test is passed. Let us move on to something more difficult. Next, I move on to a medium-difficulty task. The goal is to build a pixel editor. Again,

[04:09] I switch to the Pi agent and ask it to implement the project still without creating an implementation plan beforehand. Let us see if the model can handle it. By the way, while the model is working, I will show you the system load. As you can see, the GPU is fully utilized. Ignore the second graph, that is the integrated GPU. Around 40 GB of system RAM are being used and roughly half of the CPU cores are fully loaded. Okay, the model has finished the work.

[04:39] It took 5 minutes and 20 seconds. Very good for a local model, but let us take a look at the result. Okay, it looks the way it should. Let me check if it works. Yes, it looks like the pixel editor is working. The tools and colors can be changed and there do not seem to be any errors. Great. I did not expect the model to complete this task successfully on the first try. Well, in that case, I will move on to even more difficult tasks, the kind that I usually give to models from Anthropic and OpenAI. And

[05:12] the third task will be an unusual one. It will test how well models can orient themselves in our world and understand it. In this task, the models need to create an image of a pyramid using text characters that, when printed on a regular sheet of paper, would create a 3D illusion. In other words, the pyramid should appear three-dimensional when viewed from an angle. Again, I send this prompt to Pi and wait for the result. And while the model is working, I will show you how Opus 5.5 and GPT-6 solved

[05:45] handled this task. You can see the detail in my recent video where I compared and testing these models. At the time, I liked the Opus version more. Okay, let us get back to today’s model. It finished the task and generated several files. The first one is a Python script. It looks like the model used it to generate the images. Then there are the images themselves. Let us look at the PNG file. Yeah, you can see that the model understood the task correctly and

[06:16] even started moving in the right direction. But it still could not complete the task successfully. Let us also take a look at the SVG file. Yes, it is roughly the same here, but there also seems to be an error somewhere in the file. And the text file basically shows the same thing. Okay, unfortunately, the model could not handle this task, but to be fair, it is a very difficult one. Still, overall, it was a pretty good attempt. Well, I think we can already draw some conclusions. Despite my initial skepticism, both of

[06:47] this way of running the model and the model itself performed very well. I expected it to be worse. Of course, these are not my final conclusions yet, and I will continue testing all of this over the next few weeks. But my first impressions are very positive. And that is all for today. Do not forget to subscribe to the channel and to my weekly newsletter about IT and AI. The link in the description. See you soon. Take care.