O Swift Qwen3.8 27B realmente pensa menos? Comparação com o original

Autoria: Fahd Mirza · 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: Does Swift Qwen3.8 27B Really Think Less? Comparison with Original · Canal: Fahd Mirza · 14:03 · Assistir no YouTube

Tópicos: Avaliação e benchmarks de IA, Modelos de IA, Modelos locais e open source

Resumo

O vídeo compara o Swift Qwen3.8 27B com o modelo original em uma tarefa de geração de um arquivo HTML interativo que simula o preparo de um latte. O Swift concluiu a tarefa mais rápido, mas gerou mais tokens de saída e fez mais tool calls; na primeira tentativa, sua simulação também pareceu travar. Já o original levou mais tempo, mas produziu uma simulação que completou todas as etapas. O apresentador conclui que a vantagem do Swift não é necessariamente pensar menos e recomenda o modelo original como opção geral.

Pontos-chave

O Swift é um fine-tune do Qwen3.8 27B, ajustado para penalizar tokens associados ao excesso de raciocínio.
O teste usou o mesmo prompt nos dois modelos para gerar uma simulação de preparo de latte em HTML.
Na primeira execução do Swift, a simulação pareceu travar na etapa de espumar o leite.
O apresentador refez a execução do modelo original em um diretório limpo, após perceber que ele havia reutilizado um arquivo anterior.
O Swift terminou em 35 minutos e 52 segundos, enquanto o original levou 47 minutos e 7 segundos.
O Swift gerou 60.572 tokens de saída e fez 21 tool calls; o original gerou 11.744 tokens de saída e fez 4 tool calls.
A simulação gerada pelo original completou todas as etapas do preparo do latte.
O apresentador considera que o Swift pode desperdiçar menos tokens em alguns casos, mas recomenda o modelo original no geral.

Capítulos

Início	Capítulo	Resumo
00:01	Apresentação do Swift Qwen3.8 27B	O apresentador introduz a reclamação de que o modelo original demora para responder e explica como vai testar a variante Swift.
01:37	Como o Swift foi ajustado e qual será o teste	O vídeo descreve o ajuste do modelo e apresenta o desafio de gerar uma simulação interativa de preparo de latte em HTML.
04:12	Primeiro resultado do Swift e execução do original	O apresentador mostra a simulação do Swift, que parece travar, e inicia o teste do modelo original com o mesmo prompt.
06:46	Benchmarks e nova execução controlada	O apresentador comenta os benchmarks divulgados e refaz o teste do original em um diretório limpo para evitar reutilização de arquivos.
09:54	Resultado do original e comparação das métricas	A simulação do original completa as etapas, e o apresentador compara tempo, tokens de saída e tool calls dos dois modelos.

Citações

Mesmo cérebro, monólogo interno mais curto. — 01:37

A questão é se essa velocidade custa algo numa tarefa desse tipo. — 08:20

O Swift fez mais trabalho em menos tempo. — 12:30

Escolha o Qwen original. Ele é muito, muito melhor. — 13:32

Conceitos e entidades

Qwen3.8 27B (modelo): Modelo comparado em sua versão original e na variante Swift.
Swift Qwen3.8 27B (modelo): Fine-tune do Qwen3.8 27B apresentado como uma versão que reduz o excesso de raciocínio.
Thinking Cap (modelo): Modelo citado como fonte de uma transferência de eficiência usada no Swift.
vLLM (ferramenta): Ferramenta usada pelo apresentador para servir os modelos localmente.
Hermes Agent (ferramenta): Agent usado para executar localmente os testes com os modelos.
Mass Compute (empresa): Serviço recomendado pelo apresentador para alugar uma GPU.
Fahd Mirza (pessoa): Apresentador do vídeo e responsável pelo teste comparativo.

Tradução completa (pt-BR)

00:01 Já falamos bastante sobre o Qwen 3.8 27B neste canal: o original, os fine-tunes, tudo. E uma das maiores reclamações sempre foi a mesma: esse modelo demora demais para responder. Hoje vamos testar algo completamente diferente: uma versão que afirma ter realmente resolvido isso. E não vamos apenas testá-la; também vamos medir o Swift Qwen 3.8 27B.

