Quais modelos locais de IA um computador comum consegue executar?

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: What Local AI Models Can a Regular Computer Run? · Canal: Zero to MVP · 11:53 · Assistir no YouTube

Tópicos: 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 apresentador testa modelos locais de diferentes tamanhos em um mini PC GEEKOM A9 Max, usando Ollama e uma alocação de 24 GB de memória de vídeo. Ele compara a velocidade de geração de texto, observando também o uso da GPU, da memória e o ruído do sistema de refrigeração. Entre os modelos testados, Qwen 3.6, com 36 bilhões de parâmetros, chega a quase 38 tokens por segundo, enquanto Qwen 3.8, com 27 bilhões, alcança quase 14 tokens por segundo. Ao final, escolhe manter Qwen 3.8 e Gemma 4 de 26 bilhões de parâmetros, considerando desempenho e diversidade de famílias de modelos.

Pontos-chave

O mini PC GEEKOM A9 Max permite ajustar no BIOS a divisão da memória entre RAM do sistema e memória de vídeo.
O apresentador usa Ollama para executar os modelos e afirma que, nos testes realizados, a diferença de desempenho em relação a llama.cpp ficou dentro da margem de erro.
Os modelos foram testados com quantização Q4KM e parâmetros padrão; o foco da comparação foi a velocidade de geração de tokens.
Gemma 4 E2B tem 5 bilhões de parâmetros, mas apenas cerca de 2 bilhões são efetivos por etapa de geração.
Gemma 4 de 12 bilhões de parâmetros gera pouco mais de 10 tokens por segundo, enquanto GPT-4, de 20 bilhões, passa de 21 tokens por segundo.
Gemma 4 de 26 bilhões de parâmetros atinge quase 31 tokens por segundo; Qwen 3.6, de 36 bilhões, chega a quase 38.
Qwen 3.8, de 27 bilhões de parâmetros, executa no mini PC a quase 14 tokens por segundo, velocidade considerada aceitável pelo apresentador.
O apresentador decide manter Qwen 3.8 e Gemma 4 de 26 bilhões de parâmetros no computador.

Capítulos

Início	Capítulo	Resumo
00:00	Escolha do computador e configuração	O apresentador explica por que escolheu o mini PC GEEKOM A9 Max e descreve o ajuste da memória e a instalação das ferramentas.
02:04	Primeiros testes com Gemma 4	Os testes começam com Gemma 4 E2B e avançam para a versão de 12 bilhões de parâmetros, comparando velocidade e uso dos recursos.
05:40	Testes de GPT-4 e modelos maiores	O apresentador testa GPT-4 e Gemma 4 de 26 bilhões de parâmetros, destacando a velocidade de geração e o uso da GPU.
08:13	Qwen 3.6 e Qwen 3.8	Qwen 3.6 alcança o melhor resultado de velocidade, e Qwen 3.8 também executa no mini PC com desempenho considerado aceitável.
10:50	Conclusões e modelos escolhidos	O apresentador informa as condições dos testes e escolhe manter Qwen 3.8 e Gemma 4 de 26 bilhões de parâmetros.

Citações

No BIOS, você pode configurar como a memória é dividida entre a RAM do sistema e a memória de vídeo. — 01:02

Uma velocidade de mais de 46 tokens por segundo mostra que o hardware se sai muito bem com este modelo. — 03:05

Quase 38 tokens por segundo, contra 31 do Gemma. Eu não esperava que fosse mais rápido. — 08:44

A velocidade de geração ficou em quase 14 tokens por segundo. — 10:19

Meu objetivo era simplesmente entender quais modelos faz sentido usar em um computador moderno comum. — 11:21

Conceitos e entidades

