Este pequeno modelo de programação não deveria ser tão bom (MiniCPM5)

Autoria: Better Stack · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: This Tiny Coding Model Shouldn’t Be This Good (MiniCPM5) · Canal: Better Stack · 07:22 · Assistir no YouTube

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

Resumo

O vídeo avalia o MiniCPM5, um modelo de 2 bilhões de parâmetros treinado para tarefas com agentes, e mostra seu desempenho em programação, uso de ferramentas e execução local. Embora tenha resultados impressionantes em alguns benchmarks e ampla compatibilidade com runtimes, seu desempenho varia bastante entre avaliações. Configurações padrão de amostragem podem causar repetições e prejudicar muito os resultados quantizados; ajustar a repeat penalty e o valor min pode resolver parte do problema. O apresentador considera o modelo promissor para experimentação local, mas ainda prefere o Qwen 3.5 4B para tarefas grandes.

Pontos-chave

O MiniCPM5 tem 2 bilhões de parâmetros e foi treinado com 500 mil trajetórias de agentes, fine-tuning supervisionado e reinforcement learning.
No SWE-bench Verified, o vídeo cita uma pontuação de 46 para o MiniCPM5, acima dos modelos de 2B comparados e do Qwen 3.5 4B.
O modelo usa uma arquitetura compatível com runtimes que carregam modelos Llama, incluindo MLX e llama.cpp.
O vídeo demonstra execução local com MLX e chamadas estruturadas de ferramentas por meio de llama.cpp.
Os resultados são inconsistentes entre benchmarks: o MiniCPM5 supera o Qwen 3.5 4B em algumas avaliações de código, mas fica atrás em outras.
Com configurações de quantização documentadas, algumas gerações podem entrar em repetição; ajustar repeat penalty para 1.15 melhora os resultados citados.
Segundo o vídeo, o valor min padrão de llama.cpp deveria ser definido como zero, embora essa orientação não estivesse na documentação quando os testes foram feitos.
O apresentador recomenda experimentar o modelo para tarefas locais pequenas, mas escolheria o Qwen 3.5 4B para tarefas maiores.

Capítulos

Início	Capítulo	Resumo
00:00	Desempenho surpreendente e contexto do modelo	O vídeo apresenta o MiniCPM5 e compara seus resultados iniciais com os de outros modelos pequenos em tarefas de agente.
01:37	Execução local e chamadas de ferramentas	O apresentador demonstra o modelo com MLX e llama.cpp, incluindo chat interativo e uma chamada estruturada de ferramenta.
03:43	Compatibilidade e resultados dos benchmarks	O vídeo explica a arquitetura compatível com runtimes Llama e mostra que o desempenho do MiniCPM5 varia conforme o benchmark.
05:17	Configurações de amostragem e limitações	O apresentador mostra como ajustes de repeat penalty e min podem reduzir falhas de repetição e comenta lacunas na documentação e nas avaliações.
06:51	Recomendação de uso	O modelo é considerado interessante para experimentação local, mas o Qwen 3.5 4B continua sendo a escolha para tarefas maiores.

Citações

Um modelo de dois bilhões de parâmetros afirma superar o de quatro bilhões no SWE-bench. — 00:00

O modelo literalmente não sabe quando parar de falar. — 02:07

Uma configuração padrão ruim pode transformar um modelo útil em algo que não é grande coisa. — 05:17

O interessante não é exatamente um modelo de 2B superar um de 4B, mas ver o quanto esses modelos pequenos estão chegando perto do limite. — 07:22

Conceitos e entidades

