Niko Strata MUDOU O JOGO da IA local com o Qwen 3.8 Flash Next

Ver no idioma original →

Autoria: AI ProgBr · 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: Niko Strata MUDOU O JOGO da IA local com o Qwen 3.8 Flash Next · Canal: AI ProgBr · 15:43 · Assistir no YouTube

Tópicos: Agentes 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 Qwen 3.8 Flash Next em duas placas Intel Arc B770, comparando quantizações Q4 e Q2 e diferentes configurações de memória. Na versão Q4, o modelo usa as duas placas e alcança cerca de 60 tokens por segundo na geração, com resultados maiores em trechos de código. A versão Q2 pode rodar em uma placa, mas usar duas placas melhora a velocidade de processamento do prompt e a geração de código. O apresentador destaca que os resultados dependem do software e da configuração e propõe comparar o modelo com o Qwen 3 27B em um vídeo futuro.

Pontos-chave

• O teste usa duas Intel Arc B770 com 16 GB de VRAM cada e 32 GB de RAM no sistema.
• A versão Q4 do modelo carrega um context window de 262 mil tokens e alcança cerca de 60 tokens por segundo em geração geral.
• A velocidade de geração varia conforme o conteúdo: trechos de código podem ser gerados mais rapidamente do que texto de raciocínio.
• O MTP pode acelerar a geração quando os tokens propostos têm maior chance de serem aceitos, como em código mais previsível.
• O cache permite reutilizar o processamento de um prompt repetido quase instantaneamente.
• A versão IQ2XS cabe em uma placa, liberando a outra para outro modelo ou modalidade, mas a quantização reduz a precisão e pode afetar a qualidade.
• Com a versão Q2 nas duas placas, o teste chegou a mais de 2.000 tokens por segundo no processamento do prompt e a cerca de 85 tokens por segundo em uma geração de código.
• O apresentador considera comparar o Qwen 3 8B Flash e o Qwen 3 27B em diferentes quantizações e configurações.

Capítulos

Início	Capítulo	Resumo
00:00	Configuração do teste e desempenho inicial	O apresentador descreve o hardware e testa a versão Q4 do modelo, que carrega o contexto completo e gera cerca de 60 tokens por segundo.
03:40	Velocidade em prompts longos e geração de código	Os testes mostram processamento rápido de prompts extensos e geração de código mais veloz, com a possível contribuição do MTP.
07:51	Cache e quantização Q2 em uma placa	O apresentador demonstra a reutilização do cache e testa a versão IQ2XS em uma placa, observando o consumo de memória e o desempenho.
12:35	Q2 em duas placas e comparação de desempenho	A configuração Q2 com duas placas melhora o processamento do prompt e a velocidade em código, mas o apresentador pondera a escolha diante do Qwen 3 27B.
14:41	Resultados e próximos testes	O apresentador resume os testes e propõe comparar o Qwen 3 8B Flash com o Qwen 3 27B em diferentes quantizações.

Citações

Tivemos uma média de 60 tokens por segundo, o que não é nada mau, mas poderia ser melhor. — 02:07

Não deu nem tempo de piscar; foi instantâneo. — 09:25

1073 tokens por segundo para processar 111 mil tokens. — 11:33

Usando as duas placas com a versão Q2, estamos passando de 2.000 tokens por segundo no processamento do prompt. — 14:41

Conceitos e entidades

• Qwen3.8 Flash Next (modelo): Modelo avaliado no vídeo em diferentes quantizações e configurações de placas.
• Unsloth (empresa): Origem da versão Q4 do modelo usada no teste.
• Intel Arc B770 (ferramenta): Placa gráfica com 16 GB de VRAM usada em dupla nos testes.
• MTP (conceito): Técnica descrita no vídeo como capaz de propor vários tokens de uma vez, acelerando a geração quando eles são aceitos.
• cache (conceito): Recurso que permite reutilizar o processamento de um prompt já recebido.
• Hermes (ferramenta): Agent mencionado pelo apresentador como configurado para usar o modelo testado.
• Three.js (ferramenta): Biblioteca citada em uma solicitação para criar um jogo da cobrinha.
• Qwen3 27B (modelo): Modelo que o apresentador pretende comparar com o Qwen 3 8B Flash em um teste futuro.

Tradução completa (pt-BR)

