Este modelo de IA de 125B roda 5 vezes mais rápido no meu PC do que na nuvem (com Strata)

Autoria: Better Stack · 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: This 125B AI Model Runs 5x Faster on My PC Than in the Cloud (Using Strata) · Canal: Better Stack · 08:38 · Assistir no YouTube

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

Resumo

O vídeo demonstra o Strata, um projeto open source que permite executar localmente um modelo de 125 bilhões de parâmetros distribuindo o trabalho entre GPU, CPU, RAM e SSD. Em um PC com RTX 5090, o modelo alcança mais de 250 tokens por segundo e, nos testes apresentados, geralmente supera em velocidade a versão na nuvem. O apresentador explica como a arquitetura mixture of experts, a distribuição dos especialistas e a speculative decoding contribuem para o desempenho. Ele ressalta que a comparação não é perfeitamente equivalente, pois usou uma versão quantizada de 2 bits localmente e as condições do provedor de nuvem podem variar.

Pontos-chave

O Strata executa localmente um modelo de 125 bilhões de parâmetros, distribuindo o trabalho entre GPU, CPU, RAM e SSD.
O modelo usa a arquitetura mixture of experts: seleciona 10 especialistas por vez, de um total de 512 por camada.
A GPU mantém os dados mais usados, enquanto os especialistas restantes ficam na RAM e uma tabela de consulta grande permanece no SSD.
A speculative decoding usa um modelo auxiliar para prever tokens, que o modelo maior verifica em conjunto.
No PC com RTX 5090, o apresentador mediu mais de 250 tokens por segundo; o README menciona até cerca de 94 tokens por segundo em uma RTX 5070 de 12 GB.
Nos testes, o Strata foi mais rápido em tarefas de programação e escrita, mas empatou aproximadamente com a nuvem em um quebra-cabeça lógico.
A configuração exigiu o download de cerca de 70 GB; o apresentador recomenda pelo menos 12 GB de VRAM, 32 GB de RAM e cerca de 80 GB livres em disco.
O modelo local usava quantização de 2 bits, enquanto a versão na nuvem provavelmente era maior; por isso, o apresentador considera os resultados principalmente uma comparação de velocidade.
A eletricidade estimada para gerar uma resposta de 33 segundos custou menos de um décimo de centavo, sem incluir o preço do computador.

Capítulos

Início	Capítulo	Resumo
00:00	Modelo local e comparação inicial	O apresentador compara a velocidade do modelo executado no PC com a de uma versão na nuvem e introduz o Strata.
01:36	Como o Strata distribui o processamento	O vídeo explica a arquitetura mixture of experts, o uso de GPU, RAM e SSD e o papel da speculative decoding.
04:20	Instalação e testes práticos	O apresentador descreve a configuração necessária e compara o desempenho em tarefas de programação, lógica e escrita.
07:35	Limitações e conclusão	O vídeo contextualiza a comparação entre as versões local e na nuvem e conclui que executar modelos grandes em PCs domésticos está cada vez mais viável.

Citações

Meu PC terminou em 6,6 segundos, enquanto a nuvem levou 33 segundos. — 00:00

Os dois acabam trabalhando na mesma camada ao mesmo tempo. — 02:43

Os dois caíram no clássico problema do taco e da bola e disseram que a bola custa 10 centavos. — 05:57

Eu consideraria isso apenas um teste de velocidade. — 07:35

Executar IA localmente está ficando cada vez mais viável. — 08:07

Conceitos e entidades

Strata (ferramenta): Projeto open source que distribui a execução de modelos grandes entre GPU, CPU, RAM e SSD.
Qwen3.8 Flash Next (modelo): Modelo de 125 bilhões de parâmetros descrito no vídeo como mixture of experts.
Qwen3.8 Flash (modelo): Modelo usado pelo apresentador como referência de comparação na nuvem.
Mixture of Experts (conceito): Arquitetura em que apenas um subconjunto de especialistas é selecionado para processar cada token.
speculative decoding (conceito): Técnica em que um modelo auxiliar prevê tokens e o modelo principal verifica as previsões em conjunto.
RTX 5090 (modelo): GPU usada pelo apresentador para executar o modelo localmente.
OpenRouter (ferramenta): Serviço citado como intermediário para executar o modelo de comparação na nuvem.
Better Stack (empresa): Canal que publicou o vídeo.

