Como Fazer Fine-Tuning de um LLM: Métodos, Frameworks e Código Passo a Passo [2026]

Fazer fine-tuning de um LLM significa pegar num modelo pré-treinado e treiná-lo com os seus dados específicos para que este execute a sua tarefa melhor do que qualquer prompt conseguiria alcançar. A barreira de entrada desmoronou: QLoRA + Unsloth permitem agora fazer fine-tuning de um modelo de 8 mil milhões de parâmetros numa GPU doméstica de 12 GB por menos de 1€ em custos de cloud.

Este guia abrange todo o percurso: quando fazer fine-tuning (em vez de RAG ou engenharia de prompts), qual o método e framework a escolher, como preparar o seu conjunto de dados, um tutorial do Llama 3 pronto para copiar e colar, cenários de custos reais e implementação.

Fine-Tuning Num Relance

Antes de se comprometer com qualquer coisa, eis o panorama geral:

Agora, vamos descobrir se o fine-tuning é realmente a decisão certa para o seu projeto.

Quando Deve Fazer Fine-Tuning de um LLM? (vs. RAG vs. Engenharia de Prompts)

Esta é a questão que a maioria dos programadores ignora, custando-lhes semanas de esforço desperdiçado. O fine-tuning é poderoso, mas nem sempre é a ferramenta certa. Eis um framework para decidir.

A decisão resume-se ao que está a tentar alterar. Eis cenários reais:

Se está a escolher a stack de IA certa para o seu SaaS, este framework de decisão é o primeiro passo. Muitas equipas constroem pipelines RAG complexos quando um fine-tune com 500 exemplos lhes daria resultados mais consistentes com menor latência.

Veredito: Faça fine-tuning quando precisar que o modelo se comporte de forma diferente de maneira consistente, e não apenas que saiba coisas diferentes. Se só precisa de novo conhecimento, o RAG é mais barato e fácil de manter. Se precisa de ambos, opte pelo híbrido.

Como Funciona o Fine-Tuning de LLM? Completo vs. LoRA vs. QLoRA

Existem três abordagens principais, que diferem drasticamente em requisitos de hardware, custo e qualidade. Compreender as compensações evita que invista em excesso ou entregue resultados insuficientes.

Fine-Tuning Completo (Quando o Orçamento Não É Problema)

O fine-tuning completo atualiza todos os parâmetros do modelo. Produz os melhores resultados possíveis, mas requer recursos enormes, aproximadamente 100+ GB de VRAM para um modelo de 7B (precisa de armazenar o modelo, estados do otimizador e gradientes simultaneamente). Isto é território de clusters H100. A menos que esteja num laboratório bem financiado, ignore isto.

LoRA: A Revolução PEFT

LoRA (Adaptação de Baixo Rank) congela o modelo base e adiciona pequenas matrizes treináveis chamadas adaptadores. Em vez de atualizar diretamente uma matriz de pesos massiva W, o LoRA decompõe a atualização em duas pequenas matrizes A e B, onde o rank r é muito menor que a dimensão do modelo. Resultado: treina-se cerca de 1-2% dos parâmetros originais mantendo 98-99% da qualidade do fine-tuning completo.

A biblioteca peft da Hugging Face é a implementação padrão. Os adaptadores LoRA têm tipicamente 50-200 MB, minúsculos comparados com o modelo completo.

QLoRA: Fine-Tuning Para Todos

QLoRA leva o LoRA um passo adiante. Carrega o modelo base em precisão de 4 bits usando um tipo de dados especial chamado NormalFloat4 (NF4), e depois aplica adaptadores LoRA por cima. A quantização a 4 bits reduz o uso de VRAM em mais ~25% comparado com o LoRA padrão, preservando uma qualidade quase idêntica.

É isto que torna o fine-tuning acessível. Um modelo de 7B que precisa de 100+ GB para fine-tuning completo cabe em 12 GB com QLoRA.

Veredito: Para 90% dos programadores, QLoRA é a escolha certa. A diferença de qualidade face ao fine-tuning completo é negligenciável para a maioria das tarefas, e a poupança de hardware é massiva. Comece por aqui e só escale se as suas métricas de avaliação o exigirem.

Qual Framework de Fine-Tuning Deverá Usar em 2026?