MiniCPM-5 (modelo): Modelo de linguagem de 2 bilhões de parâmetros apresentado como voltado a programação e uso de ferramentas por agentes.
OpenBMB (empresa): Organização associada ao MiniCPM5 e citada no vídeo como responsável por divulgar informações sobre o modelo.
SWE-bench Verified (conceito): Benchmark baseado em issues reais do GitHub que avalia a capacidade de produzir correções de código.
MLX (ferramenta): Framework usado no vídeo para executar o modelo localmente em um Mac.
llama.cpp (ferramenta): Runtime usado na demonstração para carregar o modelo e processar chamadas de ferramentas.
Qwen3.5 4B (modelo): Modelo de 4 bilhões de parâmetros usado como comparação e preferido pelo apresentador para tarefas maiores.
GGUF (conceito): Formato de arquivo de modelo quantizado mencionado nos testes de desempenho.

Tradução completa (pt-BR)

00:00 Este modelo de dois bilhões de parâmetros afirma superar o de quatro bilhões no benchmark SWE-bench, mas, ao executar o mesmo modelo em 4 bits com as configurações exatas da própria documentação, ele pode entrar em um loop infinito em mais de 90% das vezes. Isso pode ser verdade, mas também é verdade que dá para corrigir a versão problemática com uma única flag. Este é o MiniCPM5 2B, da OpenBMB. Um modelo de dois bilhões de parâmetros é bom o bastante para ser usado de fato como agent? Vamos dar uma olhada.

00:32 Os modelos pequenos têm enfrentado o mesmo problema há algum tempo. Eles estão ficando muito bons em conversa. Mas dê ferramentas a eles e, em geral, tudo desanda. Veja o SWE-bench Verified. São issues reais do GitHub em que o modelo precisa produzir patches reais. O Qwen 3.5 2B marca cinco pontos. O Gemma 4 E2B marca dois. Esses são números divulgados pelos fornecedores, mas combinam com o que qualquer pessoa que já tentou usar modelos pequenos para tarefas de agent provavelmente viu. O modelo alucina o schema da ferramenta, ou se esquece dele, ou simplesmente entra em loop. Aí aparece o MiniCPM5 2B

01:06 com uma pontuação de 46. Não só muito acima dos outros modelos de 2B, mas também acima do Qwen 3.5 4B, que tem o dobro do tamanho. Então, o que mudou? A OpenBMB aponta três coisas. A arquitetura é Llama padrão. Não há nada exótico aqui. Ele tem cerca de 128 mil tokens de contexto nativo e, o mais importante, o treinamento foi desenvolvido em torno de agents. Foram 500 mil trajetórias de agents durante o fine-tuning supervisionado, depois reinforcement learning e, então, 16 modelos especialistas de

01:37 RL separados, combinados em um só. Ele usa a licença Apache 2.0 e conjuntos de dados open source. E, só para evitar uma confusão comum, este é o modelo MiniCPM5 apenas de texto. Agora, vamos executá-lo de verdade. Se você gosta de ferramentas de programação que aceleram seu workflow, não deixe de se inscrever. Publicamos vídeos o tempo todo. Certo. Para usar MLX, estou em um Mac. Basta executar um pip install em um ambiente virtual, que já deixei preparado aqui. Versões mais antigas do MLX LM ignoram a lista de tokens de fim de sequência deste modelo. Então,

02:07 o modelo literalmente não sabe quando parar de falar. Depois, podemos executar o primeiro prompt para baixar o modelo e os pesos. É só esperar um instante. Na primeira vez, ele inicia. E lá vai. Quando executamos isso, aparece o bloco de raciocínio. É assim que ele pensa. Depois disso, ele produz a resposta final. E também aparece o contador de tokens por segundo. Tudo isso vem de um arquivo de 1,3 GB. Agora, também podemos configurá-lo para uma conversa interativa. Então, quando coloco esta linha aqui, pronto, ele inicia

02:39 e você pode ver que agora ele está sempre ouvindo. Assim, podemos fazer uma pergunta a qualquer momento, e as respostas chegam na hora. Conversar é legal, mas o uso de ferramentas também funciona muito bem aqui. Vou iniciar o Llama.cpp em um novo terminal, apontar um cliente OpenAI para ele e fornecer uma ferramenta simples de previsão do tempo. O modelo produz uma chamada de função estruturada, o Llama.cpp a interpreta e a resposta volta como um array adequado de chamadas de ferramenta. Agora você pode imaginar todas as maneiras diferentes de executar isso sem problemas no seu sistema. Agora,