00:00 Hoje vamos conferir o mais pedido, o mais aguardado: Nico Strata, rodando aqui na minha configuração com as duas Arc B770s. Esse mecanismo ficou muito famoso por rodar o Qwen 2.5 Flash Next em praticamente qualquer configuração, desde que você tenha uma placa de vídeo com 16 GB, embora algumas pessoas até estejam rodando com oito. E desde que você tenha memória de sistema suficiente, a memória do computador, a RAM. Basicamente, ele usa sua placa de vídeo apenas para os especialistas principais e usa o restante da memória para o

00:31 restante. Vamos para a tela para conferir tudo o que conseguimos fazer até agora. Já deixei tudo configurado e carregado, então vamos lá. Qual modelo estamos rodando? Estamos rodando o Qwen 2.5 Flash Next da Unsloth com quantização de 4 bits. É o modelo menor deles, de 4 bits, e conseguimos carregá-lo por completo aqui. Para isso, estou usando as duas ARC B770s. Cada uma dessas ARC B770s tem 16 GB de VRAM. Então, são 32 GB no total. Podemos ver aqui que há 22.321 especialistas nas placas, certo?

01:03 Então, está ocupando 50 GB ali, e o restante está na RAM. Estamos usando cerca de 45% da memória deste sistema aqui. Neste caso, nosso PC tem 32 GB; em breve terá 64 GB, mas, por enquanto, só temos 32. Mesmo assim, consegui carregar todo o contexto deste modelo. Este modelo tem uma context window de 262.000 tokens, e conseguimos carregá-la inteira. E o processador desta máquina que estamos usando é um AMD com 16 núcleos. Mas vamos ao que interessa; vamos falar de velocidade. Vamos começar com uma pergunta simples

01:34 ou talvez não. O que devo levar em conta ao comprar hardware para rodar LLMs localmente? Vamos apertar Enter aqui. E, aqui em cima, vamos ver a velocidade que estamos alcançando. Estamos chegando a cerca de 50 tokens por segundo, em média. No final, teremos uma ideia mais clara disso. Podemos ver aqui, conferir o uso da CPU. Nossa CPU também está trabalhando. Então, a CPU também vai ter um papel nesta geração, porque não estamos usando apenas as placas. Neste caso, com o Nico Strata, olha, está terminando a geração. Podemos ver que nossa placa nem sequer está perto do limite de potência. Então

02:07 as duas placas não estão trabalhando na capacidade máxima. E terminou bem aqui. Podemos ver um resumo aqui no monitor. E olha, tivemos uma média de 60 tokens por segundo, o que não é nada mal, mas poderia ser melhor. Algumas pessoas assistindo a este vídeo hoje provavelmente conseguem rodá-lo mais rápido com hardware menos potente. E eu também fiquei um pouco surpreso. Acredito que o motivo seja o seguinte. Quando um novo mecanismo é lançado, normalmente ele é desenvolvido e testado em placas NVIDIA com CUDA, e logo depois a comunidade

02:38 começa a fazer adaptações para AMD, Intel etc. Como estamos rodando uma configuração com duas placas Intel, há uma contrapartida. Como eu disse, as placas não estavam funcionando na potência máxima. Então, provavelmente há espaço para extrair um pouco mais de potência, um pouco mais de desempenho, mas, para isso, precisamos trabalhar no software. No meu último vídeo, por exemplo, mostrei que ajustei o software para rodar o Qwen 3.827 B em duas placas no formato EXL. Então, provavelmente seria possível fazer ajustes neste caso também.

03:10 Não tenho certeza se vou fazer isso, porque normalmente, quando rodo este modelo, rodo no meu Mac e, no Mac, tenho conseguido de 90 a 100 tokens por segundo, às vezes um pouco mais. Agora, há uma coisa que talvez me faça mudar de ideia: o perfil. Se olharmos aqui, conseguimos 47 tokens por segundo. Mas um ponto importante sobre a criação de perfil é que, se você enviar apenas uma frase, um texto curto ou um parágrafo — algo bem breve —, provavelmente o resultado será baixo. Para ver o perfil real,

03:40 precisamos de um texto mais longo. E é isso que vou fornecer agora. Vou começar uma nova conversa aqui, veja. Vou pedir para ele resumir um parágrafo e colar meu texto aqui. E assim vamos conseguir ver melhor. Posso ir até o monitor porque podemos vê-lo lendo o prompt bem aqui. Ele já está lendo a 900 tokens por segundo, mais ou menos o que o Mac faz. Aumentou um pouco, depois mais um pouco; agora já está mais rápido que meu Mac, pelo menos mais rápido que o M3 Ultra. 100 tokens por segundo. Ainda não consegui chegar a isso no

