Qwen3.8-27B roda em uma placa de vídeo de 8 GB: minha configuração gratuita exata

Autoria: Hyperautomation Labs · 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: Qwen3.8-27B Runs on an 8GB Graphics Card: My Exact Free Setup · Canal: Hyperautomation Labs · 06:37 · Assistir no YouTube

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

Resumo

O vídeo demonstra como executar o Qwen3.8-27B em uma placa de vídeo de 8 GB usando llama.cpp, sem assinatura nem API, e compara versões quantizadas de 2, 3 e 4 bits. A versão de 3 bits obteve a melhor pontuação nos testes de código, enquanto a de 2 bits foi a mais rápida. O apresentador explica as configurações necessárias para evitar erros de memória e mostra como conectar o modelo a uma ferramenta de programação. Também apresenta opções para GPUs na nuvem e Macs, além de soluções para problemas comuns.

Pontos-chave

O Qwen3.8-27B pode ser executado localmente em uma placa de vídeo de 8 GB com llama.cpp.
A versão de 2 bits alcançou 33 tokens por segundo e usou cerca de 7,5 GB de VRAM.
A versão de 3 bits marcou 29 de 30 no teste de código, superando as versões de 2 e 4 bits.
A versão de 4 bits foi a mais lenta e precisou de quase 11 GB de RAM convencional.
As opções NP1 e de memória de chat em 8 bits ajudam a evitar erros de falta de memória.
O llama-server permite conectar o modelo local a ferramentas de IA compatíveis com um endereço de servidor configurável.
Kaggle oferece acesso gratuito a GPUs de 16 GB por algumas horas por semana.
Reduzir o contexto ou escolher um arquivo de modelo menor pode melhorar o desempenho quando há muita transferência para a RAM.

Capítulos

Início	Capítulo	Resumo
00:00	Apresentação e requisitos de memória	O vídeo introduz a execução do modelo em uma GPU de 8 GB e explica como quantização e RAM afetam o uso de memória.
01:30	Instalação e três receitas	O apresentador explica os passos com llama.cpp e compara velocidade, memória e contexto das versões de 2, 3 e 4 bits.
03:02	Testes de qualidade e configurações de memória	As três versões são avaliadas em tarefas de código e recuperação, e são apresentadas as opções para evitar erros de memória.
04:34	Integração com ferramentas e alternativas	O vídeo mostra o modelo corrigindo um teste em Open Code e apresenta opções de execução com GPU na nuvem ou em um Mac.
06:06	Solução de problemas e recomendações	O apresentador resume ajustes para problemas comuns e recomenda a versão de 2 bits para velocidade ou a de 3 bits para melhores respostas.

Citações

Isso é esse modelo em uma placa de 8 GB escrevendo código funcional a 33 tokens por segundo. — 00:00

Em uma placa de 8 GB, maior não significou mais inteligente; só ficou mais lento. — 03:34

Com essas duas mudanças, ele cabe com folga. — 04:04

Uma placa de 8 GB é suficiente para executar um dos melhores modelos gratuitos disponíveis hoje. — 06:37

Conceitos e entidades

Qwen3.8 27B (modelo): Modelo apresentado no vídeo, testado em versões quantizadas de 2, 3 e 4 bits.
llama.cpp (ferramenta): Mecanismo gratuito usado para executar o modelo localmente em Windows e Linux.
quantização (conceito): Redução da precisão usada para armazenar os números do modelo, diminuindo seu tamanho e suas exigências de memória.
NGL 99 (repo): Origem do arquivo quantizado de 2 bits usado na receita A.
Research Lab ISTA (empresa): Responsável pelo arquivo quantizado de 3 bits descrito como preparado para manter bom desempenho em tamanhos menores.
RTX 5060 (modelo): Placa de vídeo usada nos testes, com 8 GB de memória gráfica.
OpenCode (ferramenta): Agent de programação gratuito usado para demonstrar o modelo local corrigindo um erro em um projeto.
Kaggle (empresa): Plataforma mencionada como opção para usar GPUs gratuitas na nuvem.
Ollama (ferramenta): Ferramenta citada para executar o arquivo do modelo na GPU disponibilizada pelo Kaggle.
OpenAI (empresa): Empresa usada como referência para explicar o endereço de servidor oferecido pelo llama-server.

Tradução completa (pt-BR)