GEEKOM A9 Max (ferramenta): Mini PC usado para testar a execução de modelos locais em um computador de formato compacto.
Ollama (ferramenta): Ferramenta usada no vídeo para baixar e executar modelos locais.
llama.cpp (repo): Biblioteca citada como alternativa de nível mais baixo para executar modelos locais.
vLLM (ferramenta): Ferramenta mencionada pelo apresentador como outra opção para executar modelos.
tmux (ferramenta): Utilitário usado para acessar sessões de terminal no mini PC.
btop (ferramenta): Utilitário open source usado para observar o uso de CPU, memória e GPU.
Gemma 4 E2B (modelo): Modelo da família Gemma 4 com 5 bilhões de parâmetros totais e cerca de 2 bilhões efetivos por etapa de geração, segundo o vídeo.
Gemma 4 (modelo): Família de modelos testada em versões de 12 bilhões e 26 bilhões de parâmetros.
GPT-4 (modelo): Modelo descrito no vídeo como tendo 20 bilhões de parâmetros e testado no mini PC.
Qwen3.6 (modelo): Modelo de 36 bilhões de parâmetros que alcança quase 38 tokens por segundo no teste.
Qwen3.8 (modelo): Modelo de 27 bilhões de parâmetros que o apresentador executa a quase 14 tokens por segundo.
Mixture of Experts (conceito): Arquitetura citada para explicar que os modelos usam apenas parte de seus parâmetros em cada etapa de geração.
Q4_K_M (conceito): Configuração de quantização usada em todos os modelos testados no vídeo.
Memória de vídeo (conceito): Memória configurada no BIOS e monitorada durante os testes para verificar se os modelos cabem no hardware.

Tradução completa (pt-BR)

00:00 Recentemente, falei sobre como executo e uso LLMs pequenos no meu Zima Cube. Além disso, de vez em quando, quando testo vários modelos locais maiores, uso meu computador de mesa, que tem uma placa de vídeo bastante potente e mais de 100 GB de RAM. No entanto, recentemente, fiquei curioso com uma pergunta interessante: que modelos você consegue executar em um computador comum? Em outras palavras, que modelos você consegue usar no tipo de computador que a maioria das pessoas tem em casa? Dito de outra forma, um computador que possa ser um trabalhador do dia a dia

00:30 confiável. Não vou entediar vocês com o longo processo de escolha. Vou apenas contar o que acabei escolhendo e por quê. Então, minha escolha foi o Mini PC A9 Max da GEEKOM. Em poucas palavras, eis por que o escolhi. Primeiro, eu não precisava de outro PC de tamanho normal. Já tenho um. Por isso, o formato compacto é importante para mim. Segundo, pelo que entendi, ele foi projetado pensando em modelos locais. Assim, tanto o processador quanto a placa de vídeo são potentes e bastante equilibrados. Ele também tem um sistema de resfriamento ativo muito robusto,

01:02 projetado especificamente para esse hardware. E, em terceiro lugar — e esse provavelmente foi o fator decisivo para mim —, na BIOS, você pode configurar como a memória será dividida entre a RAM do sistema e a memória de vídeo. Assim, terei mais controle sobre o tamanho do modelo que posso executar. A propósito, hoje vou usar esse mini PC no modo headless e me conectar a ele pela rede local. No entanto, por enquanto, vou deixá-lo na minha mesa, ao meu lado, para ver quanto ele esquenta sob cargas pesadas.

01:33 E, como sempre, vou usar SSH e tmux para me conectar a ele. Certo, provavelmente vou começar instalando tudo de que preciso. Primeiro, o Ollama, para executar modelos locais. E quero responder logo à pergunta de por que não usar llama.cpp ou algo parecido que funcione em um nível mais baixo. O motivo é simples. O Ollama usa internamente a mesma biblioteca llama.cpp e, ultimamente, eles otimizaram tudo tão bem que quase não há sobrecarga ao usar um

02:04 modelo llama. Fiz alguns testes sobre os quais vou publicar um vídeo separado em breve, e a diferença ficou dentro da margem de erro. Em outras palavras, praticamente não houve diferença. Então, para mim, não há muita vantagem em usar llama.cpp ou vllm. Certo, vou começar com modelos pequenos e, aos poucos, passar para modelos maiores. Assim, quero encontrar o ponto em que a qualidade das respostas seja a mais alta possível, enquanto a velocidade de resposta ainda seja aceitável. O primeiro modelo que vou usar é o Gemma 4, na sua

02:34 versão menor. A propósito, prestem atenção ao nome. É E2B, e muita gente acha que isso significa que ele tem 2 bilhões de parâmetros, mas não é bem assim. Ele tem 5 bilhões de parâmetros, enquanto os 2 bilhões no nome se referem ao número de parâmetros efetivos. São os parâmetros que participam dos cálculos em cada etapa de geração de token. Por causa dessa arquitetura, o modelo é executado mais rápido. Mas voltemos aos nossos testes. Estou baixando esse modelo e executando-o no

03:05 modo verbose, para que as métricas sejam exibidas no final. Para facilitar a avaliação da velocidade de resposta do modelo, vou usar um prompt que começa imediatamente a gerar um fluxo longo e contínuo de texto. Ele vai gerar um arquivo JSON simples com base na minha descrição, e não acho que essa tarefa deva ser difícil para o Gemma 4. Certo, como vocês podem ver, o modelo responde muito rápido, mas vamos dar uma olhada no número no final. Uma velocidade de mais de 46 tokens por segundo mostra que o hardware se sai muito