00:34 Este é Fahad Miraa, e dou as boas-vindas a você ao canal. Recentemente, também comecei esta newsletter semanal gratuita sobre IA, na qual você pode se inscrever em fahada.substat.com. O que vou fazer é usar o vLLM para servir este modelo. Como você pode ver, já estou fazendo isso neste sistema local com esta configuração. E já integrei tudo ao Hermes agent, que está rodando localmente. E esta é a quantidade de VRAM que ele está

01:05 consumindo. Tenho 80 GB de VRAM. Se você não tem isso, há duas opções: usar uma versão quantizada em GGUF ou, se quiser reproduzir o que estou fazendo, acessar o Mass Compute — o link está na descrição do vídeo — e alugar uma GPU por um preço bem acessível. Então, resolvido isso, primeiro vou explicar exatamente o que eles fizeram. Basta olhar este diagrama: ele mostra o quadro completo. Não é um modelo novo, como eu

01:37 mencionei antes: são os mesmos pesos do Qwen 3.8 27B. O que eles fizeram foi aplicar fine-tuning para penalizar os tokens que desencadeiam o excesso de raciocínio e incorporar uma transferência de eficiência de outro modelo chamado Thinking Cap, que, aliás, já abordamos no canal. O resultado final: o mesmo cérebro, um monólogo interno mais curto. Para o primeiro teste, vou propor esta tarefa: vou dar a ele um prompt difícil. Gere um arquivo HTML completo e independente

02:09 que simule o preparo de um latte no estilo de um barista. Não é um teste simples. Ele precisa lidar com uma lógica de estado em várias etapas: moer o café, compactá-lo, extrair o espresso com um temporizador, vaporizar o leite e despejá-lo. O que vamos verificar são duas coisas: ele é realmente mais rápido? E reduzir os tokens de raciocínio custa alguma capacidade de verdade? Ou ele ainda acerta a lógica? Então, vou voltar e abrir meu Hermes

02:40 e vou inserir o prompt que está diante de você. Espero que funcione. Este é o prompt completo que já mostrei. Enquanto isso, se quiser ajudar o canal, acesse a página inicial do canal ou o primeiro comentário fixado e torne-se membro. O modelo está pensando, e este é o teste de verdade: quanto tempo ele leva para pensar? Se quiser ver quanto tempo o original levou para pensar, basta acessar meu canal e procurar aquele vídeo; você vai se surpreender

03:11 com quanto tempo ele demora para pensar. Então, vamos esperar a resposta e analisar em tempo real se a afirmação é verdadeira ou não. Ou, melhor ainda, depois que este terminar, vou salvar o resultado e instalar também o Qwen original com a mesma configuração. Então, vamos executar o mesmo prompt e fazer uma comparação lado a lado. Por fim, o modelo gerou o arquivo

03:42 e, depois de verificá-lo bastante, sabe de uma coisa? Ele também pensou muito. Mas não dá para fazer uma comparação de verdade a menos que eu execute o outro modelo original. Então, antes disso, vou registrar estas estatísticas para compará-las mais tarde. Vou sair daqui. Esta é a minha sessão. Vou pegar algumas estatísticas e depois iniciar o outro modelo. E, se você está se perguntando como tenho

04:12 certeza dessas estatísticas, também estou executando o comando diretamente no banco de dados SQL, como você pode ver aqui. E ele me mostrou estes tokens de entrada e saída. Certo, agora vou servir o Qwen original. O Qwen original está sendo servido com os mesmos parâmetros. E esqueci de mostrar o arquivo HTML gerado pelo Swift. É este aqui. Vou abri-lo no navegador. Aí está. Esta é uma simulação. Como você pode ver, há 10 etapas. Vou também

04:43 aumentar um pouco o tamanho. Pronto. Acho que assim está melhor. Ele reproduz automaticamente toda a sequência de seis etapas. Pressione R ou clique em Redefinir para começar de novo. Enfim, esta é a etapa 1, depois 2 e 3. Está indo bem. E esta é a etapa 4. Que legal! Olha só. Nossa! Esta é a beleza de um Qwen com apenas 27 bilhões de parâmetros. Agora ele está formando uma microespuma sedosa.