Escolher um framework importa mais do que a maioria das pessoas percebe. O certo poupa horas de configuração e acelera significativamente o treino. Eis como as quatro opções principais se comparam.

Eis a recomendação rápida:

• Primeiro fine-tune? Use Unsloth. Treino mais rápido, configuração mais fácil, cadernos Colab gratuitos para começar imediatamente.
• Precisa de uma UI web sem código? Use LLaMA-Factory. A sua GUI LLaMA-Board permite configurar e lançar o treino a partir de um navegador.
• A fazer alinhamento (RLHF, DPO, GRPO)? Use TRL. É o padrão da Hugging Face para treino baseado em preferências, e a v0.15.0 (março de 2026) adicionou suporte nativo a GRPO.
• A executar pipelines de produção em multi-GPU? Use Axolotl. Configurações baseadas em YAML tornam as experiências reprodutíveis e auditáveis.

Um truque útil: Unsloth e LLaMA-Factory podem ser combinados. O LLaMA-Factory suporta Unsloth como backend de treino, dando-lhe a conveniência da GUI com as otimizações de velocidade do Unsloth. Equipas a construir agentes de IA que usam modelos com fine-tuning começam frequentemente com Unsloth para iteração rápida, passando depois para Axolotl para reprodutibilidade em produção.

Como Preparar um Conjunto de Dados para Fine-Tuning?

A qualidade dos dados é o fator individual mais importante para o sucesso do fine-tuning. Um conjunto de dados bem curado com 500 exemplos superará quase sempre um conjunto ruidoso de 10.000 exemplos.

Formatos de Conjunto de Dados

Os dois formatos dominantes são chat (compatível com OpenAI) e instrução (estilo Alpaca). Eis como cada um se apresenta em formato JSONL:

Formato chat (recomendado para a maioria dos casos de uso):

{"messages": [{"role": "system", "content": "You are a customer support agent for Acme Inc. Be helpful, concise, and always reference the user's order number."}, {"role": "user", "content": "I ordered a laptop 3 days ago (order #4821) and it still says processing."}, {"role": "assistant", "content": "I can see order #4821 is currently in our warehouse being prepared for shipment. Laptops typically ship within 3-5 business days. You should receive a tracking number by tomorrow. Would you like me to flag this for priority processing?"}]}
{"messages": [{"role": "system", "content": "You are a customer support agent for Acme Inc. Be helpful, concise, and always reference the user's order number."}, {"role": "user", "content": "Can I return my keyboard? Order #3019, bought it last week."}, {"role": "assistant", "content": "Absolutely! Order #3019 is within our 30-day return window. I'll email you a prepaid return label right now. Once we receive the keyboard, your refund will process within 2-3 business days."}]}
{"messages": [{"role": "system", "content": "You are a customer support agent for Acme Inc. Be helpful, concise, and always reference the user's order number."}, {"role": "user", "content": "My monitor arrived cracked. Order #5573."}, {"role": "assistant", "content": "I'm sorry about that! For order #5573, I'm initiating an immediate replacement shipment -- no need to return the damaged unit. The new monitor will ship today with express delivery. You'll get a tracking email within the hour."}]}

Formato instrução (estilo Alpaca):

{"instruction": "Summarize the following customer complaint in one sentence.", "input": "I've been waiting 2 weeks for my refund and nobody responds to my emails. This is the worst customer service I've ever experienced.", "output": "Customer is frustrated by a 2-week delay in receiving their refund and lack of email response from support."}
{"instruction": "Classify the sentiment of this review.", "input": "The product works fine but shipping took forever.", "output": "Mixed (positive product, negative shipping)"}

Diretrizes de Tamanho do Conjunto de Dados

De quantos dados precisa realmente? Depende da complexidade da tarefa:

1. 50-100 exemplos, prova de conceito, suficiente para testar se o fine-tuning ajuda
2. 500-1.000 exemplos, útil para a maioria das tarefas únicas (classificação, extração, formatação)
3. 5.000-10.000 exemplos, resultados de qualidade de produção para tarefas complexas
4. 10.000+ exemplos, retornos decrescentes a menos que a sua tarefa tenha alta variabilidade

Lista de Verificação de Qualidade de Dados

Antes do treino, valide o seu conjunto de dados contra estes critérios:

• Formatação consistente em todos os exemplos (mesmo prompt de sistema, mesma estrutura de saída)
• Exemplos diversos cobrindo casos extremos e modos de falha
• Sem contradições (não ensine o modelo a dizer "sim" e "não" para o mesmo padrão de entrada)
• Distribuição equilibrada de tipos de saída (se fizer classificação, não tenha 90% dos exemplos numa classe)
• Remova entradas duplicadas ou quase duplicadas

Dica pro: Use GPT-4 ou Claude para gerar dados sintéticos de treino iniciais, refinando depois com revisão humana. 500 exemplos sintéticos de alta qualidade superam frequentemente 5.000 exemplos reais ruidosos. O guia de fine-tuning da Meta recomenda esta abordagem para inicializar conjuntos de dados.

Passo a Passo: Fine-Tune do Llama 3 8B com QLoRA e Unsloth

Eis o guia completo. Cada bloco de código está pronto para copiar e colar; pode executá-lo num caderno Google Colab gratuito ou em qualquer máquina com 12+ GB de VRAM.

Passo 1: Instalar Unsloth

pip install unsloth

É tudo. O Unsloth gere todas as dependências (transformers, peft, trl, bitsandbytes) automaticamente.

Passo 2: Carregar o Modelo Base em 4 bits

from unsloth import FastLanguageModel

# Load Llama 3.1 8B in 4-bit quantization
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Meta-Llama-3.1-8B-bnb-4bit",
    max_seq_length=2048,
    load_in_4bit=True,
)

Isto descarrega o modelo quantizado a 4 bits (~4 GB) e carrega-o na memória da GPU. Numa RTX 3060 (12 GB), terá margem suficiente para o treino.

Passo 3: Configurar Adaptadores LoRA

# Add LoRA adapters to the model
model = FastLanguageModel.get_peft_model(
    model,
    r=16,                # LoRA rank -- 16 is the sweet spot for most tasks
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                     "gate_proj", "up_proj", "down_proj"],
    lora_alpha=16,       # Scaling factor (usually equal to r)
    lora_dropout=0,      # Unsloth optimizes for 0 dropout
    bias="none",
)

Com r=16, está a treinar cerca de 40 milhões de parâmetros de 8 mil milhões, menos de 0,5% do modelo. Essa é a magia do LoRA.

Passo 4: Carregar o Seu Conjunto de Dados

from datasets import load_dataset

# Load your JSONL dataset from Hugging Face Hub or local file
dataset = load_dataset("json", data_files="train.jsonl", split="train")

# Format into chat template
def format_chat(example):
    text = tokenizer.apply_chat_template(
        example["messages"],
        tokenize=False,
        add_generation_prompt=False,
    )
    return {"text": text}

dataset = dataset.map(format_chat)

Isto pega no formato chat JSONL da secção anterior e aplica o template de chat do Llama 3. O tokenizer trata de todos os tokens especiais (<|begin_of_text|>, <|eot_id|>, etc.).

Passo 5: Configurar e Executar o Treino

from trl import SFTTrainer
from transformers import TrainingArguments
from unsloth import is_bfloat16_supported

trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=2048,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,    # Effective batch size = 8
        warmup_steps=5,
        max_steps=60,                     # Adjust based on dataset size
        learning_rate=2e-4,               # Standard for QLoRA
        fp16=not is_bfloat16_supported(),
        bf16=is_bfloat16_supported(),
        logging_steps=1,
        output_dir="outputs",
        seed=42,
    ),
)

# Start training
trainer.train()

Hiperparâmetros chave a compreender:

• Taxa de aprendizagem (2e-4): O padrão para QLoRA. Reduza (2e-5) se vir o modelo a esquecer capacidades gerais.
• Tamanho do lote (2) x acumulação de gradiente (4): Tamanho efetivo do lote de 8. Aumente a acumulação de gradiente se a sua GPU ficar sem memória.
• max_steps (60): Para 500 exemplos, isto é aproximadamente 1 época. Comece com 1-3 épocas e observe a perda de validação.
• Rank r (16): Menor (4-8) para tarefas simples, maior (32-64) para tarefas complexas. 16 é um padrão seguro.

Passo 6: Guardar e Testar