03:36 bem com esse modelo. Ótimo, isso significa que modelos pequenos não são um problema para o meu computador. Então, está na hora de passar para modelos maiores. Para o modelo de tamanho médio, também vou usar um da família Gemma 4, com 12 bilhões de parâmetros. Esse já é um modelo totalmente denso. Portanto, todos os 12 bilhões de parâmetros serão usados para gerar cada token. Vou manter o mesmo prompt que usei para o modelo menor porque, primeiro, é importante para mim entender o panorama geral. Depois, se necessário, vou me aprofundar nos detalhes. Certo,

04:08 enquanto o modelo está ocupado gerando a resposta, vamos dar uma olhada na carga que esse processo cria. Vou para a segunda aba no tmux e inicio o btop. É um utilitário gratuito e open source que, além das métricas habituais de uso de CPU e memória, também mostra a carga da GPU. Como vocês podem ver, a GPU está totalmente ocupada neste momento, enquanto a CPU não está. Isso é bom, porque significa que todo o trabalho está sendo feito na placa de vídeo, como deveria. Também fico feliz em ver que ainda há bastante memória de vídeo

04:39 disponível. Como vocês devem se lembrar, configurei 24 GB na BIOS. Então, quase dois terços ainda estão livres. Isso significa que posso continuar testando modelos maiores. O sistema de resfriamento também começou a funcionar com mais intensidade, e agora consigo ouvir um pouco a ventoinha. Isso é importante para mim porque, pelo menos por enquanto, pretendo deixar este computador na minha mesa. Pessoalmente, eu descreveria o nível de ruído como baixo. Quando estou sentado a cerca de um braço de distância, consigo ouvi-lo. Mas acho que, se estivesse do outro

05:09 lado do cômodo, provavelmente nem perceberia. Aqui, escutem como ele soa de mais perto. Certo, a geração terminou. Então, vamos ver os resultados. Desta vez, o número de tokens por segundo é significativamente menor do que com o modelo anterior: pouco mais de 10 tokens por segundo. Mas isso não é surpreendente, porque esse modelo não é apenas

05:40 maior, mas também tem uma arquitetura diferente. E todos os 12 bilhões de parâmetros são usados para gerar cada token, em vez de apenas uma parte deles, como no modelo anterior. Mas, ainda assim, a velocidade é perfeitamente boa e aceitável para mim. Então, não vou parar neste modelo e vou passar para o próximo. Certo, agora vamos sair da família Gemma, e vou testar um modelo da OpenAI com 20 bilhões de parâmetros. Este é o GPT-4, e acho que vocês provavelmente já o conhecem bastante. Estou

06:11 baixando-o, iniciando-o e tentando a mesma coisa. Mais uma vez, enquanto o modelo está ocupado gerando a resposta, vamos dar uma olhada no uso dos recursos. Sim, com este modelo também está tudo certo. A GPU está trabalhando, não a CPU. Isso é bom. E ainda há bastante memória disponível também. Ótimo. Certo, não vou mostrar todo o processo de geração porque é bem entediante, e vou direto aos resultados.

06:41 Ah, e os resultados são muito bons. A velocidade de geração é de mais de 21 tokens por segundo, o dobro da do modelo anterior. É um resultado muito impressionante para um modelo com 20 bilhões de parâmetros. Ótimo. Com certeza vou manter este modelo aqui e usá-lo. A propósito, se vocês gostam de experimentos como estes com modelos locais e querem apoiar o crescimento do canal, podem assinar meu Patreon. Também publico lá vídeos e materiais mais pessoais que normalmente não aparecem no canal principal. Vou deixar o link na

07:12 descrição. Certo, acho que está na hora de passar para modelos ainda maiores. Dessa categoria, vou testar mais dois modelos que já tiveram bons resultados para mim antes. São o Gemma 4, com 26 bilhões de parâmetros, e o Qwen 3.6, com 36 bilhões de parâmetros. Graças à arquitetura especial deles, de mistura de especialistas, esses dois modelos usam apenas cerca de três ou quatro bilhões de parâmetros para gerar cada token, em vez de todos. Isso