03:12 há também uma razão para a compatibilidade ser tão boa. Se olharmos de forma mais ampla, este é um modelo denso de 2,5 bilhões de parâmetros, com 42 camadas e atenção de consultas agrupadas. Mas o ponto importante aqui é a arquitetura: Llama para modelos de linguagem casuais. O MiniCPM4 não era assim. Ele usava atenção esparsa personalizada e previsão de múltiplos tokens. Isso é ótimo, mas todos os runtimes precisavam de suporte especial. O MiniCPM5 basicamente abandona isso. Se o seu runtime consegue carregar Llama, há uma boa chance de conseguir carregar este modelo. MLX,

03:43 Llama.cpp, WebLLM. Então, a compatibilidade é um dos pontos mais fortes deste modelo. Mas agora chegamos à tabela completa de benchmarks, porque é aqui que as coisas ficam bem menos claras. Se você ler a tabela só por um ângulo, o MiniCPM5 parece absurdo. Comparado ao Qwen 3.5 4B, um modelo com o dobro do tamanho, no LiveCodeBench eles marcam 69 contra 56. No SWE-bench Verified, 46 contra 34. Você também pode conferir essas classificações em outras plataformas. Então, essa comparação é meio absurda. Isso parece

04:14 um modelo de 2B substituindo um de 4B. Agora, veja a tabela por outro ângulo. No SWE-bench Pro, 14 contra 28. O MiniCPM5 faz metade da pontuação. No Terminal-Bench, temos cerca de 8,5 contra aproximadamente 26, mais ou menos um terço. O Qwen 3.5 4B também vence em outras plataformas: MMLU-Pro, GPQA Diamond e LogBench V2. E, em seguimento de instruções simples, até o Qwen 3.5 2B supera o MiniCPM5. Então, quando dizem que ele está na

04:44 classe dos modelos de 4B, há alguma verdade nisso para código, chamadas de ferramentas, matemática e partes das tarefas de agent. Mas, de forma geral? É, provavelmente não. O maior problema específico deste modelo é o que acontece quando você executa a versão quantizada usando as configurações documentadas. Alguém no rastreador do GitHub testou o HumanEval Plus com os arquivos GGUF. O Q8 marcou cerca de 43, e 55% das gerações descambaram para repetição. O Q4_K_M marcou cerca de seis, e 92% descambaram. 92%.

05:17 Parece um modelo quebrado, mas aí mudaram uma coisa: a penalidade de repetição para 1,15. A pontuação do Q8 salta de cerca de 43 para 92. A do Q4 salta de 6 para 71. Mais tarde, a OpenBMB disse no Hugging Face que o valor padrão de min do Llama.cpp é 0,5. Esse é o verdadeiro problema e o valor deveria ser zero. Mas isso não estava na documentação quando as pessoas fizeram os testes. Com dois bilhões de parâmetros, um valor padrão ruim pode transformar um modelo útil em… bem, em nada muito bom. O sampler

05:48 não é mais só um ajuste. Ele faz parte do próprio modelo. E há mais algumas coisas que você deveria saber antes de usá-lo. Todos os benchmarks aqui foram executados pelo fornecedor. Então, a tabela comparativa inclui apenas Qwen e Gemma. Nada de Llama, nada de Phi, nada de Small LM3, nem sequer uma linha do MiniCPM4 mostrando o que melhorou de uma geração para a outra. Alguém pediu os scripts de avaliação em uma issue. Não houve resposta. Ele também não está na biblioteca do Llama, então você precisa escrever um arquivo de modelo. Também não há uma página no LM Studio.

