Fine-tuning de LLMs para criar personalidades de IA: tutorial em Python (2026)

Pedes ao ChatGPT que escreva «com a tua voz» e ele solta três parágrafos genéricos. Colas-lhe um prompt de 800 palavras com exemplos e regras, e à quarta resposta já esqueceu metade. O problema não é o modelo ser mau. É que estás a pedir à forma algo que se resolve nos pesos.

Isso é o fine-tuning: deixar de explicar ao modelo como falar em cada prompt e ensinar-lho de uma vez, treinando-o com exemplos do teu estilo até a voz lhe sair por defeito. É a ferramenta certa para construir uma personalidade de IA própria. E em 2026 já não precisas de um cluster nem de um mestrado: cabe numa única GPU. Vamos montá-lo sem fumaça.

O que é o fine-tuning (e quando SIM e quando NÃO)

Um modelo base como o Llama ou o Qwen já vem pré-treinado com meia internet. O fine-tuning não parte do zero: pega nesse modelo e continua a treiná-lo com os teus exemplos para o inclinar para um comportamento concreto. Não é magia, é ajustar pesos.

A ideia-chave que quase ninguém te diz claramente: o fine-tuning é para a FORMA, não para os dados. Serve para mudar como soa, como estrutura a saída e que vocabulário usa. Não serve para lhe meter informação que muda todas as semanas — isso escapa por uma lacuna de conhecimento que o fine-tuning cobre mal.

Os modelos de ponta de 2026 continuam a falhar em três coisas que o fine-tuning resolve pela raiz:

• Esquema de saída exato: que devolva sempre o mesmo JSON, o mesmo formato, sem se desviar.
• Vocabulário de domínio estreito: o jargão do teu setor, os teus termos, as tuas convenções.
• Voz de marca: aquele tom concreto que com prompts se dilui de resposta em resposta.

Precisamente o terceiro ponto é o coração de criar uma personalidade de IA. Uma voz consistente não se sustenta à custa de prompts cada vez mais longos; treina-se uma vez e fica.

Quando SIM compensa:

• Tens uma tarefa estável com uma saída previsível (um tom, um formato).
• Já testaste prompting e RAG e o modelo estagnou.
• Tens (ou consegues reunir) mais de 500 bons exemplos coerentes.

Quando NÃO:

• Precisas que o modelo saiba factos concretos e atualizados → isso é RAG.
• O teu caso muda a toda a hora → retreinar todas as semanas não escala.
• Ainda não testaste a fundo um bom prompt → começa por aí, é grátis e reversível.

O processo de fine-tuning, num relance

Antes do código, o mapa. Estes são os seis passos que vais percorrer sempre, independentemente da ferramenta:

Repara que treinar é só um passo de seis, e nem sequer o mais importante. Os passos 1 e 2 — os dados — decidem 80 % do resultado. Vamos repeti-lo até ao aborrecimento.

Passo a passo com código (Python + Unsloth)

Vamos usar o Unsloth, que em 2026 é a via mais rápida para treinar numa única GPU: os seus kernels otimizados reduzem o uso de memória até 74 % e aceleram o treino entre 2 e 5 vezes face ao Hugging Face Transformers em cru. Funciona na GPU gratuita do Google Colab. Se preferes pipelines por config em YAML sem escrever Python, o Axolotl faz o mesmo com um ficheiro de configuração; e por baixo, ambos se apoiam no ecossistema Hugging Face.

1. Instalar o ambiente

pip install unsloth
pip install --no-deps trl peft accelerate bitsandbytes

2. Carregar o modelo base em 4 bits (QLoRA)

Carregamos um modelo base pequeno quantizado para 4 bits para que caiba em pouca VRAM, e ligamos-lhe os adaptadores LoRA.

from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
  model_name = "unsloth/Meta-Llama-3.1-8B-Instruct",
  max_seq_length = 2048,
  load_in_4bit = True,   # QLoRA: quantiza o base para 4 bits
)

model = FastLanguageModel.get_peft_model(
  model,
  r = 16,                # rank do adaptador LoRA (8-64 é o normal)
  lora_alpha = 16,
  target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
)

3. Treinar

Com o dataset já formatado (vemo-lo na secção seguinte), o treino é padrão. Poucas épocas: com dados limpos, 1 a 3 passagens bastam e sobretreinar é um risco bem real.

from trl import SFTTrainer
from transformers import TrainingArguments

trainer = SFTTrainer(
  model = model,
  tokenizer = tokenizer,
  train_dataset = dataset,         # o teu JSONL formatado
  dataset_text_field = "text",
  max_seq_length = 2048,
  args = TrainingArguments(
      per_device_train_batch_size = 2,
      gradient_accumulation_steps = 4,
      num_train_epochs = 2,
      learning_rate = 2e-4,
      output_dir = "outputs",
  ),
)

trainer.train()

4. Inferir e exportar

Testas a personalidade acabada de treinar e, se convencer, exporta-la para GGUF para a correres em local com o Ollama.