05:14 Este é um arquivo HTML. Só isso. E ele ficou parado na etapa 4. Não avança, eu acho. Ou talvez ainda esteja congelado. E esta etapa? Latte malfeito e servido. Certo. Vou ver se R funciona. Vou pressionar R maiúsculo. Opa. Não aconteceu nada. Talvez seja porque estou na máquina virtual. Vou tentar daqui

05:44 também não funciona. Redefinir e executar de novo. Mas, mesmo assim, tudo isso é bem interessante. Vou pressionar Ctrl+F5 para redefinir tudo. Vamos tentar de novo. Aqui está acontecendo a compactação do café. Extraia o espresso. Está vendo? Até esta luz piscante da máquina acende, e a xícara vai enchendo. Isso é muito legal.

06:16 e desliga. Agora, veja a fumaça subindo e o leite espumando. A espuma está pronta. Microespuma sedosa. Vou esperar um pouco e ver como vai. Certo. Então, é aqui que ele está. Ele simplesmente fica travado aqui. Esperei bastante. Nada acontece, mesmo depois de pausá-lo um pouco. Certo, certo. Vamos voltar e executar isso com o Qwen

06:46 original. Este era o nosso Qwen original. Deixe-me mostrar o consumo de VRAM. É esta a quantidade que ele consome. E vamos abrir o Hermes agent, que já configurei. O mesmo prompt. Estou enviando para o modelo base, quer dizer, para o Qwen 3.8 27B original. Vamos ver como ele se sai. Depois vamos comparar os dois. Vou preparar um café. Enquanto o Qwen pensa bastante, deixe-me

07:19 mostrar algo interessante. Eles compartilharam alguns benchmarks de raciocínio geral, GPQA, MMLU e muitas outras avaliações. O Swift fica a um ponto do modelo base e, às vezes, até fica um pouco à frente, enquanto reduz os tokens de raciocínio em 40% a 50%. Foi isso que eles afirmaram, e vamos testar em breve, enquanto nossos testes estão em andamento. Mas vejam a matemática: problemas de matemática de competição da AIME 2026, com várias etapas.

07:49 É algo em que não dá para simplesmente pegar um atalho. O Qwen 3.8 base chega a 98,667%. O Swift fica em 94%. Uma queda de 4,6 pontos. E, entre tudo o que aparece nesta tabela, acho que essa é a maior diferença. O HMMT conta a mesma história: cai de 99,33 para 96%. Então, o padrão se mantém em todas as categorias, exceto naquela que

08:20 realmente exige raciocínio sustentado, etapa por etapa. Acho que é isso que estamos testando aqui. A questão não é se o Swift é mais rápido, porque claramente é. A questão é se essa velocidade tem algum custo em uma tarefa desse tipo, que exige que o modelo realmente pense até o fim. Vamos testar quanto tempo leva e quantos tokens exige. Então, vamos esperar que termine e depois seguimos. Acho que ele

08:50 já terminou, eu acho. Aí está. Já acabou, e estas são as estatísticas. Vou pegar também os dados do banco de dados. E aqui vai outro retrato honesto. Acabei de verificar a saída e o registro de raciocínio. Pelo que parece, o que este modelo original fez foi copiar o arquivo anterior, alterá-lo e depois gerá-lo novamente. Então, não achei que fosse uma comparação justa. Por isso, reiniciei o processo depois de

09:22 mover aquele arquivo original para outra pasta, porque ele não está no diretório de trabalho atual. Assim, todo o resto continua igual. Este é o novo diretório que criei. Simplesmente movi o arquivo para a pasta Downloads. Estou mostrando tudo com transparência para que estejamos todos na mesma página. Este é o meu diretório de trabalho atual. Agora, este modelo Qwen deve gerar este novo arquivo aqui. E vou esperar de novo o tempo que for necessário. Acho que vai levar cerca de uma hora. Depois, vamos testá-lo. Então

09:54 Vamos ver como isso vai. E é isso que envolve fazer esses vídeos: leva horas e horas e, como esses servidores são alugados, temos que pagar por todas essas horas e coisas do tipo. Então, é preciso muito esforço, tempo e dinheiro para fazer esses vídeos. Espero que um dia alguém aprecie isso. Vou esperar terminar e, depois, seguimos. Por fim, ele voltou depois de 45 minutos. E foi isso que ele