00:00 Você tem uma placa de vídeo com 8 GB. Todos os guias do Qwen 3.8 27B dizem que você precisa de 24. Este é esse modelo numa placa de vídeo com 8 GB, escrevendo código funcional a 33 tokens por segundo. Isso é mais rápido do que você consegue ler. Sem assinatura, sem chave de API, nada sai da máquina. Nos próximos 10 minutos, você vai receber a configuração exata. Três versões, dependendo do que você prioriza, as duas configurações que fazem o modelo caber e qual versão é realmente a

00:30 mais inteligente. A resposta me surpreendeu. Não tenho uma placa de vídeo com 8 GB, então aluguei um PC gamer comum com uma. Uma RTX 5060, a placa Nvidia nova mais barata, um Ryzen 5 e memória DDR5 comum. Custou 20 centavos por hora. Esse é o tipo de PC que muitos de vocês já têm. Um pouco de contexto. O Qwen 3.8 27B foi lançado em 5 de agosto. É grátis. A licença permite usar o modelo no trabalho, e ele foi baixado quase 7 milhões de vezes em 2

01:00 meses. As pessoas o usam como assistente de programação, um ChatGPT privado e o cérebro por trás das automações. O problema sempre foi a memória. Aqui está toda a matemática de que você precisa. O modelo completo ocupa cerca de 54 GB. Uma quantização é uma cópia reduzida que armazena cada número com menos bits. Com 4 bits, ocupa 16 GB e meio. Com 3 bits, cerca de 10. Com 2 bits, pouco mais de 7. E esse modelo tem um projeto que ajuda. Ele tem 64 camadas, mas só 16 delas mantêm

01:30 uma memória crescente da conversa. Então, o próprio chat ocupa muito pouco. A regra é simples. Tudo o que não couber na placa vai para a RAM normal, e quanto mais coisa for para lá, mais lento fica. A configuração tem [música] duas etapas. Primeiro, baixe o llama.cpp. É o mecanismo gratuito por trás da maioria dos aplicativos de IA local, e há uma versão pronta para baixar para Windows e Linux. Segundo, baixe um arquivo do modelo. O arquivo depende da receita que você escolher. A receita A é o arquivo de 2 bits. O NGL 99

02:02 coloca todas as camadas na placa de vídeo. O resultado: 33 tokens por segundo, usando 7 GB e meio dos 8 GB e apenas cerca de um gigabyte e meio da RAM normal. O context window é de 8.000 tokens, o que é suficiente para conversar e fazer pequenos trabalhos de programação. Três desses parâmetros são os que fazem a maior diferença, e já vou mostrar por quê. A receita B é um arquivo de 3 bits feito pelo Research Lab ISTA [música], desenvolvido para continuar inteligente mesmo em tamanhos pequenos. Ele ocupa 10 GB, então

02:32 não cabe na placa. Você não precisa calcular a divisão por conta própria. Fit on diz ao llama.cpp para colocar o máximo possível na placa e o restante na RAM. Ele usou 5 GB de RAM normal, então um PC com 16 GB dá conta. A velocidade cai para 6 tokens e meio por segundo, mais ou menos a velocidade de leitura, e você tem o dobro de context window. A receita C é o arquivo de 4 bits, aquele que a maioria dos guias recomenda. A maior parte fica na RAM, quase 11 GB, então você precisa de um PC com pelo menos 16 GB, e 32 GB para

03:02 ficar tranquilo. A velocidade é de 3 tokens por segundo, o que serve para tarefas que você inicia e deixa rodando. Mas ele é mais inteligente? Essa é a verdadeira pergunta. Velocidade não significa nada se as respostas estiverem erradas. Então, dei as mesmas tarefas aos três modelos: escrever uma função que passe em 10 testes, com três tentativas cada; encontrar um bug escondido num arquivo de 170 linhas; e extrair um código da primeira página de um documento longo. Os três encontraram o bug e o código. No teste de programação, o arquivo de 3 bits fez 29 de 30 pontos. O arquivo de 2 bits fez

03:34 27, e o arquivo maior, de 4 bits, aquele que todo mundo recomenda, fez 22. Numa das tentativas, ele escreveu um código que falhava com qualquer entrada. Então, numa placa de 8 GB, o maior não era mais inteligente; era só mais lento. Aqui está o problema que eu realmente encontrei. Execute a receita A com as configurações padrão e ela dá erro por falta de memória. Há dois motivos. Por padrão, o servidor reserva espaço para quatro conversas simultâneas; NP1 faz com que seja apenas uma. E, por padrão,