04:11 Mac M3 Ultra, mas não está tão longe. Neste caso, acho que prefiro os 900 a 1.000 tokens por segundo do Mac, já que ele tem uma taxa de geração de tokens muito maior. Neste caso, ele chega a 90, o que daria 50% mais tokens por segundo na geração. E, neste caso, acho que valeria a pena esperar um pouco mais para ele ler o prompt, mas ele responderia muito mais rápido. Mas, mais uma vez, em teoria, com duas ARC B70s eu teria 1.200 GB/s de

04:42 largura de banda. Cada uma tem cerca de 600 GB/s, então as duas juntas teriam um limite de 1.200. Não chegaríamos a 1.200, mas, comparando com o Mac, que tem 800 GB/s, talvez conseguíssemos chegar perto. Então, provavelmente é possível extrair mais desempenho desta configuração. Olha, agora começou a gerar tokens por segundo, certo? E provavelmente, como o contexto está um pouco mais completo agora, ficaremos um pouco abaixo de 60. Algo em torno de 50, 55. Acho que já terminou. Ficamos com 49. Ele fez apenas um parágrafo curto aqui.

05:13 Agora vou pedir para ele fazer o seguinte: criar um site com base neste livro. Normalmente, quando esses modelos novos estão criando algo com código, que é um pouco mais previsível, eles também são um pouco mais rápidos. Então, olha, estamos em torno de 40 tokens por segundo. Vamos ver se, quando começar a escrever o código, vai acelerar. Olha. Agora que está na parte do código, já podemos ver números mais altos, às vezes chegando a 65, 70 tokens por segundo. Olha, nesta parte aqui, quando está listando, chegou a 80

05:45 tokens por segundo, certo? Quando as coisas são mais previsíveis assim, ele acerta com mais frequência. Isso também tem a ver com MTP, certo? O MTP é uma camada que gera vários tokens de uma vez, e o modelo maior simplesmente os aceita ou não. Então, quando há menos variação, existe uma chance maior de serem aceitos. Você consegue aceitar mais tokens por passagem, certo? Assim, a velocidade também aumenta. Olha, ele está escrevendo o código para nós. Agora estamos vendo uma média de 70 tokens por segundo, mais ou menos. Então, neste caso, chegou até a 95, e aí começo a mudar de opinião,

06:16 certo? Se eu conseguir algo em torno de 80, 90 para código, chegou a 100 tokens por segundo ali, e consigo 1.000, 1.300 tokens por segundo no perfil, então talvez tenhamos aqui uma excelente opção, até melhor que o Mac, certo? Especialmente se considerarmos o custo hoje. Um Mac com 256 GB… Não sei se ainda dá para comprar o M3, mas, para dar uma ideia, o M5 custa cerca de 15.000 dólares canadenses, certo? O M3 Ultra custaria

06:49 bastante. Então, se você encontrasse um por 12 ou 10 mil dólares canadenses, seria uma pechincha. O preço das duas ARC B70s subiu muito, certo? Mas elas custam cerca de 4.000 dólares canadenses. Quando comprei, eram bem mais baratas; dava para comprar duas por menos de 3.000. Nossa, acabei de perceber que peguei um livro completamente aleatório. Não fazia ideia do que estava colocando aqui, mas tudo bem. Olha, nesta parte em que está fazendo, Jason, a velocidade sobe bastante, olha. Quando está escrevendo texto, cai um pouco, olha. Nesta

07:21 parte, que é mais código, código, código, às vezes chega a 100 tokens por segundo. Olha, 70. Agora caiu de novo, certo? Porque voltou a escrever texto. Terminou. Olha, 25.000 tokens, com uma média de 66 tokens por segundo. Mas a parte do raciocínio, que tinha pouquíssimo código, realmente derrubou essa velocidade. Se estivéssemos falando de 100% código aqui, teríamos uma velocidade muito melhor, certo? Então, no total, tivemos 25.000 tokens aqui, o que muda um pouco minha opinião. Então, se conseguirmos

07:51 obter uma média de 80 a 90 tokens por segundo para código, o que é um resultado excelente, especialmente considerando que estamos rodando uma versão Q4: 60 tokens por segundo. Na verdade, se fôssemos usá-lo para algo que não fosse código, para algo sem nenhuma relação com código, então 60 tokens por segundo também seria suficiente, certo? Não é tão ruim. Então, não sei, agora estou em dúvida. Não sei se, quando usar esse modelo, vou usá-lo mais nesta configuração ou mais no Mac. Outro teste que vou fazer é o seguinte. Vou pegar aquele prompt inicial que usamos. Vou criar um com o texto inteiro do livro, tudo certinho,