07:42 permite que sejam bastante rápidos e, ao mesmo tempo, produzam respostas de alta qualidade. Primeiro, vou testar o Gemma 4 com 26 bilhões de parâmetros. Tudo como de costume. Estou baixando o modelo e pedindo que gere o JSON. Já dá para perceber pela velocidade de resposta que ele funciona significativamente mais rápido do que o modelo anterior, mas isso não é surpreendente, já que apenas parte dos parâmetros é usada em cada etapa. Certo, e os resultados? Os resultados são muito bons: quase 31

08:13 tokens por segundo. Ótimo. É cerca de um terço mais rápido que o GPT-4, com seus 20 bilhões de parâmetros. Certo, agora está na hora do modelo Qwen 3.6, com 36 bilhões de parâmetros. Estou baixando-o e passando o mesmo prompt. Este modelo é bem grande e pesado, então vai ser interessante observar o uso dos recursos. Bem, aqui está quase tudo perfeito. O modelo cabe na memória de vídeo alocada para ele, assim como todos os modelos anteriores. A maior parte da carga

08:44 a GPU. Excelente. Agora, vamos ver os resultados. Ah, isso é ainda melhor do que o Gemma: quase 38 tokens por segundo, em comparação com 31 tokens com o Gemma. Eu nem esperava que fosse mais rápido. Achei que seria mais ou menos igual. Uma bela surpresa. A propósito, talvez você note aqui que o tempo total de geração da resposta do Qwen é quase duas vezes maior que o do Gemma. Isso pode parecer estranho, considerando a velocidade de geração mais alta, mas o motivo é que, depois de gerar o JSON necessário,

09:15 ele também decidiu fazer verificações adicionais para garantir que o arquivo estava correto, além de conferir se havia informações duplicadas entre os elementos do JSON. Por isso, o processo inteiro acabou levando tanto tempo. Certo, entendemos essa categoria de modelos. Os resultados são bons e, pelo uso de recursos, vejo que já estamos perto do limite, mas, para completar, ainda vou tentar executar mais um modelo pesado. E esse será o Qwen 3.8, lançado recentemente, com 27

09:47 bilhões de parâmetros. Ele acabou sendo um modelo muito bem-sucedido, e recentemente fiz um vídeo sobre minhas primeiras impressões a respeito dele. Não deixe de conferir se ainda não assistiu. O processo com esse modelo é o mesmo do anterior. Estou baixando o modelo, iniciando-o e enviando o mesmo prompt para gerar JSON. A primeira coisa que me deixa feliz é que o modelo realmente iniciou, e não é pequeno. Mas vamos conferir logo se havia memória de vídeo suficiente para ele. Vou mudar para a segunda aba, onde já estou com o Btop em execução, e dar uma olhada.

10:19 Certo, está tudo bem. Havia memória de vídeo suficiente. Ótimo. Agora é hora dos resultados finais. E os resultados são surpreendentemente bons. A velocidade de geração acabou sendo de quase 14 tokens por segundo. Claro, é mais lento do que com os modelos anteriores, mas ainda é aceitável para mim. Além disso, este já é a próxima geração de modelos Qwen, que são muito mais poderosos e avançados. Então, sim, estou

10:50 muito feliz com esse resultado. Isso significa que você não precisa de um desktop potente para executar o Qwen 3.8, e esse modelo é perfeitamente adequado para computadores modernos comuns. Certo, acho que já descobri o que queria saber, e está na hora de resumir. Mas, antes de passar às conclusões, também quero mencionar que todos os modelos usaram quantização Q4KM. Também os executei intencionalmente com os parâmetros padrão. Nesta etapa, meu objetivo não era extrair

11:21 o máximo de desempenho de um modelo específico, mas simplesmente entender qual conjunto de modelos faz sentido usar em um computador moderno comum. O fine-tuning será o próximo passo, e é exatamente por isso que, por enquanto, prestei atenção a apenas uma métrica dos resultados: a velocidade de geração de tokens. Então, com base no teste de hoje, vou manter dois modelos neste computador. O primeiro é o Qwen 3.8, que foi o claro vencedor de hoje. É uma nova geração de modelos, e a velocidade também é aceitável. Acho que, depois de algum

11:53 fine-tuning, a velocidade pode ser ainda maior. O segundo modelo é o Gemma 4 com 26 bilhões de parâmetros. Como ele pertence a outra família de modelos e sua velocidade também é significativamente maior, será um excelente complemento ao Qwen. Mais adiante, com certeza farei outro vídeo sobre como usar esse modelo junto com ele. 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. Cuide-se.

Transcrição original