# Save the LoRA adapters (small -- ~50-200 MB)
model.save_pretrained("my-fine-tuned-model")
tokenizer.save_pretrained("my-fine-tuned-model")

# Quick inference test
FastLanguageModel.for_inference(model)
inputs = tokenizer(
    [tokenizer.apply_chat_template(
        [{"role": "user", "content": "I need to return order #7742"}],
        tokenize=False,
        add_generation_prompt=True,
    )],
    return_tensors="pt",
).to("cuda")

outputs = model.generate(**inputs, max_new_tokens=256)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

É toda a pipeline. Numa RTX 4090 com Unsloth, treinar 500 exemplos demora cerca de 15-30 minutos. Num T4 Colab gratuito, espere 1-2 horas.

E Quanto ao Fine-Tuning Baseado em API? (OpenAI, Google, Mistral)

Nem todos querem gerir GPUs. Os fornecedores de API permitem fazer fine-tuning através de um fluxo simples de upload e treino. Eis como se comparam com executar localmente.

Quando o fine-tuning por API faz sentido: Precisa de iterar rapidamente, o seu conjunto de dados é pequeno, não quer gerir infraestrutura ou precisa especificamente de um modelo fechado como o GPT-4o.

Quando o fine-tuning local vence: A privacidade dos dados importa (saúde, finanças, jurídico), está a treinar frequentemente, quer possuir e exportar os pesos ou está a otimizar custos em escala.

Veredito: O fine-tuning por API é o caminho mais rápido para uma prova de conceito. O fine-tuning local é o caminho mais barato para a produção. A maioria das equipas faz protótipos numa API, passando depois para Unsloth local assim que valida a abordagem.

Quanto Custa Fazer Fine-Tuning de um LLM?

A narrativa de que "o fine-tuning é caro" está presa em 2023. Eis o que realmente custa hoje.

A curva de custos achata-se rapidamente. Uma startup a fazer fine-tuning de um modelo 8B no RunPod gasta menos no treino do que num único café. Mesmo o cenário de produção 70B fica abaixo dos 30€ -- isso é o orçamento de almoço diário de um mês de um programador júnior.

Fornecedores de GPU na cloud vale a pena comparar: RunPod (melhores preços spot), Lambda (H100s on-demand fiáveis), Vast.ai (mais barato mas qualidade variável) e Modal (serverless, pagamento por segundo).

O gráfico acima mostra porque é que o QLoRA mudou o jogo. Um modelo 7B que exigia um cluster multi-GPU para fine-tuning completo cabe agora numa GPU de portátil. O modelo 70B passa de "apenas cloud" para uma única A100.

Veredito: Pode fazer fine-tuning de um modelo 8B de qualidade de produção por menos de 1€. A barreira de custo para o fine-tuning desapareceu. O custo real é o tempo de preparação dos dados.

Como Avaliar um Modelo com Fine-Tuning?

O treino é apenas metade do trabalho. Sem uma avaliação adequada, não consegue saber se o seu modelo com fine-tuning melhorou realmente, ou se apenas memorizou os seus dados de treino.

Métricas Automatizadas

Acompanhe estas durante e após o treino:

• Perda de treino / perplexidade: Deve diminuir constantemente e depois estabilizar. Se cair para perto de zero, está a sofrer overfitting.
• Métricas específicas da tarefa: Precisão (classificação), BLEU/ROUGE (sumarização), correspondência exata (extração), F1 (multi-etiqueta). Escolha a métrica que corresponde à sua tarefa.

Avaliação Humana

Os números não captam tudo. Para tarefas generativas:

• Testes A/B: Mostre a saída do modelo base vs. fine-tuned lado a lado. Peça a 3-5 avaliadores para escolherem a melhor resposta em 50+ exemplos. Acompanhe a taxa de vitória.
• Classificação em escala Likert: Classifique as saídas em relevância (1-5), precisão (1-5) e tom (1-5). Calcule a melhoria média sobre o modelo base.

Verificação de Esquecimento Catastrófico

Esta é a que a maioria dos programadores ignora. Após o fine-tuning, execute o seu modelo num benchmark geral como MMLU ou HellaSwag. Se as pontuações caírem mais de 2-3 pontos, o seu modelo perdeu demasiado conhecimento geral. A solução: reduza a taxa de aprendizagem, reduza as épocas ou mude para LoRA (que congela os pesos base).