06:20 Você precisa colocar o GGUF manualmente. O raciocínio fica ativado por padrão, então cada resposta precisa raciocinar antes de começar a responder. Há uma opção para ativar ou desativar o raciocínio no template de chat, mas a documentação oficial só fornece um perfil de amostragem para o modo de raciocínio. Ninguém mediu ainda como ele se sai com o raciocínio desativado. Só inglês e chinês; mais de 100 mil downloads para o modelo 2B e 600 mil para o 1B. As pessoas estão usando esses modelos, só não falam tanto deles. Então, eu realmente usaria o Mini

06:51 CPM5 2B? Bem, é muito legal brincar com eles. É legal ver para onde as coisas locais estão indo, para usar como agent de programação local, talvez em um MacBook Air. Quer dizer, sim, pode ser bem legal. Eu usaria o MLX em 4 bits ou o GGUF Q8. Colocaria o min_p em zero. Ajustaria a penalidade de repetição para o valor que eles realmente recomendam para essa tarefa. Pode ser bem forte para um modelo desse tamanho, né? Dá para ver para onde esses modelos locais estão indo. Teste-os e veja como melhoram com o tempo. Para qualquer tarefa realmente grande,

07:22 eu ainda escolheria o Qwen 3.5 4B em vez deste. E isso não significa que eu discorde da OpenBMB. Já testei outros modelos deles. Alguns são muito, muito bons. O interessante aqui não é exatamente que um modelo de 2B consiga superar um de 4B. É o quanto esses modelos pequenos estão chegando perto do limite. O próprio MiniCPM5 está bom. O que pode quebrá-lo são as configurações padrão. Sou Josh, da Better Stack. Se você gosta de dicas e truques de programação como este, não deixe de se inscrever. A gente se vê em outro vídeo.

Transcrição original

[00:00] This two billion parameter model claims to beat the four billion one on S swb bench but run the same model at 4bit using the exact settings in its own docs and it can fall into an infinite loop over 90% of the time. Now that could be true but it’s also true the broken version is fixable with one flag. This is mini CPM52B from open BMBB. Is a 2 billion parameter model good enough to actually be used as an agent? Let’s take a look.

[00:32] Now, small models have had the same problem for a while. They are getting pretty good at chat. Give them tools, though, and things usually fall apart. Look at swbench verified. These are real GitHub issues when the model has to produce real patches. Quinn 3.5, 2B scores five. Gemma 4, E2B scores two. Those are vendor numbers, but match what anyone who’s tried small models for agent work has probably seen. The model hallucinates the toll schema or forgets it or just loops. Then mini CPM 52B

[01:06] shows up with a score of 46. Not only way above the other 2B models, but also above Quen 3.54B, which is twice its size. So, what’s changed? OpenBM points to three things. The architecture is plain llama. There’s nothing exotic here. It has about 128,000 native context and most importantly, the training was built around agents. 500,000 agent trajectories during supervised fine-tuning, then reinforcement learning, then 16 separate

[01:37] RL expert models merged into one. It’s Apache 2.0 with open data sets. And just to avoid one easy point of confusion, this is the texton mini CPM5 model. Now, let’s actually run it. If you enjoy coding tools that speed up your workflow, be sure to subscribe. We have videos coming out all the time. All right. Now, for MLX, I’m on a Mac here. We can just do a pip install in a virtual environment, which I got set up here. Older versions of MLX LM ignore this model’s end of sequence list. So,

[02:07] the model literally doesn’t know when to stop talking. Then, we can run the first prompt to pull the model in the weights. Just give it a second. It fires up the first time. And here it goes. Once we run this, you get the think block. This is how it thinks. Then after this, it produces that final answer. And there’s the tokens per second counter as well. All of that is coming from a 1.3 GB file. Now, we can even set this to be an interactive chat, too. So, when I drop this line in here, boom, it fires

[02:39] up. You can see now it’s always listening. So, we can just ask a question on the go, and the responses that we get fire right back at us. Now, chat is cool, but the tools are just as good here. I’m going to start up Llama CPP now in a new terminal, then point an OpenAI client at it and give it a simple weather tool. The model produces a structured function call llama CPP parses it, and the response comes back as a proper tool calls array. So now you can think of all the different ways this could run cleanly on your system. Now,