08:22 tudo idêntico. Vou criar um novo chat aqui e enviar, olha, exatamente o mesmo texto de novo, porque quero ver se ele vai reutilizar o cache e quanto tempo vai levar para processar o mesmo texto. Isso é muito importante porque, quando usamos um agente de código, temos aquela carga inicial, certo, que demora um pouco mais. Dependendo do seu agente de código, ele coloca muitos dados no system prompt para chamadas de skill e coisas assim. O OpenCode, dependendo do modelo do provedor, pode variar de 7.000 a 15.000 tokens. Quando falamos de

08:54 Cloud Code, por exemplo, às vezes o Cloud Code injeta 50.000 tokens. Tudo isso também serve de contexto para o modelo, para o bem ou para o mal, mas ocupa uma boa parte do context window. E normalmente você vai sentir isso mais durante a primeira carga, mas depois, a cada mensagem, só vai processar aquela mensagem específica. Se estiver lendo um arquivo do projeto, naquele momento ele só vai ler esse arquivo. Se o arquivo não for muito grande, você não vai sentir tanto o processamento desse prompt. E, depois que ele o leu, se precisar relê-lo, precisa reutilizar o cache. Aí é quase instantâneo. É isso que quero ver aqui, olha.

09:25 Se eu enviar este prompt, o resultado aqui tem que ser muito rápido, olha. Não deu nem tempo de piscar, foi instantâneo. Se olharmos aqui no monitor, veremos que o prefill token foi de 38 tokens por segundo, porque, basicamente, ele não processou nada, certo? Foi instantâneo, olha. Vou fazer de novo aqui para podermos ver, certo? Vou colar aqui e, olha, sem cortes, ele começa a responder instantaneamente porque reutiliza o cache. Entendeu? Mas há uma maneira de melhorarmos esse desempenho

09:56 quase como mágica, abrindo mão de um pouco de precisão e qualidade, isto é, passando para um modelo mais quantizado, com quantização Q2, por exemplo. E, na minha configuração, o Q2 terá uma vantagem, porque vou conseguir rodá-lo em uma única placa. E é isso que vamos fazer agora. Agora estamos rodando com o 3.8 Flash Next IQ2XS. Esta é uma versão mais quantizada, teoricamente também mais burra, mas terá a vantagem de caber em uma única placa. Usamos mais RAM, na verdade, está usando bem mais aqui,

10:28 certo? Mas, quando pensamos em uma máquina com 64 GB, talvez isso não seja um problema. A principal vantagem é que agora temos uma placa livre; poderíamos carregar outro modelo nessa placa. Poderíamos carregar um modelo de imagem, vídeo ou áudio, certo? Um gerador de música ou um gerador para várias outras modalidades. Também queremos ver agora se teremos algum ganho de velocidade ou não. Vai ser a mesma coisa. Vou começar aqui com um prompt simples. Conte uma história. E aqui já podemos ver que estamos a uma taxa de cerca de 40 tokens por segundo. Ou seja, 43 tokens por segundo. Próximo teste,

11:02 crie um jogo da cobrinha com Three.js. Aqui vamos ver se a velocidade melhora um pouco com código. Acho que pedir Three.js foi um erro, porque ele está pensando demais. Só faça o código, cara. Vou fazer o seguinte: vou parar, começar de novo e pedir apenas o jogo da cobrinha. Eu disse: ei, faça um jogo da cobrinha, não pense, só escreva o código. E agora ele está escrevendo o código para nós. Está mantendo uma boa taxa aqui, certo? Vamos ver a média no final, olha. Pensando pouco e gerando muito código, alcançamos uma média de 58 tokens por segundo. O próximo passo aqui será testar o resumo do nosso

11:33 livro. Resuma um parágrafo e vamos monitorar aqui; estamos chegando a cerca de 1.200 tokens por segundo, olha. Então, até 50.000 tokens, são aproximadamente 1.200 tokens por segundo. E vemos que, a cada passagem, a velocidade diminui um pouco. Vai terminar por volta de 1.000 a 1.100 tokens por segundo. Olha, está terminando o processamento, a uma taxa de cerca de 1.080 tokens por segundo, 1.073 tokens por segundo para processar 111.000 tokens. Um ponto importante aqui é o