10:24 gerou. Então, vou copiar esse caminho e mostrar para vocês ao vivo. E prometo que eu mesmo ainda não conferi. Estou abrindo na frente de vocês. Aí está. Vou aumentar um pouco e depois vamos testar. Vamos começar. Primeiro passo: moer os grãos de café. Parece bom. Depois, compactar o pó — melhor ainda. Latte Pro. A propósito,

10:56 vocês veem que as luzes vermelhas estão acesas. Tirando o espresso. Terceiro passo. Há uma diferença marcante entre o outro e este. A saída e os gráficos. Enfim, ele ainda está extraindo. O café está pingando na xícara. Como podem ver, essas são as coisas que não… Enquanto a máquina está funcionando, a luz fica acesa. Aconteceu a mesma coisa com a outra. A luz estava verde. Esta está vermelha. Vou deixar rodar. Parou no passo quatro, eu acho. Agora, no passo quatro, ele está vaporizando e espumando o leite. Olhem,

11:28 podemos simplesmente ignorar esse tipo de coisa, mas isso está bom. Isto é HTML, não uma imagem, e nosso latte está pronto. Todos os passos foram concluídos e o sistema foi reiniciado para começar de novo. Então, o original foi do início ao fim. Não chegou a apresentar problemas. Depois do passo quatro, está concluído. Essa é uma diferença que podemos apontar. Quanto ao restante, vou sair desta sessão e pegar os dados do banco de dados

12:00 e este é o resultado do banco de dados, para ser justo. Esta é uma tabela que acabei de criar comparando os dois, que já mostrei a vocês. Se olharem para esta tabela, foi isso que realmente aconteceu, e não é bem o que vocês esperariam. O Swift gerou 60.572 tokens de saída a mais do que o Qwen original, que gerou 11.744, e fez mais chamadas de ferramentas: 21 contra 4.

12:30 Mas terminou mais rápido: 35 minutos e 52 segundos, contra 47 minutos e 7 segundos do Qwen original. Então, não é simplesmente que o Swift pensa menos nesta tarefa. O Swift fez mais trabalho em menos tempo. Já o Qwen original passou um tempo considerável duvidando das próprias decisões. Vocês viram na transcrição que ele ficou debatendo se deveria copiar um arquivo existente ou reescrever tudo do zero, antes de finalmente se decidir e fazer o trabalho direito na minha segunda tentativa. E eu tinha reiniciado o VLM e limpado tudo, para

13:02 que ele não armazenasse nada em cache nem fizesse qualquer outra coisa. Então, é algo que vocês precisam ter em mente. É um teste limpo e claro. E dá para ver que a afirmação realmente não se sustenta. Mas acho que a afirmação se sustenta — e concordo com isso — quando se diz que a verdadeira vantagem não é ter menos pensamentos. A verdadeira vantagem é desperdiçar menos tokens, e nisso eu concordo. Mas, se vocês olharem aqui, até mesmo em

13:32 termos do número de tokens — e estou falando do raciocínio, de como ele de fato chegou ao resultado —, no geral, eu diria que o Qwen original é muito melhor do que este Swift ou, sabe, qualquer fine-tune ou variação que vi até agora e que testamos no canal. E recebo muito esta pergunta: qual Qwen é melhor? Sabe de uma coisa? Fiquem com o Qwen original. Ele é muito, muito melhor. O restante ainda é

14:03 pesquisa. Há alguns resultados promissores, como no GSQRCO, da Áustria. Mas, além disso, acho que o Qwen original ainda se mantém, inclusive na versão quantizada. É isso. Digam o que acham. Obrigado por todo o

Transcrição original

[00:01] We have covered coin 3.8 27 billion a lot on this channel. The original, the finetunes, all of it. And one of the biggest complaints has always been the same. This model thinks way too long before it answers. Today we are testing something entirely different. A version that claims to have actually fixed that. And not only we are going to test it out, we are going to actually measure this swift coin 3.827

[00:34] billion. This is Fahad Miraa and I welcome you to the channel. Recently I also have started this free weekly AI newsletter which you can subscribe at fahada.substat.com. What I’m going to do, I’m going to use V LLM to serve this model. And you can see I am already doing that on this local system with this configuration. And I have already knitted it together with Hermes agent where it is running locally. And this is how much VRAM it is