Tradução completa (pt-BR)

00:00 O que você está vendo aqui agora é um modelo de IA com 125 bilhões de parâmetros rodando no meu próprio computador, bem aqui na minha mesa, e ele está passando de 250 tokens por segundo. À direita, estou com o Qwen 3.8 flash rodando na nuvem pelo open router, e ele está fazendo cerca de 60. Dei exatamente o mesmo prompt para os dois, e meu PC terminou em 6,6 segundos, enquanto a nuvem levou 33 segundos. E isso não aconteceu só uma vez: em praticamente todos os testes que fiz, minha máquina concluiu

00:34 a tarefa de três a cinco vezes mais rápido. Agora, como isso é possível? Bem, o que torna isso possível é um projeto gratuito e open source chamado Strata. Normalmente, um modelo tão grande fica em algum servidor, porque até mesmo a menor versão decente dele é um arquivo de 66 GB, e tudo precisa ficar na memória enquanto ele está rodando. Até minha placa de vídeo RTX 5090 tem apenas 32 GB de VRAM. Então, ele não cabe na placa de vídeo, mas o Strata contorna isso de um jeito bem

01:06 inteligente, fazendo o PC inteiro dar uma mão. Sua placa de vídeo, sua CPU, sua RAM e até seu SSD acabam fazendo parte do trabalho. Neste vídeo, vou mostrar o que é o Strata, >> [música] >> como ele consegue fazer isso e, depois, vamos analisar alguns testes lado a lado. Vai ser bem divertido, então vamos começar. Primeiro, uma observação rápida sobre o próprio modelo. O Qwen 3.8 flash next é um modelo de mistura

01:36 de especialistas, e já falamos bastante sobre modelos de mistura de especialistas neste canal, então não vou me aprofundar nisso aqui. Mas, resumindo, cada camada tem 512 desses especialistas, e o modelo escolhe apenas 10 deles por vez. Então, embora o modelo inteiro tenha 125 bilhões de parâmetros, apenas cerca de 6 bilhões deles estão realmente fazendo alguma coisa para cada token. E é nisso que o Strata se baseia. O que cada token precisa corresponde a apenas cerca de 3,5 GB, então isso fica na placa de vídeo, e o restante da placa é ocupado

02:09 pelos especialistas mais frequentemente selecionados. Depois, todos os 24.576 especialistas ficam na RAM comum, e o SSD entra em cena porque o modelo também tem uma enorme tabela de consulta que, sozinha, ocupa quase 29 GB. Então, o Strata deixa essa tabela no SSD e pega apenas algumas linhas minúsculas dela para cada token. Ele as busca com uma etapa de antecedência, para você nem perceber. Agora, a parte que achei muito legal é que, para cada camada, a GPU identifica quais são os 10 especialistas de que precisa e deixa

02:43 os IDs deles em um pequeno espaço na memória compartilhada, que o artigo chama de campainha. A CPU fica esperando por isso e, assim que a campainha toca, divide o trabalho. Os especialistas que já estão na GPU são processados lá, e a CPU calcula o restante direto na RAM. Assim, as duas acabam trabalhando na mesma camada ao mesmo tempo. Além disso, há decodificação especulativa. O modelo vem com um pequeno auxiliar que prevê os próximos tokens, e o modelo grande verifica todos de uma vez e mantém aqueles com os quais concorda. A

03:17 resposta sai exatamente igual; ela só chega cerca de 1,6 a 1,8 vezes mais rápido. E, no meu próprio teste, o modelo grande concordou com o auxiliar em cerca de 79% das vezes. Agora, o readme diz que ele chega a cerca de 94 tokens por segundo em uma RTX 5070 de 12 GB, e nos meus testes eu passava de 250. Isso porque rodei o modelo na minha RTX 5090 de 32 GB e, segundo o artigo, a VRAM importa muito