04:04 a memória do chat é armazenada em 16 bits. CTK e CTVQ8 armazenam essa memória em 8 bits, usando metade do espaço. Com essas duas mudanças, o modelo cabe com espaço de sobra. Você também vai ver gente alertando que reduzir a memória do chat para 4 bits deixa o modelo discretamente menos inteligente. Eu testei. Mesmo prompt, mesma seed. As duas versões deram as respostas certas, palavra por palavra, na busca pelo bug, e a versão de 4 bits economizou um gigabyte e meio de RAM. Então, se a memória estiver curta, vale a pena tentar.

04:34 Todos os comandos deste vídeo, além da receita certa para placas de 12, 16 e 24 GB, estão num PDF gratuito. Comente “8 GB” que eu envio para você. Executar o modelo num terminal é legal. Colocá-lo para trabalhar é melhor. O llama-server fornece um endereço da web do mesmo tipo que o OpenAI oferece, mas na sua própria máquina. Assim, qualquer ferramenta de IA que permita mudar o endereço pode usá-lo. Aqui está ele no Open Code, um agent de programação gratuito. São cerca de doze linhas de configuração. Este pequeno projeto de loja tem um teste que falha. Peço que ele encontre o bug e o corrija.

05:05 Ele lê o código, percebe que a verificação do desconto diz “maior que 10”, quando a regra diz “10 ou mais”, muda um caractere e executa os testes de novo. Os quatro passam. Tudo isso na placa de 8 GB. Sem placa de vídeo. Duas opções. Uma: GPUs na nuvem gratuitas. O Kaggle oferece uma GPU gratuita de 16 GB por várias horas toda semana. E o mesmo arquivo da receita B roda lá pelo Ollama. Oito tokens por segundo, sem configuração.

05:35 Duas: se você tem um Mac com 24 GB, ele roda na GPU integrada ao chip. No meu MacBook, chega a 12,7 tokens por segundo com a internet bloqueada. >> [música] >> Cinco problemas comuns e como resolvê-los. Falta de memória. Adicione NP1 e os parâmetros de memória do chat Q8 ou mude para Fit on. Muito lento. Tem coisa demais indo para a RAM. Então, escolha um arquivo menor ou um context window mais curto. Fica pensando para sempre antes de responder. Defina o esforço de raciocínio como baixo.

06:06 Lento numa CPU grande de servidor. Informe quantos núcleos usar com T. E o navegador também usa memória da GPU. Então, feche o Chrome antes de carregar o modelo. Falando sério: 90% de vocês que estão assistindo ainda não se inscreveram. No Facebook, o botão de inscrição é o de apoiador. É isso que mantém as luzes acesas por aqui. No YouTube, é grátis e diz ao algoritmo para mostrar mais conteúdo nosso. Inscreva-se para nos apoiar. Resumindo: quer velocidade? Escolha A. Quer as melhores respostas? Escolha B, o

06:37 arquivo de 3 bits, que superou o maior. Ignore o arquivo maior, a menos que você tenha bastante RAM e paciência. Uma placa de 8 GB é suficiente para rodar um dos melhores modelos gratuitos disponíveis hoje. Comente “8 GB” para receber a folha completa com as receitas e conte qual é a sua placa e qual velocidade você consegue. Acompanhe a gente no Instagram e no Facebook para dicas rápidas de IA; os guias aprofundados estão aqui no YouTube. Inscreva-se para não perder nenhum.

Transcrição original

[00:00] You have an 8-gig graphics card. Every guide for Quen 3.8 27B says you need 24. This is that model on an 8-gig card writing working code at 33 tokens a second. That’s faster than you can read. No subscription, no API key, nothing leaves the machine. In the next 10 minutes, you get the exact setup. Three versions depending on what you care about, the two settings that make it fit, and which version is actually the

[00:30] smartest. The answer surprised me. I don’t own an 8-gig card, so I rented a normal gaming PC with one. An RTX 5060, the cheapest new Nvidia card, a Ryzen 5, and regular DDR5 memory. It cost 20 cents an hour. That’s the kind of PC a lot of you already have. Quick context. Quen 3.8 27B came out on August 5th. It’s free. The license lets you use it for work, and it’s been downloaded almost 7 million times in 2

[01:00] months. People use it as a coding assistant, a private chat GPT, and the brain inside their automations. The catch has always been memory. Here’s all the math you need. The full model is about 54 gigs. A quant is a shrunk copy that stores each number with fewer bits. At 4-bit, it’s 16 and 1/2 gigs. At 3-bit, about 10. At 2-bit, just over seven. And this model has a lucky design. It has 64 layers, but only 16 of them keep