[01:05] consuming. I have 80 GB VRAM. If you don’t have that, you have two options. either go with quantized GGF version or if you want to replicate what I’m doing just go to mass compute the link is in video description and rent a GPU on very affordable price. So that’s out of the way let me first talk through what exactly these guys have done just look at this diagram and this gives you the whole picture it is not a new model as I

[01:37] mentioned earlier same coin 3.827 27 billion weights underneath. What they did is fine-tune it to penalize the tokens that trigger overthinking and pulled in an efficiency transfer from another model called thinking cap, which we already have covered by the way on the channel. End result, same brain, shorter internal monologue. So for the first test, I’m going to do this goal. I am going to give it one hard prompt. Generate a complete self-contained HTML

[02:09] file simulating making a latte barista style. This isn’t a toy test. It needs multi-step state logic. Grinding, temping, pulling the shot with a timer, steaming milk, pouring. What we are checking here is two things. Is it actually faster? And does cutting the thinking tokens cost it any real capability? Or does it still get the logic right? So I’m just going to go back and I’m going to go to my Hermes

[02:40] and I will give the prompt in front of you. So hopefully it is going to work. This is the whole prompt which I already showed you. Meanwhile, if you want to help out the channel, please go to the homepage of channel or in the first print comment and become a member. the model is thinking and this is actual test here that how long does it think. If you want to see how long the original thought just go to my channel and search for that video and you’ll be surprised

[03:11] how long uh does it think. So let’s wait for it to come back and then we will analyze in real time if the claim is right or not. Or better yet, after this one is finished, I will uh save the result and then we will also install the original Quen in the same config and then we will run the same prompt and do sideby-side comparison eventually model has produced the file

[03:42] and after verifying it a lot and you know what it has also thought a lot but we can’t really make comparison unless I run the other original one. So before that I’m just going to capture these statistics and then we will compare them later on. So let me just exit from here. This is my session. I’ll just grab some statistics and then I will launch the other one. And if you’re wondering how exactly I’m

[04:12] sure about this statistics, I’m actually also running the direct command to that SQL DB as you can see here. And it has given me these input output tokens. Okay, let me now serve that original coin. Original coin is now being served with same parameters. And I forgot to show you the HTML file which that swift generated. This is the one. Let me open it in the browser. There you go. So this is a simulation. You see there are 10 steps. Let me also

[04:43] make it bit bigger. There you go. I think this is better. So it auto plays the full sixst step sequence. Press R or hit reset to start over. Anyway, so this is step 1, two, three. Going good. And this is a step four. How good is that? Look at that. Goodness me. This is the beauty of co only 27 billion parameter. It is now frothing to silky microform.

[05:14] This is a HTML file. Nothing else. And uh it has it is stuck at step four. Not moving forward, I guess. Or maybe still frozen. What about this step? Poor latte and serve. Okay. So, I’ll just see if R works or not. I’m going to press capital R. Oops. Nothing happening. Maybe it because I’m in the VM. I’ll just go from

[05:44] here. This is also not working. Reset and run again. But even this whole stuff is quite interesting. I’ll do control F5 to reset everything. Let’s try it out again. This is a temping happening. Pull shot. You see even this blinker just switches on on the machine and the cup is getting filled. This is quite cool.

[06:16] and off. Now look at the smoke rising and frothing. Frothing is done now. Silky microphone. So I’ll just wait a bit and see how it goes. Okay. So this is uh where it is. So it just gets stuck here. I have waited for long. Nothing happens even I paused it a bit. Okay. Okay, so let’s go back and now let’s run this with the original

[06:46] coin. So this was our original coin. Let me show you the VM consumption. So this is how much it consumes. And let’s go to Hermes agent where I already have set it up. Same prompt. I’m giving it to base I mean like the 3.8 27 billion original one. So let’s see how it does. We will then compare both of these. So I’m just going to go make some coffee. While Gwen thinks long and hard, let me

[07:19] show you something interesting. They have shared some of the benchmarks across general reasoning, GPQA, MMLQ and lot of other swift stays within a point of base model sometimes even edges ahead while cutting means tokens by 40 to 50%. That is something they have claimed and we will test it out shortly as our tests are running. But look at the mathematics. Amy 2026 computition math