Regra prática: Reserve sempre 10-20% do seu conjunto de dados como conjunto de teste. Nunca avalie nos dados de treino, isso não lhe diz nada sobre o desempenho no mundo real.

Como Implementar um Modelo com Fine-Tuning?

O treino está feito. Agora precisa de o servir. A maioria dos guias ignora completamente esta parte.

Passo 1: Fundir Adaptadores LoRA

Se usou LoRA ou QLoRA, funda os adaptadores de volta no modelo base para inferência:

# Merge adapters into base model
model.merge_and_unload()
model.save_pretrained("merged-model")
tokenizer.save_pretrained("merged-model")

Passo 2: Escolher o Seu Caminho de Implementação

Desenvolvimento local e testes, Ollama:

# Convert to GGUF format (Ollama's native format)
python llama.cpp/convert_hf_to_gguf.py merged-model --outfile model.gguf --outtype q4_k_m

# Create an Ollama model
ollama create my-fine-tuned-model -f Modelfile
ollama run my-fine-tuned-model

Servidor de produção, vLLM:

# Start an OpenAI-compatible API server
python -m vllm.entrypoints.openai.api_server \
    --model merged-model \
    --host 0.0.0.0 \
    --port 8000

Serverless (zero infraestrutura): Carregue o seu modelo para Together AI, Fireworks ou Modal. Obtém um endpoint de API sem gerir servidores. O custo escala com o uso.

Avançado: Servidor Multi-Adaptador

Eis um padrão que mais equipas deveriam usar: mantenha um modelo base carregado na memória e troque adaptadores LoRA por pedido. Poderia servir um adaptador de suporte ao cliente, um de revisão de código e um de sumarização, tudo a partir de uma única GPU. O vLLM suporta isto nativamente com a flag --enable-lora.

Pronto para implementar? Veja as nossas Melhores Ferramentas e Plataformas de Fine-Tuning de LLM [em breve] para uma comparação mais profunda das opções de implementação.

Quais São os Erros Mais Comuns no Fine-Tuning?

Depois de ajudar equipas a depurar dezenas de execuções de fine-tuning, estes são os erros que surgem repetidamente.

1. Overfitting em pequenos conjuntos de dados. Treina durante 10 épocas com 200 exemplos, a perda de treino atinge perto de zero e o modelo repete textualmente os seus dados de treino. Solução: máximo 1-3 épocas, use um conjunto de validação e observe a lacuna entre a perda de treino e a perda de avaliação.

2. Esquecimento catastrófico. O modelo acerta na sua tarefa específica mas já não consegue manter uma conversa básica. Solução: use LoRA/QLoRA (congela pesos base), mantenha taxas de aprendizagem baixas (2e-5 para fine-tuning completo, 2e-4 para QLoRA) e avalie em benchmarks gerais antes de implementar.

3. Qualidade de dados lixo. Formatação inconsistente, contradições entre exemplos ou duplicados. O modelo aprende o ruído. Solução: limpe os seus dados antes do treino. Sempre. Gastar mais tempo na curadoria de dados do que no ajuste de hiperparâmetros.

4. Começar com um modelo demasiado grande. As equipas saltam para 70B porque "maior é melhor", depois não conseguem suportar os custos de GPU. Solução: comece com 8B. Se 8B com bons dados não resolver a sua tarefa, 70B com os mesmos dados provavelmente também não. Melhore primeiro a qualidade dos dados, depois o tamanho do modelo.

5. Sem pipeline de avaliação. Treinar sem um conjunto de teste reservado, depois implementar baseado em "vibes". Solução: divida os seus dados 80/10/10 (treino/val/teste) antes de começar. Compare com o modelo base em cada exemplo de teste.

6. Taxa de aprendizagem demasiado alta. Destrói o conhecimento pré-treinado nos primeiros passos. O modelo produz disparates. Solução: comece em 2e-4 para QLoRA, 2e-5 para fine-tuning completo. Se as saídas degradarem, reduza.

Como a Techsy Aborda o Fine-Tuning de LLM

Na Techsy, seguimos um caminho de escalonamento rigoroso para cada projeto de IA: engenharia de prompts primeiro, RAG em segundo, fine-tuning apenas quando os dados provam que é necessário. A maioria dos projetos de clientes não requer realmente fine-tuning; prompts bem elaborados ou uma pipeline RAG resolvem o problema com menor custo e complexidade.