12:05 seguinte. Para conseguir carregar todo o context de 262.000 tokens, estamos carregando menos experts na VRAM. Então, mesmo que seja uma quantidade menor, acabamos carregando menos experts aqui, e isso tem um custo de desempenho. Não há nada no meu chat aqui, e o modelo começou a responder. Acho que é o meu agent Hermes perguntando alguma coisa. Chegou uma mensagem aqui do Renato, e ele está configurado exatamente para usar este modelo. Renato é meu agent Hermes, certo? Para quem não sabe. Olha, tentei

12:35 diminuir nosso context window aqui, certo? Não conseguimos muito mais espaço na VRAM, está quase no limite, 24 GB. O consumo de RAM diminuiu um pouco, mas também não tivemos um grande ganho de velocidade. Então, para obter algum ganho de velocidade, vamos precisar usar as duas placas. Vamos testar rodando a versão Q2 nas duas placas. Olha, agora temos a versão Q2 aqui com 262.000 tokens carregados nas duas placas. E podemos ver que as duas placas já não estão perto do limite, certo? Há bastante espaço aqui. Nós

13:06 também estamos usando bem menos memória e temos 24.000 experts na VRAM. Vamos conferir a velocidade aqui. Basicamente, a velocidade é quase a mesma: 54 tokens por segundo. Deixe-me tentar com código aqui. Vou pedir para não pensar demais e ir direto para HTML. Foi direto para HTML. Agora sim, estamos obtendo uma excelente velocidade instantânea aqui. Vamos ver no final. Houve um problema aqui porque ele parou de gerar do nada, mas gerou 6.000 tokens a 85 tokens por segundo. Então, aqui tivemos um ganho real de velocidade. O problema é que estamos usando

13:37 duas placas aqui com uma versão Q2. Então, precisamos levar várias coisas em conta. Se você viu o outro vídeo que fiz sobre esta configuração, podemos rodar um Qwen 3.8 27B Q4 em uma placa ou a versão FP8 em duas placas. Então, se vou usar duas placas, é melhor rodar um Qwen 3.8 FP8 ou um Qwen 3.8 Flash Next Q2? Não sei, ainda não fiz esse teste, mas, em princípio, acho que escolheria o 27B. Vou pedir para ele continuar aqui, olha. Ele acha que terminou?

14:09 Na verdade, quase tinha terminado, certo? Mas esta versão não é muito boa. Só precisava fechar o, viu? Esta aqui é uma versão Q2. Só precisava fechar o script ali. Mas enfim, teoricamente funciona, certo? Pelo menos os cliques e coisas assim. Vamos ver se temos alguma melhora no processamento do prompt. Então, estamos conseguindo uma boa melhora no processamento do prompt, olha. Temos uma grande vantagem aqui: usando as duas placas com a versão Q2, estamos passando de

14:41 2.000 tokens por segundo no processamento do prompt. A placa está quase no limite aqui, olha, especialmente a primeira placa, mas essa velocidade é incrível, certo? Ótimo. Terminou aqui com uma velocidade de 55 tokens por segundo. Ao lado está um resumo do que vimos hoje. Começamos olhando a versão Q4, que precisa de duas placas para rodar. Depois vimos a versão Q2 rodando em apenas uma placa. Em seguida, a versão Q2 rodando em duas placas. E provavelmente daqui a um mês essas

15:11 os números já estarão todos desatualizados, porque, como eu disse, é uma questão de o campo continuar evoluindo. A grande questão é se vale a pena ou não. Na verdade, isso me deu uma ideia para um vídeo novo: Qwen 3 8B Flash versus Qwen 3 27B. Vamos rodar o Qwen 3 8B Flash em Q2 em uma placa, em Q4 em duas placas, e o Qwen 3 27B vamos rodar em Q4 em uma placa e em FP8 em duas placas. Aí podemos comparar a velocidade e a qualidade. E isso é bom porque também vou decidir como vou usar

15:43 essa minha configuração. Mas é isso. Se você gostou deste vídeo, deixe aquele like, isso ajuda muito. Se quiser ver os outros vídeos sobre essa configuração, vou deixar dois links bem aqui. Agora, se quiser dar uma olhada no meu curso, é só clicar bem aqui. Beleza? É isso. Vou ficando por aqui. Até o próximo vídeo.

Transcrição original