[07:49] multi-step problems. This is something where we cannot really shortcut our way through. Basecoin 3.8 hits 98.667%. Swift comes in at 94%. A 4.6 point drop. And out of everything on this sheet, I think this is the biggest one. Hmmt tells the same story. 99.33 down to 96%. So the pattern holds everywhere except the one category that

[08:20] actually needs sustained step-by-step reasoning. I think that is where we are doing this test. So not whether Swift is faster because it clearly is. It’s whether that speed is costing something on this sort of task that needs the model to actually think it through and we will test out how long does it take and how many tokens it requires. So let’s wait for it to finish and then we will go from there. I think it has

[08:50] already finished I guess. There you go. It’s already done and this is the statistics. Let me also grab this stat from the database. And here is another honest picture. I just checked the output and the reasoning trace and it seemed what this original model did. It copied the previous file, changed it and then regenerated it. So I don’t didn’t think that was a fair comparison. So what I have done, I have relaunched this by

[09:22] removing that original file to another folder. because it is not in the current working directory. So everything stays the same. This is the new directory which I have created. So I just moved it to downloads directory. I’m just giving you the honest picture so that we are all on the same page. This is my current working directory. So now this co model should generate this new file here. And I will again wait for however it takes. I think it will take around an hour or so. And then we will test it out. So

[09:54] let’s see how it goes. And this is what involves in making these videos that it takes hours and hours and you know because these servers are rented so just have to pay for all of these hours and stuff. So a lot of effort, time and money goes into making these videos. Hopefully someday someone will appreciate. So I will wait for this to finish and then we’ll go from there. And eventually this has come back after 45 minutes. And this is what it has

[10:24] generated. So let me copy this path and show it to you live. And I promise I really haven’t checked it out myself. I’m opening it in front of you. There you go. So I will make it bit bigger and then we will test it out. So let’s start. So first step grinding coffee beans. Looks good. Then temping the grounds even better. Latte Pro. By the way,

[10:56] you see red lights on. Pulling espresso shot. Third step. There’s a market difference between the other one and this one. The output and the graphics. Anyway, so it is still pulling it. It is dripping in the cup. As you can see, these are the non things. While the machine is running, the light is on. Same was the story with the other one. It was green. This one is red. I will let it run. That stopped at step four I guess. Now the step four it is streaming and frothing the milk. Look

[11:28] we can just ignore these sort of things but this is good. This is HTML not an image thing and our latte is ready. All the steps are done and reset to go again. So the original one is end to end. It didn’t really break. Uh after step four it is complete. So that is one thing we can tell the difference about for the rest of it. I will just go in and get out of this session and then get the data from database

[12:00] and this is the result from database in all fairness. So this is a table which I have just created comparing both of these which I already have shown you. If you look at this table, this is actually what happened and it’s not quite what you would expect. Swift generated more 60,572 output token tokens against base coins or original coins 11,744 and made more tool calls 21 versus 4.

[12:30] But it finished faster 35 minutes 52 seconds versus 47 minutes 7 seconds for original coin. So this isn’t simply Swift thinks less on this task. Swift did more work in less time. Original Quen on the other hand spend real time secondg guessing itself. You saw it in the transcript debating whether to copy an existing file or rewrite from scratch before settling down and doing the work properly in my second attempt. Uh and I had restarted VLM cleaned everything so

[13:02] that it won’t cach or do anything. So that is one thing you need to uh be aware of. It is a clean clear test. Um and you can see that the claim really doesn’t hold. So but I think um where the claim holds and I agree with that that the real advantage is not fewer thoughts. The real advantage is that it wasted fewer tokens which I agree with. But then uh if you look here even in

[13:32] terms of number of tokens and I’m talking about reasoning um as how it actually got to the result. But overall I would say original Quinn is way more better than this swift or you know what any fine-tune any variation I have seen so far on the um and we have tested on the channel and this question I get a lot that which coin is better. You know what? Just go with the original coin. That is way way better. Rest of it is

[14:03] still research. There are some promising result like in GSQRCO from Austria. But other than that, I think uh original coin would still hold including its quad. That’s it. Let me know what do you think. Thank you for all the