Quando o fine-tuning é a decisão certa, eis o nosso processo:

1. Auditoria de dados, revemos os dados do cliente quanto à qualidade, cobertura e formatação. Se não tivermos exemplos suficientes, ajudamos a construir um conjunto de dados sintético usando GPT-4 ou Claude com revisão humana.
2. Seleção de framework, Unsloth + QLoRA para 90% dos projetos de startups. Axolotl para clientes que precisam de pipelines de produção reprodutíveis e multi-GPU.
3. Treino e avaliação, treinamos sempre com um conjunto de teste reservado e comparamos com o modelo base. Se o modelo com fine-tuning não melhorar mensuravelmente a métrica alvo, não o implementamos.
4. Implementação, vLLM para servidor de produção, padrões multi-adaptador quando os clientes precisam de vários modelos especializados a partir de uma única GPU.

Já entregámos modelos com fine-tuning para startups que não podiam suportar orçamentos empresariais de GPU; QLoRA no RunPod mantém os custos abaixo de 30€ mesmo para modelos 70B.

Precisa de ajuda para fazer fine-tuning de um LLM para o seu caso de uso? Ajudamos equipas a passar de dados brutos a modelo implementado. Obtenha uma consulta gratuita

Perguntas Frequentes Sobre Fine-Tuning de LLM

O que é fine-tuning de LLM?

Fine-tuning de LLM é o processo de treinar um modelo de linguagem pré-treinado com os seus próprios dados específicos da tarefa para que este execute essa tarefa melhor. Está essencialmente a ensinar ao modelo novos comportamentos, formatos ou expertise de domínio que o prompting genérico não consegue alcançar de forma fiável.

Quando devo fazer fine-tuning vs. usar RAG?

Faça fine-tuning quando precisar que o modelo se comporte de forma diferente, formato de saída consistente, linguagem específica do domínio, tom particular. Use RAG quando o modelo precisar de saber coisas diferentes, especialmente se esse conhecimento mudar frequentemente. Para muitos sistemas de produção, uma abordagem híbrida funciona melhor.

Quanto custa fazer fine-tuning de um LLM?

De 0€ a 540€, dependendo da escala. A maioria dos programadores individuais gasta menos de 1€ usando QLoRA numa RTX 4090 do RunPod (0,34€/h). Um modelo de produção 70B numa A100 custa 17-27€. Fine-tuning completo em clusters H100 custa 270-540€. Fine-tuning por API (OpenAI) custa 3-25€ para 1.000 exemplos.

Posso fazer fine-tuning de um LLM no meu portátil?

Sim, se o seu portátil tiver uma GPU com 12+ GB de VRAM. Uma GPU de portátil RTX 3060 lida com modelos 8B com QLoRA. Macs com Apple Silicon e 16+ GB de memória unificada também podem fazer fine-tuning via MLX, embora seja mais lento que CUDA. Para modelos maiores, precisará de GPUs na cloud.

Qual é a diferença entre LoRA e QLoRA?

Ambos adicionam pequenas camadas de adaptador treináveis enquanto congelam o modelo base. A diferença: QLoRA também quantiza o modelo base para precisão de 4 bits (tipo de dados NF4), reduzindo o uso de VRAM em ~25% comparado com LoRA padrão. A qualidade é quase idêntica, QLoRA alcança 97-99% da qualidade do fine-tuning completo.

Quantos exemplos de treino preciso?

Depende da complexidade da tarefa. 50-100 exemplos são suficientes para uma prova de conceito. 500-1.000 exemplos produzem resultados úteis para a maioria das tarefas únicas. 5.000-10.000 exemplos entregam qualidade de produção para tarefas complexas. Acima de 10.000, atinge retornos decrescentes a menos que a tarefa tenha variabilidade extremamente alta.

Qual modelo base devo fazer fine-tuning em 2026?

Llama 3.x para tarefas de propósito geral (melhor rácio qualidade/tamanho global). Mistral para línguas europeias e inferência eficiente. Qwen 2.5 para tarefas multilingues e de código. Phi-4 quando precisa da pegada mais pequena possível. Gemma 2 para integração no ecossistema Google.