03:49 mais do que a velocidade bruta da GPU. Cada gigabyte extra comporta cerca de 700 especialistas a mais, então, numa 5090, a maioria deles cabe, e sobra muito pouco trabalho para a CPU. Além disso, meus prompts e respostas eram mais curtos do que os do readme, e a velocidade diminui um pouco conforme as conversas ficam mais longas, então não é uma comparação perfeitamente equivalente. Também precisamos levar em conta que a nuvem pode estar mais lenta porque o provedor do open router compartilha o hardware entre muitas

04:20 pessoas, enquanto minha GPU está atendendo só a mim. Certo, mas, dito isso, vamos testar de verdade. A configuração é muito fácil: basta executar este script, escolher o modelo e o tamanho, e então ele baixa cerca de 70 GB e abre um pequeno app de chat no navegador. Escolhi a versão quantizada de dois bits, que é a menor e mais rápida, e estou rodando na minha 5090, com um processador Core Ultra 9 285K e 62 GB de RAM. E um

04:52 aviso: na primeira vez que carregar, seu PC pode travar por alguns minutos, e você vai precisar de pelo menos 12 GB de VRAM, 32 GB de RAM e cerca de 80 GB de espaço livre em disco para conseguir colocá-lo para funcionar. Além disso, depois de carregado, ele praticamente toma conta da sua GPU inteira. Na minha máquina, usou quase todos os 32 GB de VRAM, além de outros 39 GB de RAM comum. Para tornar a comparação justa, montei um app pequeno que envia o mesmo prompt para o Strata à

05:23 esquerda e para o Qwen 3.8 Flash à direita, e acompanha a velocidade, o tempo e o custo. Primeiro, passei aos dois uma tarefa simples de programação em Python: encontrar a maior substring palíndroma em uma string. O Strata terminou em cerca de 4 segundos, enquanto a nuvem levou quase 19 segundos. Quanto às respostas, as duas parecem bem parecidas. Até os casos de teste fornecidos eram muito semelhantes. Depois, tentei um quebra-cabeça lógico rápido, e esse terminou praticamente empatado, em 1,4 contra 1,5 segundo, principalmente porque a nuvem mal pensou

05:57 no problema. Curiosamente, os dois caíram no clássico truque do taco e da bola e disseram que a bola custava 10 centavos, quando, na verdade, a resposta certa é cinco. Mas vou culpar o próprio modelo por isso, não as ferramentas que estou usando. Depois, dei a eles um prompt divertido para escrever uma descrição de uma torradeira secretamente viva, e isso levou cerca de 3 segundos com o Strata, contra 10 com a versão na nuvem. Em seguida, passei uma tarefa grande aos dois. Pedi um guia detalhado sobre como montar um servidor de laboratório doméstico e aumentei o limite para

06:30 9.000 tokens. O Strata escreveu mais de 8.000 tokens em 33 segundos. Já o modelo na nuvem continuou pensando, pensando e pensando. Ele gastou todo o limite de 9.000 tokens com raciocínio e, depois de quase 3 minutos, ainda não tinha escrito uma palavra sequer da resposta em si. Agora, para ser justo, não acho que essa parte seja realmente sobre velocidade, porque o tempo que um modelo leva pensando depende de como o provedor o configurou. Mas, mesmo que tivesse escrito

07:01 a mesma resposta a cerca de 54 tokens por segundo, teria precisado de aproximadamente 2 minutos e meio, o que ainda são 2 minutos a mais do que o resultado do Strata. Então, para manter a comparação justa, executei o teste de novo com o modo de pensamento desativado. Dessa vez, os dois realmente me deram uma resposta completa, e o Strata terminou em 6,6 segundos, enquanto a nuvem levou 37 segundos. E, se você está se perguntando sobre o custo, a eletricidade para aquela resposta de 33 segundos custou menos de um décimo de centavo. Claro, isso não inclui o preço da própria RTX 5090, o que já é outra