[00:00] Today we’re checking it out—the most requested, most awaited, Nico Strata, running here on my setup with the two Arc B770s. This engine became very famous for running Qwen 2.5 Flash Next on basically any setup, as long as you have a graphics card with 16GB, though some are even running it with eight. And provided you have enough system memory, the computer’s memory, the RAM. Basically, it uses your graphics card just for the main experts and uses the rest of the memory for the

[00:31] rest. Let’s go to the screen so we can check out everything we’ve managed to do here so far. I’ve already got everything configured and loaded, so let’s go. Which model are we running? We are running Qwen. 2.5 Flash Next from Unsloth with 4-bit quantization. It’s their smaller 4-bit model, and we managed to load it completely here. For this, I’m using the two ARC B770s. Each one of these ARC B770s has 16GB of VRAM. So the total is 32GB. We can see here that 22,321 experts are on the cards, okay?

[01:03] So, it’s occupying 50GB there and the rest is in the RAM. So, we’re using about 45%of this system’s memory here . In this case, our PC has 32GB, soon it will have 64GB, but for now, we only have 32. Even so, I managed to load the full context of this model. This model has a context window of 262,000 tokens, and we managed to load it all. And the processor on this machine we’re using is an AMD with 16 cores. But let’s get to what matters; let’s talk about speed. Let’s start here with a simple

[01:34] question, or maybe not. What should I look for when buying hardware to run LLMs locally? Let’s hit enter here. And up here, we’ll see the speed we’re achieving. We’re getting around 50 tokens per second on average. At the end, we’ll have a clearer view of that. We can see here, check the CPU load. Our CPU is working as well. So the CPU will also play a role in this generation because we aren’t just using the cards. In this case with Nico Strata, look, it’s finishing up the generation. We can see that our card isn’t even close to its power limit. So

[02:07] , the two cards aren’t working at their maximum capacity. And it finished right here. We can see a summary right here on the monitor. And look, we averaged 60 tokens per second, which isn’t bad at all, but it could be better. Some people watching this video today can probably run it faster with less powerful hardware. And I was a little surprised, too. I believe the reason for this is as follows. When a new engine comes out, it’s usually built and tested on NVIDIA cards with CUDA, and soon after, the community

[02:38] starts making adaptations for AMD, Intel, etc. Since we’re running a setup with two Intel cards, that’s a trade-off. Like I said, the cards weren’t running at their maximum power. So, there’s likely room to extract a bit more power, a bit more performance, but for that, we need to work on the software. In my last video here, for instance, I showed that I tweaked the software to run the Qwen 3.827 B on two cards in EXL format. So, it would

[03:10] probably be possible to tweak it in this case as well. I’m not sure if I’ll do that, because usually when I run this model, I run it on my Mac, and on the Mac, I’ve been getting 90 to 100 tokens per second, sometimes a bit more . Now, there is one thing that might change my mind, and that’s the profile. If we look here, we got 47 tokens per second. But an important thing about profiling is that if you send just a sentence, a short text, or a paragraph —something very brief—it will likely be low. To see the real profile,

[03:40] we need a larger body of text. And that’s what I’m going to provide it with now. I’ll start a new chat here, watch. I’ll tell it to summarize a paragraph and paste my text here. And here we’ll be able to see it better. I can go over to the monitor because we can see it reading the prompt right here. So it’s already reading at 900 tokens per second, which is about what the Mac does. It increased a bit, then a bit more; now it’s already higher than my Mac, at least higher than the M3 Ultra. 100 tokens per second. I haven’t been able to reach that on the

[04:11] Mac M3 Ultra yet, but it’s not that far off. In this case, I think I prefer the 900 to 1000 tokens per second of the Mac, since it has a much higher token generation rate. In this case, it does 90, which would give 50%more tokens per second in generation. And in this case, I think it would be worth waiting a little longer for it to read the prompt , but it would respond much faster. But once again, in theory, with two ARC B70s I would have 1200 GB/s of

[04:42] bandwidth there. Each one has around 600 GB/s, so the two together would have a ceiling of 1200. We wouldn’t get 1200, but comparing it to the Mac which has 800 GB/s, maybe we could get something close. So, it’s probably possible to extract more performance from this setup. Look, now it has started generating tokens per second, right? And probably, since the context is a bit fuller now, we’ll have a little less than 60. It will be around 50, 55. I think it’s already done. We ended up with 49. It only made a small

[05:13] paragraph here. Now I’m going to ask it to do the following: create a website based on this book. Usually, these new models, when they are creating something with code that is a bit more predictable, they are also a bit faster . So here, look, we are around 40 tokens per second. Let’s see if when it starts writing the code, it will speed this up, look. Look, now that it’s in the code part, we can already see higher numbers there, sometimes hitting 65, 70 tokens per second. Look, in this part here where it’s listing, it hit 80