O que é GRPO e porque é importante?

GRPO (Group Relative Policy Optimization), introduzido pela DeepSeek, é um sucessor do RLHF para treino de alinhamento. A vantagem chave: não requer treinar um modelo de recompensa separado, o que corta o custo computacional aproximadamente ao meio. TRL v0.15.0 suporta GRPO nativamente, tornando-o acessível a quem usa o ecossistema Hugging Face.

Como prevenir o esquecimento catastrófico?

Use LoRA ou QLoRA em vez de fine-tuning completo; eles congelam os pesos do modelo base, o que preserva o conhecimento geral. Mantenha a sua taxa de aprendizagem baixa (2e-4 para QLoRA, 2e-5 para completo). Treine pelo mínimo de épocas necessárias (1-3 é geralmente suficiente). Após o treino, execute o seu modelo em benchmarks gerais (MMLU, HellaSwag) para verificar se não regrediu.

Posso fazer fine-tuning e depois usar RAG em conjunto?

Absolutamente, e muitos sistemas de produção fazem exatamente isso. Faça fine-tuning para comportamento e consistência de formato, depois conecte RAG para recuperação de conhecimento atualizado. O modelo com fine-tuning é melhor a usar o contexto recuperado porque compreende a linguagem e os requisitos de saída do seu domínio.

Quanto tempo demora o fine-tuning?

Para a maioria dos projetos, 30 minutos a 8 horas. Um modelo 8B com 500 exemplos no Unsloth + RTX 4090 termina em 15-30 minutos. O mesmo trabalho num T4 Colab gratuito demora 1-2 horas. Modelos 70B em A100s demoram 5-8 horas. Fine-tuning completo em configurações multi-GPU pode demorar 20-40 horas.

Vale a pena a API de fine-tuning da OpenAI?

Para prototipagem rápida, sim. Pode carregar um ficheiro JSONL e ter um GPT-4o-mini com fine-tuning em 30 minutos sem configuração de GPU. Para produção, o fine-tuning local é geralmente melhor: é dono dos pesos, controla a privacidade dos seus dados e os custos são menores em escala. A maioria das equipas começa com a API para validar a abordagem, migrando depois para local.

Conclusão

Fazer fine-tuning de um LLM não é a magia negra que era há dois anos. Eis as principais conclusões:

1. Comece com QLoRA + Unsloth, lida com 90% dos casos de uso em hardware doméstico
2. Boa dados vencem um modelo maior sempre. Gaste o seu esforço na qualidade do conjunto de dados, não em upgrades de GPU.
3. A barreira de custo desapareceu, faça fine-tuning de um modelo 8B por menos de 1€ em GPUs na cloud
4. Avalie sempre contra o modelo base antes de implementar. Se não for mensuravelmente melhor, não o lance.
5. Considere RAG primeiro, faça fine-tuning apenas quando precisar que o modelo se comporte de forma diferente, e não apenas saiba coisas diferentes

Pronto para implementar? Veja as nossas Melhores Ferramentas e Plataformas de Fine-Tuning de LLM [em breve] para uma comparação detalhada de frameworks de treino e opções de implementação.

Se achou este guia útil, consulte o nosso walkthrough sobre escolher a stack de IA certa para as decisões de arquitetura mais amplas em torno de produtos potenciados por IA.

Fontes

• Repositório GitHub Unsloth, framework de fine-tuning com melhorias de velocidade 2-5x
• Documentação TRL Hugging Face, implementação SFTTrainer, DPO e GRPO
• Documentação PEFT Hugging Face, LoRA e fine-tuning eficiente em parâmetros
• Artigo QLoRA (Dettmers et al., 2023) -- pesquisa de quantização NormalFloat a 4 bits
• Artigo LoRA (Hu et al., 2021), adaptação de baixo rank de grandes modelos de linguagem
• Documentação API Fine-Tuning OpenAI, fluxo de trabalho de fine-tuning baseado em API
• Preços Cloud GPU RunPod, referência de custos de GPU na cloud
• Documentação vLLM, servidor LLM de produção
• Guia Fine-Tuning Meta Llama, recomendações oficiais de treino Llama
• Artigo DeepSeekMath (GRPO), Group Relative Policy Optimization