07:35 história. >> [risadas] >> E lembre-se também de que estou rodando localmente uma versão de dois bits, enquanto a nuvem provavelmente está usando uma versão maior do modelo. Então, eu encararia isso apenas como um teste de velocidade. Mas, para ser justo, nos meus testes, a versão de dois bits deu respostas praticamente no mesmo nível das do modelo na nuvem. E é isso, pessoal. Esse é o Strata em poucas palavras. Sinceramente, não esperava que um modelo tão grande rodasse em um único PC gamer, muito menos que superasse o modelo na nuvem por essa

08:07 muito. E é meio incrível como esse espaço está avançando rápido, porque projetos como esse continuam encontrando maneiras mais inteligentes de fazer modelos enormes caberem no hardware que já temos em casa, e executar IA localmente está ficando cada vez mais viável. Então, se você tem uma GPU potente por aí, com certeza recomendo experimentar o Strata. E, se experimentar, conte nos comentários que velocidades está conseguindo. E pessoal, se vocês gostam desse tipo de análise técnica, avisem-me clicando no botão de curtir logo abaixo do

08:38 vídeo. E também não se esqueçam de se inscrever no nosso canal. Aqui foi Andris, da Better Stack, e vejo vocês nos próximos vídeos. >> [música] [música]

Transcrição original

[00:00] What you’re looking at here right now is a 125 billion parameter AI model running on my own computer right here at my desk and it’s pushing over 250 tokens per second. On the right, I’ve got Qwen 3.8 flash running in the cloud through open router and it’s doing around 60. I gave them both the exact same prompt and my PC was done in 6.6 seconds while the cloud took 33 seconds. And this wasn’t just a one-off either because in pretty much every test I did, my machine did

[00:34] the task three to five times faster. Now, how is that possible? Well, the thing that makes this possible is a free and open source project called Strata. Now, normally a model this big lives on a server somewhere because even the smallest decent version of it is a 66 GB file and it all has to sit in memory while it runs. Even my RTX 5090 graphics card only has 32 GB of VRAM. So, it can’t fit on the graphics card, but Strata gets around that in a pretty

[01:06] clever way by getting your whole PC to pitch in. Your graphics card, your CPU, your RAM, and even your SSD all end up doing a piece of the work. So, in this video, I’ll show you what Strata is, >> [music] >> how it actually pulls this off, and then we’re going to go through some test runs side by side. It’s going to be a lot of fun, so let’s dive into it. So, first, a quick word about this model itself. Qwen 3.8 flash next is a mixture

[01:36] of experts model and we’ve talked a lot about mixture of experts models on this channel before, so I won’t go deep into it here, but the short version is that each layer has 512 of these experts and it only picks 10 of them at a time. So, even though the whole thing is 125 billion parameters, only about 6 billion of them are actually doing anything for any given token. And that’s what Strata builds on. The stuff that every token needs is only about 3.5 GB, so that lives in your graphics card, and the rest of the card gets filled with

[02:09] the experts that get picked up the most. Then, all 24,576 experts sit in your regular RAM, and the SSD comes in because the model also has a huge lookup table that’s almost 29 GB on its own. So, Strata leaves that on the SSD and only grabs a few tiny rows of it for each token, and it grabs them a step early, so you never feel it. Now, the part that I found really cool is that for every layer, the GPU figures out which 10 experts it needs and leaves

[02:43] their IDs in a little spot in shared memory, which the paper actually calls a doorbell. The CPU is just waiting for it, and as soon as it rings, it splits up the job. Experts that are already on the GPU get handled there, and the CPU crunches the rest right into RAM. So, both of them end up working on the same layer at the same time. And on top of that, there’s speculative decoding. The model comes with a tiny helper that guesses the next few tokens, and the big model checks them all in one go and keeps the ones it agrees with. The

[03:17] answer comes out exactly the same, it just gets there about 1.6 to 1.8 times faster. And in my own test, the big model agreed with the helper about 79% of the time. Now, the readme states it gets up to about 94 tokens per second on a 12 GB RTX 5070, and in my tests, I was getting over 250. And that’s because I ran it on my RTX 5090 with 32 GB, and according to the paper, VRAM matters way

