datasetMasterLeve — tool calling em pt-BR para o Qwen3-4B-Instruct-2507

Afinamento de roteamento e chamada de ferramenta para o Qwen/Qwen3-4B-Instruct-2507, com as 18 ferramentas reais de uma skill de assistente de voz. Versão leve: a rodada barata — mesmo desenho, 2,6 vezes menos tokens por época. É por onde começar: mede se a mistura move o holdout antes de gastar a GPU no completo.

Tudo em português. Zero linha em inglês, conferido linha por linha nos três arquivos.

Par: luispersegona/datasetMasterPesado tem a mesma receita no outro tamanho.

A proporção vem de uma medição, não de um palpite

Rodei o qwen3-4b-instruct-2507 sem treino contra as 210 falas do holdout, pelo LM Studio:

Chamada exata	46,7%
Nome certo	81,0%
Texto junto da chamada	0 de 210
Chamou ferramenta numa fala de conversa	6 de 58
Não chamou quando devia	1
Latência	mediana 6.639 ms, p90 11.573 ms

Por número de ferramentas no gabarito:

Ferramentas	Casos	Exato	Nome certo
0 (conversa)	58	90%	90%
1	69	45%	99%
2	3	100%	100%
3	56	7%	68%

O formato já está certo (zero texto colado na chamada) e conversa já está quase resolvida (90%). Então este dataset não gasta linha nessas duas coisas. Gasta nos dois erros reais:

1. Argumento, não roteamento. Com uma ferramenta o nome sai certo em 99% e a chamada inteira em 45%. O que falha é o campo condicional: omite tipo: "noticias" numa fala de notícia (no dado de origem, 233 de 233 levam esse campo), devolve ler_lista({}) em vez de preencher lista, perde hora ou dia no lembrete. → bloco argumento, 16%.
2. Fala com 3 ferramentas: trunca na primeira. Nome certo em 68%, e o padrão de erro é emitir uma chamada e parar. → lote3 22%, mais resultado e cadeia.

Teto de 3 chamadas por turno. Não existe bloco de 4: é decisão do projeto, e o runtime corta no mesmo número (MAX_PARALLEL_CALLS em lambda/llm.js). O que passar fica para a rodada seguinte. Distribuição: 0 → 18,0%, 1 → 46,7%, 2 → 13,3%, 3 → 22,0%. Zero linhas com 4 chamadas.

Blocos

Bloco	%	O que ensina
argumento	16%	o campo condicional de cada ferramenta, onde o modelo erra
chamada	18%	uma chamada, caso geral
lote2 / lote3	10% / 22%	2 e 3 chamadas num turno
resultado	8%	chamada → <tool_response> → resposta curta: ensina a parar
cadeia	5%	uma linha por rodada, para a fala com duas escritas
texto	7%	conversa em pt-BR com as 18 na mesa: não chame
nocall_pt	7%	a mesma lição com outro vocabulário (UltrachatBR)
conversa_pt	4%	conversa e conhecimento geral (sharegpt-portuguese)
anti-fuga	3%	fala embrulhada em meta-instrução, saída ainda é só a chamada

O bloco argumento é seleção, não geração: pega as falas de uma ferramenta cujo gabarito já validado exercita o campo que o modelo esquece. Conferido no arquivo publicado: 100% das linhas de buscar_web levam tipo, 100% das de ler_lista levam lista.

Prompt de sistema: 60 variações, de propósito

Cada linha leva um system sorteado entre 60 variações (237 a 1.023 caracteres): nomes diferentes para a assistente — ou nenhum —, tamanhos, tom, ordem das regras, data, nome do usuário. Nenhuma passa de 2% das linhas.

O que não varia é o invariante: português do Brasil, ferramenta quando a fala pede ação, texto quando é conversa, nada escrito depois da chamada. Um dataset com um prompt só ensina "este texto exato → chame ferramenta" e degrada com qualquer outro — inclusive o que a sua aplicação manda.

O teste.jsonl mantém o prompt original dele, intocado.

Formato

O Qwen3 põe um objeto JSON dentro de <tool_call> (diferente do Qwen3.5, que usa <function=nome><parameter=k>). O dataset guarda a chamada estruturada, e quem renderiza é o template:

{
  "tools": [ { "type": "function", "function": { "name": "...", "description": "...", "parameters": {} } } ],
  "messages": [
    {"role": "system", "content": "Você é a Alexa..."},
    {"role": "user", "content": "me diz o clima em Manaus e a cotação do dólar"},
    {"role": "assistant", "content": "", "tool_calls": [
      {"type": "function", "function": {"name": "clima", "arguments": {"cidade": "Manaus"}}},
      {"type": "function", "function": {"name": "cotacao", "arguments": {"moedas": ["dolar"]}}}
    ]}
  ],
  "meta": {"bloco": "lote2", "origem": "composto/clima+cotacao"}
}

Renderizado pelo template do Qwen3-4B-Instruct-2507:

<tool_call>
{"name": "clima", "arguments": {"cidade": "Manaus"}}
</tool_call>

content é "" em toda linha com tool_calls. meta é só rastreio; descarte ao treinar.

O caminho sem raciocínio

O qwen3-4b-instruct-2507 vem com reasoning ligado por padrão. Medido: 661 ms sem raciocínio contra 2.793 ms com, e o raciocínio sai em inglês. Num turno de voz de 8 segundos isso não cabe.

Com enable_thinking=False, o template pré-preenche <think>\n\n</think> no prompt de geração, então o modelo escreve só a resposta. Treine assim e sirva com reasoning_effort: "none": é o mesmo caminho dos dois lados.

Splits e custo

Arquivo	Linhas	Tamanho
treino.jsonl	10.826	76,7 MB
validacao.jsonl	2.562	20,6 MB
teste.jsonl	210	3,2 MB

Tokens por linha renderizada, no tokenizador do Qwen3-4B-Instruct-2507 (amostra de 2.000): mediana 1.994, p90 2.744, p99 4.930, máximo 5.033. Uma época custa cerca de 23 M tokens.

teste.jsonl é o holdout de 210 falas, com zero sobreposição com treino e validação. A validação tem a mesma mistura de blocos do treino, então a eval_loss representa o conjunto todo.

Como treinar

from unsloth import FastLanguageModel
model, tok = FastLanguageModel.from_pretrained(
    "Qwen/Qwen3-4B-Instruct-2507", max_seq_length=5632, load_in_16bit=True)
tok = getattr(tok, "tokenizer", tok)
texto = tok.apply_chat_template(linha["messages"], tools=linha["tools"],
                                tokenize=False, enable_thinking=False)

max_seq_length=5632: cobre o máximo (5.033) com folga, corte de 0%. O catálogo das 18 ferramentas sozinho custa 4.556 tokens neste template, então 8% das linhas (as que levam as 18, como em produção) passam de 4.800; o resto fica perto de 2.000.

Numa RTX 3060 12 GB, batch 2 com acumulação 4. Se estourar, batch 1 com acumulação 8.

O script de treino do projeto (treino/unsloth/treinar.py) já lê este formato, põe a perda em todo turno de assistente, mascara system, user e <tool_response>, e avalia com um parser do formato nativo do Qwen3.

Qualidade conferida

• todo tool_calls aponta para ferramenta presente no tools daquela linha;
• content vazio em toda linha com chamada; nenhuma linha termina fora do assistant;
• no máximo 4 chamadas e no máximo 1 escrita por turno;
• nenhuma tag vazada em nenhum content;
• nenhuma fala do treino aparece no holdout;
• nenhuma fala se repete mais de 2 vezes;
• nenhum texto em inglês ou francês.

Procedência

Falas de uma ferramenta: 19.094 únicas, geradas por modelo e validadas contra o schema real das 18 ferramentas. Falas de 2, 3 e 4: compostas a partir dessas, juntando pedidos simples com conectivo — o gabarito é a concatenação de gabaritos já validados, nenhum argumento inventado.

Resultados de ferramenta: reaproveitados dos já observados para aquela mesma ferramenta. O resultado não casa com os argumentos daquela linha — é entrada mascarada na perda, que o modelo lê e não gera.

Fonte de terceiro	Licença	Uso
recogna-nlp/UltrachatBR	MIT	bloco nocall_pt
FreedomIntelligence/sharegpt-portuguese	Apache 2.0	bloco conversa_pt

As duas são tradução automática do inglês: português correto, construção de texto traduzido. A fala natural vem dos dados próprios. Licença other porque mistura MIT, Apache 2.0 e dado próprio.