[05:45] tokens per second, right? When things are more predictable like this, it gets it right more often. This has to do with MTP too, right? The MTP is a layer that generates several tokens at once and the larger model just accepts them or not. So when you have something that has less variation, there’s a higher chance of being accepted. You manage to accept more tokens per pass, right? So you end up increasing the speed as well . Look, here it is writing the code for us. We are now seeing an average of 70 tokens per second, more or less. So, in this case, it even hit 95 there, and then I start to change my opinion,

[06:16] right? If I can get around 80, 90 for code, it hit 100 tokens per second there and I can get 100, 1300 tokens per second of profile, then maybe here we have an excellent option, even better than the Mac, right? especially if we consider the cost today. A Mac with 256 GB, I don’t know if you can even buy the M3 anymore, but to give you an idea, the M5 costs around 15,000 Canadian, right? The M3 Ultra would be

[06:49] quite a lot. So if you could find it for 12, or 10,000 Canadian, it would be a steal. The two ARC B70s have gone up a lot in price, okay? But they cost around $ 4,000 Canadian. When I bought them it was much cheaper, you could get two for less than 3,000. Wow, I just noticed, I picked up a completely random book. I had no idea what I was putting here, but that’s fine. Look, in this part he’s doing, Jason, the speed goes quite high there, look. When he’s writing text, it drops a bit, look. In

[07:21] this part, which is more code, code, code. It’s hitting 100 tokens per second at times. Look, 70. Now it’s back, right? Because it’s writing text again. Finished. Look, 25,000 tokens at an average of 66 tokens per second. But the thought process part, which had very little code, really dragged down that speed. If it were 100%code that we were talking about here, we would get a much better speed, okay? So, in total we had 25,000 tokens here, which changes my view a bit. So, if we can

[07:51] get an average for code of 80 to 90 tokens per second, that’s an excellent result, especially considering we’re running a Q4 version, 60 tokens per second. Actually, if we were using it for non-code, for something that has nothing to do with code, then 60 tokens per second is also enough, right? It’s not that bad. So, I don’t know, now I’m in doubt, I don’t know if when I use this model I’ll use it more on this setup or more on the Mac. Another test I’m going to do is the following. I’m going to take that initial prompt we gave. I’ll create it with the entire book text, everything correct,

[08:22] everything identical. I’ll create a new chat here and send it, look, exactly the same text again, because I want to see if it will reuse the cache and how long it will take to process the same text. This is very important because when we’re using a code agent, we have that initial load, right, which will take a little longer. Depending on your code agent, it puts a lot of data into the system prompt for skill calls and so on. Open code, depending on the provider’s model, can range from 7,000 to 15,000 tokens. When we talk about

[08:54] cloud code, for example, cloud code sometimes injects 50,000 tokens. All of this will also serve as context for the model, for better or worse, but it takes up a good chunk of the context window. And you’ll usually feel it most during the first load, but afterward, with each message, you’ll only process that specific message. If you are reading a project file, at that moment it will only read that file. If the file isn’t that large, you won’t feel that prompt processing as much. And once it has read it, if you have to reread it, it needs to reuse the cache. And then it’s almost instantaneous. That’s what I want to see here, look.

[09:25] If I send this prompt, the result here has to be very fast, look. There wasn’t even time to blink, so it was instantaneous. If we look here at the monitor, we’ll see that the prefill token here was 38 tokens per second, because basically it didn’t process anything, right? It was instantaneous there, look. I’ll do it again here so we can see, okay? I’ll paste it here and, look, no cuts at all, it starts responding instantly because it reuses the cache. Got it? But there is a way for us to improve this performance

[09:56] almost like magic, meaning, by giving up a little bit of precision and quality, that is, by moving to a more quantized model, to a Q2 quantization, for example. And in my setup, Q2 will have an advantage, because I’ll be able to run it on a single card. And that is what we are going to do now. Now we are running with the 3.8 Flash Next IQ2XS. This one is a more quantized version, theoretically dumber as well, but it will have the advantage of fitting on a single card. We use more RAM, it’s actually using quite a bit more here,

[10:28] right? But when we look at a 64 GB machine, perhaps this isn’t a problem. The main advantage is that now we have a free card; we could load another model onto this card. We could load an image, video, or audio model, right? A music generator, or a generator for various other modalities. What we want to see now, too, is whether we will have any speed gain or not. It’s going to be the same thing. I’ll start here with a simple prompt. Tell me a story. And here we can already see that we are at a rate of about 40 tokens per second . So 43 tokens per second. Next test,