[00:00] Recently, I talked about how I run and use small LLMs on my Zima Cube. Also, from time to time, when testing various larger local models, I use my desktop with a fairly powerful graphics card and more than 100 GB of RAM. However, recently, I became curious in one interesting question. What models can you run on a regular computer? In other words, what models can you use on the kind of computer that most people have at home? To put it another way, a computer that can be an everyday

[00:30] workhorse. I won’t bore you with the long process of choosing one. I’ll just tell you what I ended up with and why. So, my choice was the A9 Max Mini PC from GEEKOM. In a few words, here’s why I chose it. First, I didn’t need another full-size PC. I already have one. So, the small form factor is important for me. Second, as far as I understand, it was designed with local models in mind. So, the both the processor and the graphics are powerful and quite well-balanced. It also has a very solid

[01:02] active cooling system specifically designed for this hardware. And third, and this was probably the deciding factor for me, in the BIOS, you can configure how the memory is divided between system RAM and video memory. This way, I’ll have better control over the size of the model I can run. By the way, I’ll be using this mini PC in headless mode today and connect it to it over the local network. However, I keep it on my desk next to me for now to see how much it heats up under heavy loads.

[01:33] And as always, I’ll use SSH and tmux to connect to it. Okay, I’ll probably start by installing everything I need. First of all, that will be Ollama for running local models. And I want to immediately answer the questions of why not llama.cpp or something similar that works at a lower level. And the reason is simple. Ollama uses the same llama.cpp library internally and lately they have optimized everything so well that there is almost no overhead when using a

[02:04] llama. I run some tests which I’ll make a separate video about soon and the difference was within the margin of error. In other words, there is was practically no difference. So for me, there isn’t much benefit in using llama.cpp or vllm. Okay, I’ll start with small models and gradually move on to larger one. This way, I want to find the point where the quality of the answers is as high as possible while the response speed is still acceptable. The first model I use is Gemma 4, its

[02:34] smallest version. By the way, pay attention to the name. It’s E2B and many people think this means it has 2 billion parameters, but that’s actually not the case. It has 5 billion parameters while the 2 billions in the name refers to the number of effective parameters. These are the parameters that participate in the calculations at each token generation step. Because of this architecture, the model runs faster. But let’s get back to our testing. I’m downloading this model and running it in

[03:05] verbose mode so that the metrics are displayed at the end. To make it easy to evaluate the model response speed, I’ll use a prompt that immediately starts generating a long continuous stream of text. It will generate a simple JSON file based on my description and I don’t think this task should be difficult for Gemma 4. Okay, as you can see, the model responds very quickly, but let’s take a look at the number at the end. So a speed of more than 46 token per second shows that the hardware performs very

[03:36] well with this model. Great and this means that small models are not a problem for my computer. So it’s time to move on to larger ones. For the medium-size model, I also use one from the Gemma 4 family with 12 billion parameters. This is already a fully dense model. So, all 12 billion parameters will be used to generate each token. I’ll keep the prompt the same as for the smaller model because first, it’s important for me to understand the overall picture. And then, if necessary, I’ll dig deeper into the details. Okay,

[04:08] while the model is busy generating the response, let’s take a look at the load this process creates. I’m switching to the second tab in tmux and launching btop. It’s a free open-source utility that, in addition to the usual CPU and memory usage metrics, also shows GPU load. As you can see, the GPU is currently fully loaded while the CPU isn’t. That’s good because it means all of the work is happening on the graphics card as it should. I’m also happy to see that there is a lot of free video memory

[04:39] left. As you may remember, I set it to 24 GB in the BIOS. So, almost 2/3 of it is still free. And that means I can continue at testing larger models. The cooling system has also started working more actively, and I can hear the fan a little now. This is important to me because, at least for now, I plan to keep this computer on my desk. Personally, I would describe the noise level as quiet. When I’m sitting about an arm’s length away, I can hear it. But I think if it were sitting on the other

[05:09] side of the room, I probably wouldn’t notice it. Here, listen to how it sounds from closer range. Okay, generation is finished. So, let’s look at the results. This time, the number of tokens per second is significantly lower than with the previous model, just over 10 tokens per second. But that’s not surprising because of this model is not only

[05:40] larger, but also has a different architecture. And all 12 billion parameters are used to generate each token rather than only a portion of them, like with the previous model. But, nevertheless, the speed is perfectly fine and acceptable for me. So, I won’t stop at this model and will move on to the next one. Okay, let’s move away from the Gemma family now, and I’ll try a 20 billion parameter model from OpenAI. This is GPT-4 and I think you are probably quite familiar with it. I’m

