A IA Virou Faz-Tudo? Meu Experimento com Qwen3-0.6B para Usar Ferramentas!

Olá, pessoal! Aqui é o Lucas Tech, seu amigo entusiasta de tecnologia, e hoje eu tô super animado pra compartilhar um projeto que me deixou de queixo caído! Sabe, a gente sempre fala de IAs conversando, mas e se elas pudessem usar ferramentas de verdade? Tipo, chamar uma função para buscar informações, enviar uma mensagem ou até controlar algo? É exatamente isso que explorei ao ajustar um modelo de linguagem, o Qwen3-0.6B, para se tornar um mestre em invocar ferramentas. Bora nessa jornada comigo pra entender os bastidores dessa magia?

O Desafio: Ensinar a IA a Ser "Faz-Tudo"

Nesse projeto, eu montei um "pipeline" completo de ajuste fino supervisionado. A ideia era pegar o dataset XYZ-Aquila-SFT, que é recheado de conversas onde as IAs já "interagem" com ferramentas, e ensinar o Qwen3-0.6B a fazer o mesmo. Usei as bibliotecas que a gente ama: Hugging Face Transformers, PyTorch e PEFT (que é uma maravilha pra ajustar modelos de forma eficiente!).

A gente começou "espiando" o dataset, entendendo como as conversas e as chamadas de ferramentas eram estruturadas. Depois, o desafio foi "desmontar" essas conversas, extrair exatamente quando e como a IA deveria usar uma ferramenta, e até analisar os padrões. É como dar um manual de instruções detalhado para a IA, sabe?

python
import os, sys, subprocess

… (código de configuração do ambiente e download de dependências) …

print(f"device={DEV} bf16={BF16} torch={torch.version}")
print(f"\n[1] streaming {CFG[‘REPO’]}:{CFG[‘LANG’]} …")
stream = load_dataset(CFG["REPO"], CFG["LANG"], split="train", streaming=True)
RAW: List[Dict[str, Any]] = list(stream.take(CFG["N_STREAM"]))

… (impressão de detalhes da primeira linha do dataset) …

Configurando a Base do Nosso Projeto

Antes de colocar a mão na massa, eu tive que arrumar a casa. Isso incluiu configurar o dataset, o modelo que usaríamos, os parâmetros de treinamento e, claro, onde guardaríamos os resultados. Também foi importante garantir a "reprodutibilidade" do experimento, pra que qualquer um (ou eu mesmo no futuro) possa refazer os passos e obter os mesmos resultados.

Instalei as dependências essenciais do Hugging Face, PEFT e PyTorch, e verifiquei se tinha uma GPU CUDA disponível e se ela suportava o formato de precisão BF16 (que acelera muito o treinamento!). Em seguida, fiz um "streaming" de uma parte do dataset XYZ-Aquila-SFT para dar uma olhada rápida na estrutura e ver como a primeira conversa de uso de ferramenta estava organizada. É tipo quando você abre um jogo novo e dá aquela explorada inicial!

Dissecando as Conversas: Entendendo os Dados

Aqui a coisa ficou mais técnica, mas super interessante! O grande desafio foi "pescar" as chamadas de ferramentas, os blocos de raciocínio e as observações que estavam escondidas dentro de cada conversa. Pensa que a IA, em uma conversa, pode pensar, decidir qual ferramenta usar, e depois relatar o que aconteceu. A gente precisou de ferramentas para extrair esses "pedaços" de informação de forma segura e eficiente.

Transformei cada linha bruta do dataset em um objeto estruturado, que eu chamei de "Trajectory" (trajetória). Isso me permitiu verificar se o número de chamadas de ferramentas que a gente conseguiu extrair batia com o que o dataset "declarava". Por fim, calculei algumas estatísticas gerais do corpus (o conjunto de todos os dados), como a frequência de uso de cada ferramenta, a profundidade das conversas e o tamanho das trajetórias, e até fiz uns gráficos pra visualizar tudo melhor. Entender os dados é o primeiro passo para um treinamento bem-sucedido, certo?

python

… (definição de expressões regulares e funções para extrair chamadas de ferramentas, etc.) …

def parse_row(row: Dict[str, Any]) -> Trajectory:

… (lógica para processar a linha bruta e extrair informações) …

return t

TRAJ = [parse_row(r) for r in RAW]

… (impressão de estatísticas e gráficos de distribuição) …

A Linguagem da IA: Formatando para o Treinamento

Um passo crucial foi converter as definições de ferramentas (que estavam "embutidas" nas mensagens) para um formato mais estruturado. Eu até testei se, ao fazer o processo inverso (reconstruir a mensagem original a partir do formato estruturado), tudo se mantinha intacto.

Mas a parte mais delicada foi renderizar cada "trajetória" no formato ChatML manualmente. Por que manual? Porque o template padrão do Qwen3 para ChatML acaba deletando partes do raciocínio da IA, e eu queria que ela aprendesse com tudo, não só com a resposta final. Assim, pude aplicar o cálculo da perda (que é o que a IA usa para aprender) apenas nos tokens gerados pelo assistente, economizando processamento e focando no que importa. Depois, tokenizei os exemplos, garanti que todos tivessem um tamanho adequado e preparei o PyTorch DataLoader para o treinamento e avaliação.