[11:02] create a snake game with Three.js. Here we’ll see if the speed gets a little better with code. I think asking for Three.js was a mistake here because it’s thinking too much. Just do the code, man. I’ll do the following: I’ll stop, start again, and just ask for the snake game. I told it, hey, make a snake game, don’t think, just write the code. And there it’s writing the code for us now. It’s getting a good rate here, right? Let’s see the average at the end, look. With little thinking and a lot of code, we achieved an average of 58 tokens per second. The next step here will be to test the summary of our

[11:33] book. Summarize a paragraph, and here we will monitor it, and we are getting around 1200 tokens per second, look. So , up to 50,000 tokens, it’s roughly 1200 tokens per second. And we see that with each pass here, it slows down a little bit. It will finish around 1000 to 1100 tokens per second. Look here, it’s finishing processing, at a rate of about 1080 tokens per second, 1073 tokens per second to process 111,000 tokens. An important thing here is the

[12:05] following. To be able to load the full context of 262,000 tokens, we are loading fewer experts in the VRAM. So, even if it’s a smaller amount, we end up loading fewer experts here, and this has a performance cost. There’s nothing in my chat here and the model started responding. I think it’s my Hermes agent asking something. A message arrived here from Renato, and he is exactly configured to use this model. Renato is my Hermes agent, okay? For those who don’t know. Look, I tried to

[12:35] decrease our context window here, okay? We didn’t get much more VRAM space, it’s almost at the max, 24 GB, it lowered the RAM consumption a little bit, but we didn’t get a big speed gain either. So, for us to get any speed gain, we’ll have to use both cards. Let’s test running both cards, the Q2 version. Look, now we have the Q2 version here with 262,000 tokens loaded on both cards. And we can see that the two cards are no longer near the limit, okay? There is plenty of space here. We

[13:06] are also using much less memory and have 24,000 experts on the VR. Let’s check the speed here. Basically, the speed is almost the same, 54 tokens per second. Let me try with code here. I’ll ask it not to overthink and go straight to HTML. It went straight to HTML. Now, yes, we are getting excellent instantaneous speed here. Let’s see at the end. There was a problem here because it stopped generating out of nowhere, but it generated 6,000 tokens at 85 tokens per second. So here we had a real gain in speed. The problem is that we are using

[13:37] two cards here with a Q2 version. And so we need to consider several things. If you saw the other video I made about this setup, we can run a Qwen 3.8 27B Q4 on one card or the FP8 version on two cards. So, if I’m going to use two cards, is it better for me to run a Qwen 3.8 FP8 or is it better to run a Qwen 3.8 Flash Next Q2? I don’t know, I haven’t done that test yet, but in principle I think I would go with the 27B. Let me ask it to continue here, look. Does it think it finished?

[14:09] Actually, it had almost finished, right ? This version isn’t very good, though. It just needed to close the, see? This one here is a Q2 version. It just needed to close the script there. But well, theoretically it works, right? At least the clicks and such. Let’s see if we have any prompt processing improvement here. So, we are achieving here, look, a good improvement in prompt processing. We have a big advantage here; using both cards with the Q2 version, we are getting over

[14:41] 2,000 tokens per second of prompt processing. The card is almost at its limit here, look. especially the first card here, but this speed here is incredible, okay? Awesome. It finished here with a speed of 55 tokens per second. On the side is a summary of what we saw here today. We started by looking at the Q4 version, which needs two cards to run. Then we saw the Q2 version running on just one card. Then the Q2 version running on two cards. And probably a month from now these

[15:11] numbers will all be outdated, because as I said, it’s a matter of the field evolving here. The big question is whether it’s worth it or not. Actually, this gives me an idea for a new video: Qwen 3 8B Flash versus Qwen 3 27B. We’ll run Qwen 3 8B Flash in Q2 on one card, Q4 on two cards, and Qwen 3 27B we run in Q4 on one card, and FP8 on two cards. Then we can check the speed and the quality. And it’s good because I’ll also decide how I’m going to use

[15:43] this setup of mine. But that’s it. If you liked this video, leave that hype, it helps a lot. If you want to see the other videos of this setup, I’ll leave two links right here. Now, if you want to take a look at my course, just click right here. Alright? That’s it. I’ll leave it here, see you in the next video.