[01:30] a growing memory of the conversation. So, the chat itself costs very little. The rule is simple. Whatever doesn’t fit on the card spills into your normal RAM, and the more that spills, the slower it gets. Setup is [music] two steps. First, grab llama.cpp. It’s the free engine underneath most local AI apps, and there’s a ready-made download for Windows and Linux. Second, download one model file. Which file depends on the recipe you pick. Recipe A is the two-bit file. NGL 99

[02:02] puts every layer on the graphics card. The result, 33 tokens a second using 7 and 1/2 of the 8 gigs and barely a gig and a half of normal RAM. The context is 8,000 tokens, which is plenty for chat and small coding jobs. Now, three of those flags are doing the heavy lifting and I’ll show you why in a minute. Recipe B is a three-bit file made by Research Lab [music] ISTA, built to stay smart at small sizes. It’s 10 gigs, so

[02:32] it doesn’t fit on the card. You don’t have to work out the split yourself. Fit on tells Llama CPP to put as much as it can on the card and the rest in RAM. It used 5 gigs of normal RAM, so a 16 gig PC is fine. Speed drops to 6 and 1/2 tokens a second, about reading speed, and you get double the context. Recipe C is the four-bit file, the one most guides tell you to get. Most of it lives in RAM, almost 11 gigs, so you want a 16 gig PC at minimum and 32 to be

[03:02] comfortable. Speed is three tokens a second, fine for jobs you start and walk away from. But is it smarter? That’s the real question. Speed means nothing if the answers are wrong. So I gave all three the same jobs. Write a function that passes 10 tests, three tries each, find a bug hidden in a 170-line file, and pull one code out of the first page of a long document. All three found the bug and all three found the code. On the coding test, the three-bit file scored 29 out of 30. The two-bit file,

[03:34] 27, and the big four-bit file, the one everyone recommends, scored 22. On one try, it wrote code that crashed on every input. So on an 8 gig card, bigger wasn’t smarter, it was just slower. Here’s the trap I actually hit. Run recipe A with the default settings and it crashes out of memory. Two reasons. By default, the server sets aside room for four conversations at once, NP1 makes it one. And by default,

[04:04] the chat memory is stored at 16-bit. CTK and CTVQ8 store it at 8-bit of the space. With those two changes, it fits with room to spare. You’ll also see people warn that going down to 4-bit chat memory makes the model quietly dumber. I tested that. Same prompt, same seed. Both versions got the right answers word for word on the bug hunt, and 4-bit saved a gig and a half of RAM. So, if you’re short on memory, it’s worth trying.

[04:34] Every command in this video, plus the right recipe for 12, 16, and 24 gig cards is in a free PDF. Comment 8 gig and I’ll send it to you. Running it in a terminal is nice. Putting it to work is better. Llama server gives you the same kind of web address Open AI does, but on your own machine. So, any AI tool that lets you change the address can use it. Here it is inside Open Code, a free coding agent. About a dozen lines of config. This little shop project has a failing test. I ask it to find the bug and fix

[05:05] it. It reads the code, spots that the discount check says greater than 10 when the rule says 10 or more, changes one character, and runs the tests again. All four pass. All of that on the 8 gig card. No graphics card at all. Two options. One, free cloud GPUs. Kaggle gives you a free 16 gig graphics card for hours every week. And the same recipe B file runs there through O Llama. Eight tokens a second, no setup.

[05:35] Two, if you have a Mac with 24 gigs, it runs on the chip’s built-in graphics. On my MacBook, it does 12.7 tokens a second with the internet blocked. >> [music] >> Five things that go wrong and the fix. Out of memory. Add NP1 and the Q8 chat memory flags or switch to fit on. Painfully slow. Too much is spilling to RAM. So, pick a smaller file or a shorter context. Thinks forever before answering. Set reasoning effort to low.

[06:06] Slow on a big server CPU. Tell it how many cores to use with T. And your browser uses graphics memory, too. So, close Chrome before you load it. Real talk. 90% of you watching haven’t subscribed. On Facebook, subscribe is the supporter button. That is what keeps the lights on here. On YouTube, it’s free and it tells the algorithm to send you more. Subscribe to support us. So, the short version. Want speed? Pick A. Want the best answers? Pick B, the

[06:37] three-bit file, which beat the big one. Skip the biggest file unless you have lots of RAM and patience. An 8 gig card is enough to run one of the best free models out right now. Comment 8 gig for the full recipe sheet and tell me your card and your speed. Follow along on Instagram and Facebook for bite-size AI and the deep dive playbooks live here on YouTube. Subscribe so you don’t miss one.