python

… (funções para extrair e renderizar esquemas de ferramentas) …

tok = AutoTokenizer.from_pretrained(CFG["MODEL_ID"])

… (definição de função para renderizar e mascarar no formato ChatML) …

print(f"\n[5] manual ChatML == chat_template on tool-free probe: {_mine == _theirs}")

… (impressão de informações sobre os exemplos codificados) …

Treinamento e Avaliação: A IA Aprendendo na Prática

Chegamos à parte mais emocionante! Pra avaliar a performance do modelo, criei "probes" de avaliação: cortei as conversas logo antes de a IA precisar fazer uma chamada de ferramenta, e a "resposta correta" era justamente essa chamada. É como um teste surpresa pra ver se ela estava prestando atenção.

Primeiro, carreguei o Qwen3-0.6B e medi o desempenho inicial dele na chamada de ferramentas (o "baseline"). Depois, usei a técnica LoRA (que é tipo uma "turbinada" super eficiente) para adaptar o modelo. O treinamento foi feito usando algumas estratégias avançadas, como acumulação de gradientes, precisão mista (pra ser mais rápido) e agendamento de taxa de aprendizado. Isso tudo ajuda o modelo a aprender de forma mais estável e rápida.

Após o treinamento, avaliei o modelo novamente para comparar as métricas com o baseline e ver o quanto ele melhorou. O resultado? O modelo agora consegue prever chamadas de ferramentas com muito mais precisão! E, claro, salvei o adaptador LoRA treinado e o tokenizador para futuras experimentações. Maneiro, né?

python

… (definição da função build_probes e eval_tool_calls para avaliação) …

PROBES = build_probes(EVAL_TRAJ, CFG["N_EVAL_PROBES"])
results = {}
if CFG["RUN_TRAINING"]:
from peft import LoraConfig, get_peft_model
model = AutoModelForCausalLM.from_pretrained(
CFG["MODEL_ID"], torch_dtype=dtype, attn_implementation="sdpa").to(DEV)

… (lógica de treinamento com LoRA, otimizador, scaler, etc.) …

model.save_pretrained(f"{CFG[‘OUT_DIR’]}/lora_adapter"); tok.save_pretrained(f"{CFG[‘OUT_DIR’]}/lora_adapter")

… (avaliação pós-treinamento e comparação de resultados) …

Finalizando e Guardando o Trabalho

Pra fechar com chave de ouro, exportei cada trajetória processada como um arquivo JSONL estruturado. Isso significa que agora temos registros organizados das mensagens, esquemas de ferramentas, perguntas e respostas, tudo prontinho para ser reutilizado.

Também salvei um relatório JSON completo com estatísticas do corpus, frequência das ferramentas, métricas de trajetória, proporção de tokens supervisionados e os resultados da avaliação. Tudo isso ficou guardado em um diretório configurado, pronto para qualquer análise futura ou para quem quiser dar continuidade a esse trabalho. Um verdadeiro tesouro de dados e modelos!

python
struct_path = f"{CFG[‘OUTDIR’]}/aquila{CFG[‘LANG’]}_structured_tools.jsonl"

… (escrita do arquivo JSONL estruturado) …

stats_path = f"{CFG[‘OUT_DIR’]}/corpus_stats.json"

… (escrita do relatório JSON com estatísticas) …

print(f"\n[9] wrote:\n {struct_path}\n {stats_path}")
print("done.")

Minha Visão

Gente, esse projeto foi muito mais do que apenas código e algoritmos. Ele representa um passo gigante para tornar as IAs não só "boas de papo", mas realmente úteis no mundo real. Ao ensinar um modelo a usar ferramentas de forma eficiente, abrimos portas para assistentes virtuais que podem agir de verdade, não apenas responder. Imagina uma IA que agenda compromissos, faz buscas complexas ou até controla dispositivos, tudo isso de forma autônoma e inteligente!

Preservar a estrutura original das conversas e focar o aprendizado nas respostas do assistente, tudo com a eficiência do LoRA, mostra que dá pra ter resultados incríveis mesmo com recursos mais limitados. Eu vejo um futuro onde as IAs "agenticas" (aquelas que agem e interagem com o ambiente) serão a norma, e pipelines como esse são a fundação para construir essa nova geração de inteligência artificial. É emocionante demais fazer parte disso!

E aí, o que vocês acham dessa evolução das IAs que conseguem usar ferramentas? Vocês veem mais aplicações ou desafios nesse caminho? Deixa seu comentário aqui embaixo!

Referência: Matéria Original

Posts relacionados:

Projeto Genie: Domine a arte dos prompts! Por que ignorar a maioria das ferramentas de IA – e quais quatro eu uso diariamente O uso de ferramentas de vídeo com inteligência artificial como Sora 2 pode apresentar riscos? Opiniões de um especialista jurídico. LLMs mais Rápidos e Leves: Descubra o Segredo da Quantização