[06:11] downloading it, launching it, and trying the same it generates. Again, while the model is busy generating the response, let’s take a look at the resource usage. Yes, everything looks good with this model as well. Uh the GPU is working, not the CPU. It’s good. And there’s still plenty of memory available, too. Great. Okay, I won’t show the entire generation process because it’s pretty boring, and I’ll jump straight to the results.

[06:41] Oh, and the results are quite good. The generation speed is more than 21 tokens per second, which is twice as fast as the previous model. That’s a very impressive result for a 20 billion parameter model. Great. I’ll definitely keep this model here and use it. By the way, if you enjoy experiments like these with local models and want to support the growth of the channel, you can subscribe to my Patreon. I also post more personal videos and materials there that usually don’t appear on the main channel. I’ll leave the link in the

[07:12] description. Okay, I think it’s time to move on to even larger models. From this category, I’ll try two more models that have performed well for me before. These are Gemma 4 with 26 billion parameters and Qwen 3.6 with 36 billion parameters. Thanks to their special architecture, mixture of experts, both of these models use only around three or four billion of their parameters when generating each token, rather than all of them. This

[07:42] allows them to be quite fast while still producing high-quality answers. First, I’ll try Gemma 4 with 26 billion parameters. Everything as usual. I’m downloading the model and asking it to generate the JSON. You can already tell from the response speed that it works significantly faster than the previous model, but that’s not surprising since only part of the parameters are used on each step. Okay, what about the results? And the results are very good, almost 31

[08:13] tokens per second. Great. It’s about third faster than GPT-4 with its 20 billion parameters. Okay, now it’s time for the Qwen 3.6 model with 36 billion parameters. I’m downloading it and giving it the same prompt. This model is quite large and heavy, so it will be interesting to look at the resource usage. Well, everything here is almost perfect. The model fits within the video memory allocation to it, just like all the previous models. Most of the load on

[08:44] the GPU. Excellent. Now, let’s look at the results. Oh, this is even better than Gemma, almost 38 tokens per second compared to 31 tokens with Gemma. I didn’t even expect it to be higher. I thought it would be about the same. A nice surprise. By the way, here you may notice that Qwen’s total response generation time is almost twice as long as Gemma’s. This may seem strange considering its higher generation speed, but the reason is that after Qwen generated the required JSON,

[09:15] it also decided to run additional checks to make sure the file was correct, as well as check whether any information was duplicated across the JSON elements. That’s why the whole process ended up taking so much time. Okay, we figured out this category of models. The results are good, and from the resource usage, I can see that this is already close to the limit, but for the sake of completeness, I’ll still try running one more heavyweight model. And that will be the recently released Qwen 3.8 with 27

[09:47] billion parameters. It turned out to be a very successful model, and I recently made a video about my first impression of it. Be sure to check it out if you haven’t seen it yet. The process with this model is the same as with the previous one. I am downloading the model, launching it, and sending the same prompt to generate JSON. The first thing I am happy about is that the model actually launched, and it’s not a small one. But let’s immediately check whether there was enough video memory for it. I am switching to the second tab, where I

[10:19] already have Btop running, and let’s take a look. Yes, everything is fine. There was enough video memory. Great. Now it’s time for the final results. So, the results, and they are unexpectedly good. The generation speed turned out to be almost 14 tokens per second. Of course, that’s slower than with the previous models, but it’s still acceptable for me. And on top of that, this is already the next generation of Qwen models, and they are much more powerful and advanced. So, yeah, I am

[10:50] really happy with this result. It means you don’t need a powerful desktop to run Qwen 3.8, and this model is perfectly suitable for regular modern computers. Okay, I think I have now figured out what I want to know, and it’s time to sum things up. But before moving on to the conclusions, I also want to mention that all the models used Q4KM quantization. I also intentionally run them with the default parameters. At this stage, my goal wasn’t to squeeze

[11:21] the maximum performance out of any particular model, but simply to understand which set of models makes sense to use on a regular modern computer. Fine-tuning will be the next step, and that’s exactly why for now I was paying attention to only one matrix in the results, namely token generation speed. So, based on today’s test, I’ll keep two models on this computer. The first is quant 3.8, which was the clear winner today. It’s a new generation of models, and the speed is also acceptable. I think that after some

[11:53] fine-tuning, the speed could be even higher. The second model is Gemma 4 with 26 billion parameters. Since it comes from a different model family, and its speed is also significantly higher, it will be an excellent complement to quant. Later, I’ll definitely make another video about using this model together. And that’s all for today. Don’t 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.