Olá a todos.
Prefácio: Sempre lembrando corro modelos locais em casa, numa máquina que está longe de ter uma 4090, e tenho um preconceito assumido a favor de tudo o que corre dentro de portas. Contem com isso ao longo do texto.
Depois do post sobre a Tiny League ficou-me uma pergunta a martelar na cabeça. Toda a gente quer saber se a máquina aguenta o modelo. Quase ninguém pergunta se o modelo está a receber aquilo que devia. E a minha experiência dos últimos meses com a família Qwen diz-me que uma boa parte do “este modelo escreve código fraco” não tem nada a ver com os pesos. Tem a ver com um ficheiro de texto de 30 kB que quase ninguém abre: o chat template.
Este post é sobre esse ficheiro. Mais concretamente, sobre o Qwen-Sharp-Chat-Templates, um template Jinja para os Qwen3.5, 3.6 e 3.8 que anda a circular no Hugging Face. E sobre a razão pela qual, quanto mais modesto é o modelo que correm, mais isto vos deve importar.
O modelo nunca vê o vosso JSON
Comecemos pelo básico, porque é aqui que a maior parte das pessoas tem um ponto cego.
Quando o vosso editor, o vosso agente ou o Open WebUI falam com o llama.cpp, enviam uma lista de mensagens bonitinha em JSON. Um system, um user, talvez umas chamadas a ferramentas pelo meio. O modelo não vê nada disso. Um modelo de linguagem só vê uma sequência de tokens. Alguém tem de pegar naquele JSON e transformá-lo numa string com o formato exato que o modelo viu durante o treino.
Esse alguém é o chat template. É um ficheiro Jinja (a mesma linguagem de templates que muitos de vocês conhecem do Ansible ou do Flask) que vem embutido no GGUF ou no tokenizer_config.json, e que o runtime executa a cada pedido. No caso dos Qwen, o resultado é qualquer coisa assim:
<|im_start|>system
És um assistente de programação.<|im_end|>
<|im_start|>user
Escreve uma função que leia um ficheiro INI.<|im_end|>
<|im_start|>assistant
<think>
Parece trivial. Não é. O template decide onde ficam as instruções de sistema, como se descrevem as ferramentas disponíveis, como se formatam as respostas dessas ferramentas, se o raciocínio das respostas anteriores fica no histórico ou é apagado, se o bloco <think> é aberto ou já vai fechado. Cada uma destas decisões muda aquilo que o modelo lê. E o modelo só sabe responder bem àquilo que se parece com o que viu no treino.
Um LLM não é um compilador, já o disse aqui. Também não é um parser tolerante. É um bicho estatístico que reage a padrões. Se o padrão estiver ligeiramente torto, a resposta também fica.
Um modelo grande perdoa, um pequeno não
Isto leva-me à tese do post, que é simples: um template mal feito custa muito mais a um modelo pequeno do que a um grande.
Um modelo de centenas de milhares de milhões de parâmetros, servido por uma API comercial, tem margem para aguentar ruído. Se o histórico tiver um separador a mais, uma ferramenta descrita de forma estranha ou um bloco de raciocínio que aparece e desaparece entre turnos, ele lá se desenrasca. Tem capacidade de sobra para generalizar por cima do problema.
Um Qwen3.8 quantizado a correr num portátil não tem essa folga. Cada bocado de “estranheza” no prompt gasta-lhe uma fatia da pouca capacidade que tem para a tarefa que interessa, que é escrever código que funcione. E há um segundo custo, mais prosaico: em hardware modesto, o contexto é caro. Cada token de palavreado que o modelo gera é um token que tem de ser processado de novo no turno seguinte, que ocupa KV cache, que vos come segundos (às vezes minutos) num prefill lento.
Quem corre modelos pequenos em agentes de código já viu os sintomas, mesmo sem lhes dar nome:
- o modelo responde “Claro! Aqui está uma solução completa e robusta…” e gasta duzentos tokens antes da primeira linha de código;
- num loop de agente, repete a mesma chamada falhada três, quatro, cinco vezes, com os mesmos argumentos;
- com o raciocínio desligado, começa a “pensar em voz alta” no meio da resposta, porque o template deixou a porta aberta;
- a meio de uma sessão longa, perde o fio àquilo que tinha decidido dez turnos antes.
Nenhuma destas coisas se resolve trocando para um modelo maior se a máquina não o aguenta. Algumas resolvem-se no template.
O Qwen-Sharp em cinco minutos
Convém deixar claro o que este repositório é, porque a própria metadata do Hugging Face engana: diz base_model_relation: finetune, mas não há aqui pesos nenhuns. O README diz isso com todas as letras. É só um template, licença Apache-2.0, pensado para funcionar com qualquer modelo Qwen3.5, 3.6 ou 3.8.
Também não nasceu do nada. É um fork do Qwen-Fixed-Chat-Templates do froggeric (versão 22.5), que já corrigia uma série de problemas do template original da Qwen. O que o peculiar-ragdoll acrescentou foi, essencialmente, um bloco de instruções de concisão e um punhado de correções para o modo sem raciocínio. A primeira linha do ficheiro identifica-o sem rodeios:
{%- set template_version = "qwen3.8-froggeric-v22.5.0" %}
No repositório encontram três ficheiros que interessam: o chat_template.jinja normal, uma versão minificada em texto e outra minificada e já escapada para colar diretamente no campo "chat_template" do tokenizer_config.json. Há ainda uma pasta archive/ com as versões anteriores e uma pasta scripts/ com testes, um fuzzer e um script para confirmar que o template foi mesmo aplicado. Isto, para um ficheiro de template, é mais cuidado do que se vê em muito software “a sério”. Cof cof.
Vamos às partes que mexem com a qualidade do código.
Menos palavras, mais código
A alteração mais visível é um bloco de instruções que o template acrescenta sempre ao prompt de sistema. Atenção ao “acrescenta”: se o vosso agente ou editor já manda um prompt de sistema, esse prompt mantém-se e o bloco de concisão vai a seguir, separado por uma linha em branco:
{%- if not _sc %}
{%- set _sc = _terse | trim %}
{%- else %}
{%- set _sc = (_sc | trim) ~ '\n\n' ~ (_terse | trim) %}
{%- endif %}
A frase de abertura muda consoante o raciocínio esteja ligado ou não:
{%- if ns_state.thinking %}
{%- set _terse_lead = 'Answer directly, after thinking. Lead with the answer, then only what it needs to be correct and usable.' %}
{%- else %}
{%- set _terse_lead = 'Answer directly and concisely. Give the answer with only what it needs to be correct and usable.' %}
{%- endif %}
E depois vêm as regras propriamente ditas, das quais destaco duas linhas:
Never: open with preamble or pleasantries; restate the question; add filler transitions; hedge with niceties; or repeat a point you've already made.
Always: keep essential steps, caveats, uncertainties, and specifics — never drop correctness or a needed warning for brevity.
A segunda linha é a que me fez levar isto a sério. Pedir a um modelo que seja curto é fácil, e qualquer um de vocês já o fez num prompt de sistema. O problema é que um modelo pequeno, quando lhe pedem para ser curto, tende a cortar no sítio errado: corta o aviso de que a função não é thread-safe e mantém o “Espero que ajude!”. Aqui o pedido é explícito: corta o enchimento, nunca cortes o que é preciso para o código estar correto.
Porque é que isto melhora o código e não só a estética? Por três razões.
A primeira é de orçamento. Num modelo modesto, o número de tokens que consegue gerar com qualidade antes de começar a perder coerência é limitado. Se gasta um terço desse orçamento em preâmbulo e numa explicação linha a linha do que acabou de escrever, sobra menos para o que importa.
A segunda é de contexto. Em sessões de agente, cada resposta fica no histórico. Respostas palavrosas enchem a janela de contexto com lixo que o modelo tem de reler a cada turno. Num modelo pequeno, isso traduz-se em perda de atenção sobre o que é relevante, e é precisamente aí que começam as alucinações de nomes de funções e de ficheiros que não existem.
A terceira é humana. Código que vem sozinho, com dois avisos certeiros por baixo, é código que se revê. Código enterrado em três parágrafos de prosa é código que se aceita a correr, sem ler. E nós sabemos como isso acaba.
Se por algum motivo quiserem o comportamento antigo, há um interruptor:
{%- set _terse_on = terse if terse is defined else true %}
Ou seja, vem ligado por omissão e desliga-se por pedido, já lá vamos.
O raciocínio (ou como raio isto funciona?)
Esta parte vem herdada da base do froggeric, mas é das que mais diferença faz em trabalho de código com agentes, por isso merece espaço.
Os modelos Qwen com raciocínio escrevem primeiro dentro de um bloco <think> e só depois dão a resposta. A questão é o que acontece a esse bloco nos turnos seguintes. Segundo o README, o template original da Qwen remove-o do histórico. O Sharp mantém-no por omissão:
{%- else %}
{%- set _preserve_thinking = true %}
Há dois efeitos práticos neste pensamento.
O primeiro é de consistência. Quando um agente está a corrigir um bug ao longo de vários turnos, o raciocínio é onde ficam as decisões: “o problema está no parser, não na função de validação”, “não posso mexer na assinatura porque há três chamadas noutros módulos”. Se esse raciocínio desaparece, o modelo vê apenas as ações que tomou, sem o porquê. Um modelo grande reconstrói o porquê sozinho. Um pequeno, muitas vezes, não reconstrói, e começa a desfazer decisões que ele próprio tinha tomado com boas razões.
O segundo efeito é de desempenho, e quem corre em hardware modesto vai senti-lo logo. O llama.cpp reutiliza a KV cache quando o início do prompt é igual ao do pedido anterior. Se o template reescreve o histórico a cada turno, removendo os blocos de raciocínio, o prefixo muda e a cache deixa de servir. Resultado: o servidor volta a processar o contexto todo. Numa sessão de agente com 20 ou 30 mil tokens de histórico, numa máquina onde o prefill anda pelas centenas de tokens por segundo, isso significa esperar minuto e meio por cada turno. Mantendo o histórico intacto, o prefixo não muda e só se processa o que é novo.
Há um custo, claro: o raciocínio ocupa contexto. Numa máquina com pouca memória pode fazer sentido desligar isto, e o template aceita o parâmetro preserve_reasoning para esse efeito. Mas comecem com o valor por omissão e só mudem se baterem no teto.
Ainda dentro do raciocínio: quando o desligam, o template não se limita a omitir a abertura do bloco. Abre-o e fecha-o logo, vazio:
{%- if add_generation_prompt %}
{{- '<|im_start|>assistant\n' }}
{%- if not ns_state.thinking %}
{{- '<think>\n\n</think>\n\n' }}
{%- else %}
{{- '<think>\n' }}
{%- endif %}
{%- endif %}
Parece um pormenor. Para um modelo treinado a abrir sempre um bloco de raciocínio, receber um bloco já fechado é a forma mais clara de lhe dizer “aqui não se pensa, responde”. Sem isto, os modelos pequenos têm o péssimo hábito de começar a raciocinar no meio da resposta, e depois o vosso agente recebe código com um parágrafo de dúvidas existenciais pendurado a meio de uma função.
Para alternar entre modos sem mexer em configuração, o template aceita etiquetas embutidas nas próprias mensagens: <|think_off|>, <|think_on|>, <|think_low|>, <|think_xhigh|>, entre outras. Dá jeito quando querem que o modelo pense a sério sobre a arquitetura de um módulo e depois despache em modo rápido as vinte alterações mecânicas que se seguem.
Quando o modelo bate três vezes na mesma parede
Esta é a minha funcionalidade preferida, e é a que mais diretamente ataca um defeito clássico dos modelos pequenos em agentes de código.
O cenário é conhecido. O agente corre os testes. Os testes falham com um ModuleNotFoundError porque o caminho está errado. O modelo “corrige” e volta a correr exatamente o mesmo comando. Falha outra vez. Corre outra vez. Um modelo grande normalmente percebe ao segundo erro que tem de mudar de abordagem. Um modelo de bolso entra em loop até o agente lhe cortar o pio por limite de iterações.
O template conta as falhas consecutivas de ferramentas e, a partir de certo ponto, injeta isto na resposta da ferramenta:
{{- '\n\n⚠ SYSTEM WARNING: ' ~ ns2.consecutive_failures ~ ' consecutive tool errors detected. Your previous approach is incorrect. You MUST use a fundamentally different approach or corrected arguments.' }}
É bruto, não é elegante, e funciona pela mesma razão que funciona com pessoas cansadas às duas da manhã: alguém de fora diz-lhes “pára, isso não vai lá”. O modelo pequeno não tem metacognição suficiente para reparar que está em loop. O template tem um contador e faz esse papel por ele.
O pormenor que me convenceu de que o autor usou isto a sério, e não só em testes sintéticos, está na forma como se decide o que é uma falha. Uma ferramenta de pesquisa que devolve linhas de código com throw new, console.error ou logger.error não é uma falha. É um grep que encontrou o que procurava. Um detetor ingénuo contaria isso como erro e começaria a gritar com o modelo por ter feito exatamente o que devia. Este não conta. Quem já escreveu heurísticas destas sabe que é nestes casos limite que se separa o código que alguém usou do código que alguém só imaginou.
As ferramentas, de forma geral
Ainda no capítulo das ferramentas, há algumas correções mais discretas que vale a pena conhecer.
O template suporta chamadas em XML (por omissão) e em JSON. As referências ao raciocínio nas instruções de ferramentas só aparecem quando o raciocínio está ligado, o que evita dar ao modelo instruções contraditórias do tipo “pensa antes de chamar a ferramenta” num modo em que ele não pode pensar.
Na versão 22.4, as chamadas paralelas consecutivas no histórico passaram a ser separadas por uma única quebra de linha, para coincidir com aquilo que o modelo oficial gera. Lembram-se do que eu disse sobre padrões tortos? É isto. Se o histórico tem um formato diferente daquele que o modelo produziria, o modelo vê “texto que não é bem meu” e reage pior.
E há uma deteção que poupa dores de cabeça a quem usa o LM Studio com o backend MLX: se o prompt de sistema já contém [TOOL_REQUEST] (que é o que esse backend injeta), o template não acrescenta o seu próprio bloco de ferramentas.
{%- set _runtime_tool_protocol = (_sc is defined and _sc and '[TOOL_REQUEST]' in _sc) %}
{%- set _suppress_tools = suppress_tool_instructions if suppress_tool_instructions is defined else _runtime_tool_protocol %}
Sem isto, o modelo recebia duas descrições diferentes de como chamar ferramentas, no mesmo prompt. Imaginem o que um modelo de 4B faz com instruções contraditórias. Ou melhor, não imaginem, que eu já vi e não é bonito.
Os números, e como por vezes a matemática não conta a historia toda.
Agora a parte em que tenho de ser chato, porque é o meu papel neste blog.
O autor publica alguns resultados. No SWE-bench-Live, com o Qwen3.8-27B e esforço de raciocínio médio nos dois braços, o Sharp resolveu 15 de 25 problemas. O template de origem resolveu 16. Leram bem: resolveu menos um. Mas o tempo mediano até à correção foi de 20,0 minutos com o Sharp contra 54,6 minutos sem ele. O README resume isto como “2,7 vezes mais rápido no problema mediano”.
No Claw-Eval, com o ThinkingCap-Qwen3.6-27B, os números reportados são +7,4 na pontuação das respostas, +3,8 no total e menos 59% de tokens nas respostas.
Há caveats, e o próprio autor assume-os: 25 problemas é uma amostra pequena, os valores da tabela principal são só do Qwen3.6, e o template não está afinado modelo a modelo. Há também um relato de uma etiqueta <think> a aparecer a meio de uma resposta que o autor diz não ter conseguido reproduzir. Do lado dos testes ao próprio template, a coisa está mais sólida: 105 em 105 na suite da v22, e o fuzzer passou limpo por 2000 conversas geradas.
Então, o template torna o modelo mais inteligente? Não. Nada nestes números sugere isso, e desconfiem de quem vos disser que um ficheiro Jinja faz um modelo resolver problemas que antes não resolvia. Um 15 contra 16 em 25 é, na prática, um empate.
O que os números mostram é outra coisa, e para quem corre modelos em hardware modesto é mais importante: o mesmo modelo chega ao mesmo resultado com muito menos texto e em muito menos tempo. Numa máquina com uma GPU de gama média, a diferença entre 20 e 55 minutos por correção é a diferença entre usar o agente no dia a dia ou desistir dele ao fim de uma semana. E 59% menos tokens nas respostas são 59% menos tokens no histórico, a ocupar contexto e a pesar no prefill dos turnos seguintes.
Lento não quer dizer inútil. Mas lento e palavroso, num modelo que já trabalha no limite, é meio caminho andado para a frustração.
Um exemplo à mão
Para tornar isto menos abstrato, vamos ao tipo de diferença que se vê numa tarefa simples. Um aviso antes: o que se segue é um exemplo construído para ilustrar a forma das respostas, não uma medição. Correm o mesmo modelo, com os mesmos parâmetros, e pedem-lhe isto:
Escreve uma função em Python que leia um ficheiro INI e devolva um dicionário de dicionários.
Com o template de origem e sem prompt de sistema, a resposta típica de um modelo pequeno tem esta forma:
Claro! Os ficheiros INI são um formato de configuração muito popular
e o Python tem um módulo excelente para isso. Aqui está uma solução
completa e robusta:
import configparser
def ler_ini(caminho):
try:
config = configparser.ConfigParser()
config.read(caminho)
resultado = {}
for seccao in config.sections():
resultado[seccao] = dict(config[seccao])
return resultado
except Exception as e:
print(f"Erro: {e}")
return {}
Explicação:
1. Importamos o módulo configparser.
2. Criamos um objeto ConfigParser.
3. Lemos o ficheiro com o método read().
(...)
Espero que isto ajude! Se tiveres mais perguntas, diz.
Olhem para o código, não para a prosa. Há dois problemas que um revisor apanhava. O config.read() não lança exceção se o ficheiro não existir: devolve uma lista vazia e segue em frente, e a função devolve um dicionário vazio sem dizer nada. E o except Exception com um print engole qualquer erro de parsing e devolve, outra vez, um dicionário vazio. Ou seja, um ficheiro inexistente, um ficheiro corrompido e um ficheiro vazio dão todos o mesmo resultado. Boa sorte a depurar isso em produção.
Com o Sharp, a forma da resposta muda para algo assim:
import configparser
def ler_ini(caminho: str) -> dict[str, dict[str, str]]:
config = configparser.ConfigParser(interpolation=None)
config.optionxform = str # preserva maiúsculas nas chaves
with open(caminho, encoding="utf-8") as f:
config.read_file(f)
return {s: dict(config[s]) for s in config.sections()}
Notas:
- read_file() com open() falha com FileNotFoundError se o ficheiro
não existir; read() falharia em silêncio.
- Por omissão o configparser passa as chaves a minúsculas e trata
"%" como interpolação; desliguei ambos.
- As chaves da secção [DEFAULT] são herdadas por todas as secções.
Repararem numa coisa: o template não contém nenhuma instrução sobre Python, nem sobre configparser, nem sobre tratamento de erros. Não há prompts específicos de código no Sharp; a única lógica relacionada com código é a deteção de erros de ferramentas de que falei acima. O que muda é onde o modelo gasta o esforço. A regra “keep essential caveats” obriga a resposta a ter avisos, e um aviso só se escreve se o modelo pensar no que pode correr mal. O “never open with preamble” e o “never restate” tiram-lhe o sítio onde costumava despejar texto genérico. O efeito, na minha experiência, é que os avisos passam a ser sobre o código e não sobre o formato INI em geral.
Não vos vou prometer que é sempre assim. Há respostas em que o modelo continua a fazer asneira, curta mas asneira. A diferença é que a asneira curta se vê ao primeiro olhar.
O que o modelo realmente lê
Se quiserem ver com os vossos olhos o que muda, o truque é renderizar o template sem gerar nada. Com o transformers:
from transformers import AutoTokenizer
tok = AutoTokenizer.from_pretrained("/caminho/para/o/modelo")
mensagens = [
{"role": "system", "content": "És um assistente de programação."},
{"role": "user", "content": "Escreve uma função que leia um INI."},
]
print(tok.apply_chat_template(
mensagens, tokenize=False, add_generation_prompt=True,
enable_thinking=False,
))
Corram isto com o template de origem e depois com o Sharp na pasta do modelo, e comparem. Vão ver o vosso prompt de sistema intacto, seguido do bloco de concisão, e no fim o <think> já fechado. Este exercício de cinco minutos ensina mais sobre como os modelos se comportam do que muita documentação que por aí anda. Recomendo-o mesmo que não fiquem com o Sharp.
Como o pôr a funcionar
A boa notícia é que não precisam de voltar a quantizar nada.
Para MLX, transformers ou oMLX, basta largar o ficheiro na pasta do modelo:
hf download peculiar-ragdoll/Qwen-Sharp-Chat-Templates chat_template.jinja \
--local-dir /caminho/para/o/modelo
O transformers a partir da 4.51 e as versões atuais do oMLX e do LM Studio preferem o ficheiro .jinja. Runtimes mais antigos só leem a chave chat_template do tokenizer_config.json. Se existirem os dois, atualizem os dois, ou vão passar uma tarde a perceber porque é que “não muda nada”.
Para GGUF, podem reescrever o template embutido no próprio ficheiro:
pip install gguf
gguf-new-metadata \
--chat-template-file chat_template.jinja \
modelo.gguf modelo-sharp.gguf
Ou, mais simples, passá-lo ao llama.cpp em runtime sem tocar no GGUF:
llama-server -m modelo.gguf --chat-template-file chat_template.jinja -ngl 99
Nas versões atuais do llama.cpp o --jinja já vem ligado por omissão. Em builds mais antigas tem de ser passado, e antes do --chat-template-file. O README avisa ainda para não usarem --reasoning-format none com agentes. Para confirmar que o servidor está mesmo a usar o template certo:
curl -s localhost:8080/props | jq -r .chat_template | head -n 5
Se a primeira linha disser qwen3.8-froggeric-v22.5.0, está tudo bem. Se não disser, há um template embutido a ganhar ao vosso.
Os parâmetros do template passam-se por pedido, dentro de chat_template_kwargs:
{"messages": [...], "chat_template_kwargs": {"reasoning_effort": "low"}}
{"messages": [...], "chat_template_kwargs": {"terse": false}}
Atenção a este ponto, que é onde muita gente tropeça: se puserem reasoning_effort ou terse no nível de topo do pedido, o servidor consome o campo e ele nunca chega ao template. Funciona sem dar erro e não faz nada, que é a pior forma de falhar.
Duas notas finais de configuração. O README não fala do Ollama, por isso se o usam vão ter de adaptar por vossa conta (e testar). E o autor diz que num modelo de 4B as instruções de concisão podem precisar de ser mais firmes. Faz sentido: quanto mais pequeno o modelo, menos ele obedece a instruções subtis. Se forem por aí, mexam no texto do bloco e não na lógica à volta.
Porque é que isto me interessa.
Há uns tempos, a conversa sobre modelos locais era só sobre tamanho. Quantos parâmetros, que quantização, cabe ou não cabe na VRAM. A Tiny League e o r/LowEndLocalAI mudaram um bocado isso, porque mostraram que há muita coisa útil a acontecer em máquinas que ninguém levaria a sério há dois anos.
Mas há uma camada no meio que continua invisível para a maior parte das pessoas, e o chat template é a peça mais esquecida dessa camada. Faz parte do modelo tanto quanto os pesos. Vem embutido no GGUF, ninguém o lê, e quando está mal o sintoma aparece como “o modelo é fraco”. Quantas vezes já descartaram um modelo pequeno ao fim de uma tarde porque “não presta para código”? Eu já o fiz mais vezes do que gostaria de admitir, e em pelo menos metade dos casos, olhando para trás, o problema estava no que o modelo recebia e não no que ele sabia.
Há também uma questão de soberania aqui, que é o meu cavalo de batalha habitual. Quem usa uma API comercial não controla o template: a empresa trata disso, bem ou mal, e vocês nunca vão saber. Quem corre localmente pode abrir o ficheiro, lê-lo, alterá-lo, testá-lo e versioná-lo junto com o resto da infraestrutura. Isso é uma vantagem real, mas só se a usarem. Um template que ninguém abre é tão opaco como uma API.
O Sharp não é o único caminho nem tem de ser o último. A base do froggeric continua a existir, e nada vos impede de pegar num destes e afinar o bloco de instruções para a vossa realidade: o vosso stack, as vossas convenções, os erros que o vosso modelo comete mais vezes. O que eu defendo é que tratem o template como código. Leiam-no. Testem-no com conversas reais. Ponham-no em git. Quando mudarem de versão do modelo, verifiquem se o template mudou também.
Um modelo modesto com um bom template não vai fazer o trabalho de um modelo de fronteira. Mas vai fazer o trabalho que é capaz de fazer sem tropeçar em ruído que não precisava de lá estar. E num 27B quantizado numa máquina de casa, a diferença entre um assistente que se usa e um que se abandona está muitas vezes aí.
Este fim de semana, abram o chat_template do modelo que estão a usar. Só isso. Leiam-no de uma ponta à outra e renderizem uma conversa vossa. Garanto-vos que vão encontrar pelo menos uma coisa que não sabiam que o vosso modelo estava a receber.
Abraço!
Nuno
Fontes e leitura adicional
O template:
- peculiar-ragdoll/Qwen-Sharp-Chat-Templates (README, changelog, scripts de teste e benchmarks)
- Qwen-Fixed-Chat-Templates, do froggeric (a base de onde o Sharp foi derivado)
Ferramentas:
- llama.cpp (opções
--jinjae--chat-template-file) - Documentação de chat templates do transformers
Este texto foi escrito com o auxílio de um modelo LLM privado.