[03:49] more than raw GPU speed. Every extra gigabyte fits around 700 more experts, so on a 5090 most of them fit and the CPU barely has anything left to do. And my prompts and answers were also shorter than the ones in the readme and it does slow down a bit as chats get longer, so it’s not a perfect apples-to-apples comparison. And we have to take into account that the cloud might also be slower because the open router provider is sharing its hardware between tons of

[04:20] people while my GPU is only serving me. Okay, but with that said, let’s actually try it. Setting it up is really easy because you just run this one script and it asks you which model and which size you want and then it downloads about 70 GB and opens a little chat app in your browser. I went with the two-bit quantized version, which is the smallest and fastest one and I’m running it on my 5090 with a Core Ultra 9 285K processor and 62 GB of RAM. And just a

[04:52] heads up, the first time it loads your PC might freeze for a couple of minutes and you’ll need at least 12 GB of VRAM, 32 GB of RAM and around 80 GB of free disk space to actually get it off the ground. And also once it’s loaded, it pretty much takes over your whole GPU. On my machine it used almost all of the 32 GB of VRAM plus another 39 GB of normal RAM. And to make the comparison fair, I put together a little app where I send the same prompt to Strata on the

[05:23] left and to Qwen 3.8 Flash on the right and it keeps track of the speed, the time and the cost. So I first gave them a simple Python coding task to find the longest palindromic substring in a string and Strata was done in about 4 seconds while the cloud took almost 19 seconds. As far as the output, they both seem to be pretty similar. Even the test cases they provided were both very similar. And then I tried a quick logic puzzle, and this one was pretty much a tie at 1.4 versus 1.5 seconds, mostly because the cloud barely thought about

[05:57] it at all. Funnily enough, they both fell for the classic bat and ball trick and said that the ball costs 10 cents, when in reality the right answer is actually five, but I’m just going to blame this on the model itself, not on the tools I’m using. And then I gave them a fun prompt to write description for a toaster that’s secretly alive, and that took about 3 seconds for Strata versus 10 for the cloud version. Then I gave them both a big task. I asked for a detailed guide on building a home lab server, and I increased the limit to

[06:30] 9,000 tokens, and Strata wrote over 8,000 tokens in 33 seconds. And as for the cloud model, well, it just kept thinking and thinking and thinking. It burned through the whole 9,000 token limit on reasoning, and after almost 3 minutes, it still hadn’t written a single word of the actual answer. Now, to be fair, I don’t think this part is really about speed, because how long a model thinks depends on how the provider is set up. But even if it had written

[07:01] the same answer at around 54 tokens per second, it would have needed about 2 and 1/2 minutes, which is still 2 minutes more than Strata’s result. So, just to keep things fair, I ran it again with thinking turned off, and this time they both actually gave me a full answer, and Strata was done in 6.6 seconds, while the cloud took 37 seconds. And if you’re wondering about cost, well, the electricity for that 33-second answer was less than a tenth of a cent. Of course, that’s not counting the price of the RTX 5090 itself, which is a whole

[07:35] ’nother story. >> [laughter] >> And also keep in mind that I’m running a 2-bit version locally, and the cloud is probably running a bigger version of the model. So, I would only really look at this as a speed test. But, to be fair, in my tests, the two-bit version gave answers that were pretty much on par with the cloud model. So, there you have it, folks. That is Strata in a nutshell. Honestly, I didn’t expect the model this big to run on a single gaming PC at all, let alone beat the cloud model by that

[08:07] much. And it’s kind of crazy how fast this space is moving because projects like these keep finding smarter ways to squeeze huge models onto the hardware we already have at home and running AI locally keeps getting more and more realistic. So, if you’ve got a beefy GPU lying around, I’d definitely give Strata a try. And if you do give it a shot, let me know in the comments what kind of speeds you’re getting. And folks, if you like these types of technical breakdowns, please let me know by smashing that like button underneath the

[08:38] video. And also, don’t forget to subscribe to our channel. This has been Andris from Better Stack, and I will see you in the next videos. >> [music] [music]