FastLanguageModel.for_inference(model)
inputs = tokenizer(["O que achas do hype da IA?"], return_tensors="pt").to("cuda")
print(tokenizer.decode(model.generate(**inputs, max_new_tokens=128)[0]))

# Exportar para Ollama / llama.cpp
model.save_pretrained_gguf("a-minha-personalidade", tokenizer, quantization_method="q4_k_m")

Os dados: o dataset que define a tua personalidade

Aqui está o verdadeiro trabalho. O formato padrão de 2026 para fine-tuning supervisionado (SFT) é JSONL com um array messages ao estilo ChatML: cada linha é uma conversa. Funciona direto no Unsloth, no Axolotl e no TRL sem conversões estranhas.

{"messages": [
{"role": "system", "content": "És o Blackdark: direto, prático, anti-fumaça. Nada de enchimento."},
{"role": "user", "content": "Compensa pagar o ChatGPT Plus?"},
{"role": "assistant", "content": "Depende de quanto o usas a sério. Se abres a app duas vezes por semana, não. Se o usas todos os dias para trabalhar, os 20 por mês amortizam-se logo no primeiro dia. O que não vale é pagá-lo por via das dúvidas."}
]}

As regras que de facto importam no dataset:

• Coerência de voz: cada resposta assistant tem de soar como a personalidade que queres. Um só exemplo fora de tom suja a aprendizagem.
• O system fixa a personagem: usa-o igual em todos os exemplos. É a âncora da identidade.
• Qualidade > quantidade: para tom e estilo, 500 a 2.000 exemplos curados rendem mais do que 50.000 ruidosos. Abaixo de cerca de 100 linhas, nem tentes.
• Variedade de situações: cobre diferentes tipos de pergunta para que a voz aguente para lá dos exemplos vistos.

Custo e ferramentas, sem surpresas

A boa notícia: para um modelo de 7-8 B com QLoRA, o cálculo é quase grátis. Cabe em cerca de 8 GB de VRAM, por isso treinas na GPU gratuita do Colab ou alugas uma GPU na nuvem por umas poucas horas. O gasto real não está em treinar, está em preparar o dataset: é aí que se vai o tempo.

As três ferramentas que dominam em 2026:

• Unsloth — a opção se vais numa única GPU e te importa a velocidade. Kernels otimizados, menos memória, mais rápido. A que usámos aqui.
• Axolotl — pipelines definidos num YAML. Escolhes modelo, dataset, método e hiperparâmetros num ficheiro e lanças com um comando, sem escrever Python. Ideal para processos repetíveis.
• Hugging Face (Transformers + PEFT + TRL) — a base sobre a qual as duas anteriores assentam. Mais controlo, mais atrito.

Sobre o método: o LoRA treina apenas 0,1 a 1 % dos parâmetros com qualidade próxima de retreinar todo o modelo. O QLoRA acrescenta quantização a 4 bits e consegue cerca de 90 % da qualidade do fine-tuning completo, a um custo de hardware muito menor. Para criar uma personalidade em casa, o QLoRA é o ponto ideal.

Erros típicos que arruínam o resultado

• Querer meter dados com fine-tuning. O erro nº 1. Se precisas que o modelo saiba factos atualizados, isso é RAG, não fine-tuning. Misturar os dois conceitos leva a modelos que alucinam com confiança.
• Dataset sujo ou incoerente. Exemplos fora de tom, formatos inconsistentes, respostas medíocres. O modelo aprende exatamente o que lhe dás, defeitos incluídos.
• Sobretreinar. Épocas a mais e o modelo memoriza o dataset em vez de generalizar a tua voz. Começa com 1 a 3 passagens e mede.
• Não avaliar com casos novos. Se só testas com exemplos que estavam no treino, enganas-te a ti mesmo. Avalia com perguntas que o modelo nunca viu.
• Saltar o prompting e o RAG. Se não esgotaste o barato e reversível, estás a resolver com fine-tuning algo que um bom prompt resolvia em cinco minutos.

Para quem é o fine-tuning?

Não é para toda a gente, e ainda bem que assim é.

Interessa-te se: constróis um produto ou agente com uma personalidade de marca própria e precisas que a voz seja idêntica em cada resposta; tens um formato de saída que o modelo base não respeita à primeira; trabalhas num domínio com jargão próprio; ou queres reduzir o custo por pedido face a prompts enormes que repetes mil vezes por dia.

Não te interessa se: o teu problema é de conhecimento e não de forma (aí manda o RAG); ainda não espremeste um bom prompt de sistema; ou o teu caso é tão pontual que montar o pipeline custa mais do que o benefício.

A pergunta honesta não é «faço fine-tuning?», mas «o que me falha é a forma ou os dados?». Se é a forma — o tom, a voz, o formato —, o fine-tuning é a ferramenta certa e, com QLoRA e um dataset limpo, está ao alcance de uma única GPU. Se são os dados, poupa-te ao treino e monta um RAG. E se ainda não sabes, volta ao prompt: quase sempre a resposta estava lá.