[03:12] there’s also a reason compatibility is this clean. If we take a step back, this is a dense 2.5 billion parameter model with 42 layers and grouped query attention. But the important line is the architecture here. Llama for casual LM. Mini CPM4 isn’t that. It used custom sparse attention and multi-token prediction. That’s nice and all, but every runtime needed special support. Mini CPM 5 basically throws that away. If your runtime can load llama, there’s a good chance it can load this. MLX,

[03:43] Llama CPP, Web, LLM. So, compatibility is one of the strongest parts of this model. But now we get to the whole benchmark table because this is where it gets a lot less clean. If you only read the table one direction, Min CPM5 looks ridiculous. Against Quen 3.54B, a model twice its size. Live codebench has them 69 to 56. SWE Bench verified 46 to 34. You can check these rankings on other platforms as well. So, the comparison here is kind of ridiculous. That sounds

[04:14] like a 2B model replacing a 4B model. Now, look at the table in a new light. SWEBench Pro 14 versus 28. Mini CPM 5 gets half the score. Terminal Bench, we have about an 8 1/2 versus around a 26, about a third. Quen 3.54B also wins on other platforms. Mmlu Pro, GPQA Diamond, and Logbench V2. and on plain instruction following even Quen 3.52B beats mini CPM 5. So when they call this

[04:44] 4B class there’s some truth to it for code tool calls math and parts of the agent workload absolutely across the whole board. Yeah. No, probably not. The bigger problem with this model specifically is what happens when you run the quantized model using the documented settings. Someone on the GitHub tracker tested human eval plus against the GGUF files. Q8 scored about a 43 and 55% of generations ran away into repetition. Q4KM scored around a six and 92% ran away. 92%.

[05:17] That looks like a broken model except then they changed one thing. Repeat penalty 1.15. Q8 jumps from around a 43 to a 92. Q4 jumps 6 to 71. Open BMBB later said on Hugging Face that Llama’s CPP’s default min value is 05. That’s the real problem and that it should be set to zero. But that wasn’t in the docs when people ran this. At 2 billion parameters, one bad default can turn a useful model into well nothing really great. The sampler

[05:48] isn’t just tuning anymore. It’s part of the actual model. And there are a few more things you should know before using it. Every benchmark here is vendor ran. So the comparison table only includes Quen and Gemma. No Llama, no fee, no small LM3, not even a mini CPM4 row showing what improved generation to generation. Someone asked for the evaluation scripts in an issue. No response. It’s also not in the Lama library, so you need to write a model file. There’s no LM Studio page either.

[06:20] You drop the GGUF inn manually. Thinking is enabled by default, so every answer has to reason before it starts giving you the response. There is an enable thinking switch in the chat template, but the official docs only provide a sampling profile for think mode. Nobody has measured what it’s like with thinking disabled yet. English and Chinese only, more than 100,000 downloads for the 2B model, 600,000 for the 1B. People are running these, they’re just not talking about them that much. So, would I actually use mini

[06:51] CPM52B? Well, these are really cool to play around with. They’re cool to see where local stuff is going for a local coding agent on maybe like a MacBook Air. I mean, yeah, okay. It could be kind of cool. I’d run the MLX4 bit or the Q8 GGUF. I’d set them in P to zero. Set the repeat penalty to what they actually recommend for that job. It might be pretty strong for that size, right? we can see where these local models are going. Give them a test and see how they improve over time. For anything that’s like a really big task,

[07:22] I would still take Quen 3.54B over this. And that’s not me disagreeing with OpenBM. I’ve tested other models they have. Some are really, really good. The interesting thing here isn’t really that a 2B model can beat a 4B model. It’s how close to the edge these small models are actually getting. Mini CPM 5 itself is fine. The defaults are what can break it. I’m Josh from Better Stack. If you enjoy coding tips and tricks like this, be sure to subscribe. We’ll see you in another video.