Introdução
O panorama do fine-tuning de LLM em 2026 é simultaneamente mais capaz e mais fragmentado do que nunca. Dois anos atrás, fine-tuning significava LoRA em uma única GPU com uma configuração YAML e uma prece. Hoje, equipes escolhem entre pelo menos cinco frameworks sérios, cada um com filosofias de design distintas, características de desempenho e integrações de ecossistema diferentes. A escolha do framework tem consequências reais para velocidade de treinamento, eficiência de memória, qualidade do modelo e complexidade operacional do seu pipeline de treinamento.
Este guia fornece uma comparação completa e focada na prática dos quatro frameworks de fine-tuning mais amplamente adotados: Axolotl, Unsloth, TorchTune e TRL (Transformer Reinforcement Learning). Também cobrimos LLaMA-Factory, que estabeleceu uma posição forte na comunidade de ML asiática e merece consideração. Cada framework ocupou um nicho, e entender esses nichos é essencial para tomar uma decisão informada.
A comparação se baseia em execuções de treinamento do mundo real através de múltiplas arquiteturas de modelos, configurações de GPU e métodos de treinamento. Cada benchmark e exemplo de configuração neste guia foi validado em hardware e versões de software atuais no início de 2026.
O Estado do Fine-Tuning de LLM em 2026
O fine-tuning em 2026 opera em um ambiente fundamentalmente diferente do que em 2024. Os modelos base são maiores e mais capazes, o que significa que o fine-tuning frequentemente alcança excelentes resultados com menos exemplos. O treinamento consciente de quantização amadureceu ao ponto em que modelos fine-tuned de 4 bits competem com seus equivalentes de precisão total. Métodos de alinhamento pós-treinamento como DPO e GRPO substituíram em grande parte o RLHF para aprendizado de preferências, e as ferramentas acompanharam.
O panorama de hardware também mudou. As H200 da NVIDIA e a AMD MI300X tornaram VRAM de 80GB+ acessível em ambientes cloud, enquanto a RTX 5090 com 32GB se tornou a placa de treinamento de nível consumidor preferida. O treinamento multi-GPU via FSDP se tornou a abordagem padrão, substituindo DeepSpeed para muitas cargas de trabalho devido à sua integração mais estreita com PyTorch.
No lado dos modelos, o ecossistema de pesos abertos explodiu. Llama 4, Mistral Large 2, Qwen 3 e DeepSeek-V3 fornecem todos modelos base sólidos para fine-tuning. A cobertura de suporte de modelos de cada framework se tornou um diferenciador chave.
Visão Geral dos Frameworks
Axolotl
Axolotl começou como um projeto comunitário para simplificar o fine-tuning multi-método e cresceu para se tornar o framework mais completo em recursos do ecossistema. Ele envolve Hugging Face Transformers e PEFT, adicionando um sistema de configuração baseado em YAML que cobre virtualmente todos os parâmetros de treinamento. A força do Axolotl é a amplitude: suporta mais métodos de treinamento, arquiteturas de modelos e formatos de dataset do que qualquer outro framework individual.
Unsloth
Unsloth adota a abordagem oposta ao Axolotl. Em vez de envolver o stack Hugging Face, Unsloth reimplementa kernels de treinamento críticos usando Triton, alcançando acelerações de 2-5x sobre implementações padrão. Foca incansavelmente em desempenho de GPU única e eficiência de memória, tornando-o o framework preferido para praticantes trabalhando com orçamentos de hardware limitados.
TorchTune
TorchTune é o framework oficial de fine-tuning da Meta, construído do zero sobre primitivas nativas PyTorch. Evita dependências externas quando possível, usando torch.compile, DTensor e FSDP2 em vez de bibliotecas de terceiros. Isso lhe dá a integração mais estreita com o ecossistema PyTorch e o comportamento mais previsível em novos releases do PyTorch.
TRL
TRL, mantido pela Hugging Face, é a biblioteca padrão para aprendizado por reforço a partir de feedback humano e métodos de pós-treinamento relacionados. Embora suporte SFT, sua força principal é o treinamento de alinhamento: DPO, GRPO, KTO, ORPO e a família completa de métodos de otimização de preferências. Se sua carga de trabalho principal é alinhamento em vez de fine-tuning supervisionado, TRL é o ponto de partida natural.
LLaMA-Factory
LLaMA-Factory fornece uma interface web e CLI para fine-tuning com ênfase em acessibilidade. Envolve Hugging Face Transformers e suporta uma ampla gama de métodos e modelos. Sua interface web o torna popular para equipes que querem democratizar o fine-tuning além da equipe de engenharia de ML.
Arquitetura e Filosofia de Design
As diferenças arquiteturais entre esses frameworks não são superficiais. Refletem crenças fundamentalmente diferentes sobre como deveria ser a experiência do desenvolvedor de fine-tuning.
A arquitetura do Axolotl é dirigida por configuração. Um único arquivo YAML especifica tudo: o modelo base, tipo de adaptador, formato do dataset, hiperparâmetros de treinamento e configurações de hardware. Isso torna o Axolotl extremamente reprodutível. Você pode dar a alguém um arquivo YAML e ele pode recriar sua execução de treinamento exata. A desvantagem é que o espaço de configuração é enorme, e a relação entre opções nem sempre é óbvia:
base_model: meta-llama/Llama-4-Scout-17B-16E
model_type: AutoModelForCausalLM
tokenizer_type: AutoTokenizer
load_in_4bit: true
adapter: qlora
lora_r: 32
lora_alpha: 64
lora_dropout: 0.05
lora_target_linear: true
dataset_format: sharegpt
datasets:
- path: /data/training/conversations.jsonl
type: sharegpt
conversation: chatml
sequence_len: 8192
sample_packing: true
pad_to_sequence_len: true
gradient_accumulation_steps: 4
micro_batch_size: 2
num_epochs: 3
learning_rate: 2e-4
lr_scheduler: cosine
warmup_steps: 100
optimizer: adamw_bnb_8bit
bf16: auto
tf32: true
flash_attention: true
gradient_checkpointing: true
wandb_project: llama4-finetune
wandb_run_id: scout-qlora-v1
A arquitetura do Unsloth centra-se em kernels Triton personalizados que substituem as implementações padrão de PyTorch de atenção, passagens forward de LoRA e cálculo de perda. A API é intencionalmente mínima:
from unsloth import FastLanguageModel
model, tokenizer = FastLanguageModel.from_pretrained(
model_name="meta-llama/Llama-4-Scout-17B-16E",
max_seq_length=8192,
dtype=None,
load_in_4bit=True,
)
model = FastLanguageModel.get_peft_model(
model,
r=32,
target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
"gate_proj", "up_proj", "down_proj"],
lora_alpha=64,
lora_dropout=0,
bias="none",
use_gradient_checkpointing="unsloth",
random_state=42,
)
TorchTune usa uma arquitetura baseada em receitas. Cada método de treinamento é um script Python independente (uma "receita") que você pode ler, entender e modificar. A configuração usa arquivos TOML:
[model]
_component_ = "torchtune.models.llama4.llama4_scout_17b_16e"
[tokenizer]
_component_ = "torchtune.models.llama4.llama4_tokenizer"
path = "/models/llama4-scout/tokenizer.model"
[dataset]
_component_ = "torchtune.datasets.chat_dataset"
source = "/data/training/conversations.jsonl"
conversation_style = "sharegpt"
[optimizer]
_component_ = "torch.optim.AdamW"
lr = 2e-4
weight_decay = 0.01
[training]
batch_size = 2
epochs = 3
gradient_accumulation_steps = 4
compile = true
TRL segue o padrão Hugging Face Trainer, estendendo-o com trainers especializados para cada método de alinhamento:
from trl import SFTTrainer, SFTConfig
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import LoraConfig
model = AutoModelForCausalLM.from_pretrained(
"meta-llama/Llama-4-Scout-17B-16E",
torch_dtype="auto",
attn_implementation="flash_attention_2",
)
training_args = SFTConfig(
output_dir="./output",
per_device_train_batch_size=2,
gradient_accumulation_steps=4,
num_train_epochs=3,
learning_rate=2e-4,
lr_scheduler_type="cosine",
warmup_steps=100,
bf16=True,
max_seq_length=8192,
packing=True,
gradient_checkpointing=True,
)
peft_config = LoraConfig(
r=32,
lora_alpha=64,
lora_dropout=0.05,
target_modules="all-linear",
)
trainer = SFTTrainer(
model=model,
args=training_args,
train_dataset=dataset,
peft_config=peft_config,
)
trainer.train()
Suporte a Métodos de Treinamento
A gama de métodos de treinamento suportados varia significativamente entre os frameworks. Aqui está a matriz de suporte atual:
SFT (Supervised Fine-Tuning) é suportado por todos os cinco frameworks. Este é o requisito mínimo. As diferenças emergem em quão eficientemente cada framework implementa SFT, particularmente em relação a empacotamento de amostras, paralelismo de sequência e otimização de memória.
DPO (Direct Preference Optimization) é totalmente suportado por TRL, Axolotl e LLaMA-Factory. TorchTune adicionou suporte a DPO no final de 2025. Unsloth suporta DPO através de sua camada de integração TRL.
GRPO (Group Relative Policy Optimization) emergiu como o método de alinhamento preferido para modelos de raciocínio após o trabalho da DeepSeek. TRL tem a implementação GRPO mais madura. Axolotl o suporta através de delegação ao TRL. TorchTune tem GRPO nativo desde o início de 2026.
RLHF com PPO continua suportado no TRL mas caiu em desuso para a maioria dos casos de uso. A complexidade e instabilidade dos loops de treinamento PPO tornaram DPO e GRPO alternativas atraentes.
QAT (Quantization-Aware Training) é nativamente suportado no TorchTune através das primitivas de quantização do PyTorch. Unsloth suporta QAT através de seus kernels personalizados. Axolotl e TRL suportam QAT via integração com bitsandbytes e GPTQ.
Comparação de Desempenho em GPU Única
O desempenho em GPU única é onde os frameworks mostram as diferenças mais dramáticas. Avaliamos todos os quatro em um fine-tune QLoRA do Llama 3.1 8B usando o mesmo dataset, hiperparâmetros e hardware (NVIDIA A100 80GB).
Configuração de treinamento: QLoRA r=32, comprimento de sequência 4096, tamanho de lote 2, acumulação de gradiente 4, 1000 passos, precisão BF16.
Unsloth consistentemente entrega o treinamento mais rápido em GPU única, tipicamente 2-3x mais rápido que TRL na mesma configuração. A aceleração vem de três fontes: kernels Triton fundidos que combinam múltiplas operações em lançamentos únicos de kernel GPU, uma implementação LoRA personalizada que evita materializar tensores intermediários de rank completo, e uma implementação otimizada de gradient checkpointing que reduz a recomputação.
TorchTune com torch.compile habilitado alcança aproximadamente 1,5x de aceleração sobre TRL em execuções de treinamento mais longas, embora o passo de compilação adicione vários minutos de overhead de inicialização. Para execuções curtas de fine-tuning abaixo de 30 minutos, este custo de compilação pode anular a melhoria de tempo de execução.
O desempenho do Axolotl é essencialmente idêntico ao TRL para configurações equivalentes porque usa o mesmo loop de treinamento subjacente do Hugging Face. O valor do Axolotl está na conveniência de configuração em vez de velocidade bruta.
A eficiência de memória segue um padrão similar. Os kernels personalizados do Unsloth reduzem o uso máximo de memória em 30-50% comparado com implementações padrão, frequentemente permitindo treinar em uma única GPU onde outros frameworks exigiriam offloading de gradiente ou uma placa maior.
Escalabilidade Multi-GPU
Para treinamento multi-GPU, o panorama muda. TorchTune tem a história multi-GPU mais forte porque constrói diretamente sobre as primitivas FSDP2 e DTensor do PyTorch:
tune run --nproc_per_node 8 full_finetune_distributed \
--config llama4_scout/17B_full.toml
TRL e Axolotl usam Hugging Face Accelerate para treinamento distribuído, que envolve FSDP ou DeepSpeed:
accelerate launch --num_processes 8 \
--mixed_precision bf16 \
--use_fsdp \
--fsdp_sharding_strategy FULL_SHARD \
train.py
O suporte multi-GPU do Unsloth tem sido historicamente sua área mais fraca. Os kernels Triton personalizados foram projetados para execução em GPU única, e embora o suporte multi-GPU tenha melhorado ao longo de 2025 e 2026, ainda requer mais configuração manual do que as alternativas.
Para execuções de treinamento em larga escala através de múltiplos nós, TorchTune e a integração DeepSpeed no TRL/Axolotl são as opções mais testadas em batalha. A vantagem do TorchTune é que evita os problemas de compatibilidade de versão que às vezes surgem entre Accelerate, DeepSpeed e Transformers.
Configuração e Experiência do Desenvolvedor
A experiência do desenvolvedor se estende além da configuração inicial para abranger depuração, reprodutibilidade e a curva de aprendizado para novos membros da equipe.
A configuração YAML do Axolotl é simultaneamente sua maior força e fraqueza. Um único arquivo YAML especifica completamente uma execução de treinamento, tornando a reprodução trivial. No entanto, os arquivos YAML podem crescer para centenas de linhas, e a documentação para opções menos comuns às vezes é incompleta. Depurar um problema de configuração frequentemente significa pesquisar issues do GitHub.
Unsloth fornece a experiência mais Pythônica. A configuração é código, o que significa que seu IDE fornece autocompletamento e verificação de tipos. A curva de aprendizado é suave para qualquer pessoa confortável com PyTorch. A desvantagem é que a reprodutibilidade requer compartilhar scripts Python em vez de arquivos de configuração declarativos.
TorchTune encontra um meio-termo com sua configuração TOML mais arquitetura de receitas. As receitas são arquivos Python legíveis que servem tanto como código executável quanto como documentação. Quando algo dá errado, você pode ler o código-fonte da receita e entender o fluxo de execução. Esta transparência é valiosa para equipes que precisam entender e modificar o processo de treinamento.
TRL segue o padrão familiar do Hugging Face Trainer. Se sua equipe já usa Hugging Face para inferência e processamento de dados, TRL requer o menor aprendizado novo. O padrão TrainingArguments é bem documentado e amplamente entendido.
Técnicas de Otimização de Memória
A eficiência de memória determina se você pode treinar no hardware que tem. Cada framework oferece diferentes técnicas:
# Unsloth: automatic memory-efficient LoRA
model = FastLanguageModel.get_peft_model(
model,
r=32,
use_gradient_checkpointing="unsloth", # 60% less VRAM than standard
)
# TorchTune: activation checkpointing with selective recomputation
from torchtune.training import ActivationCheckpointing
model = ActivationCheckpointing(model, checkpoint_every_n_layers=2)
Gradient checkpointing é universalmente suportado, mas as implementações diferem. A implementação do Unsloth é a mais eficiente em memória, recomputando seletivamente apenas as operações mais baratas. A implementação do TorchTune é a mais configurável, permitindo granularidade a nível de camada.
CPU offloading move estados do otimizador para RAM da CPU, reduzindo drasticamente os requisitos de memória GPU ao custo da velocidade de treinamento. TRL e Axolotl suportam isso através do DeepSpeed ZeRO Stage 3:
{
"zero_optimization": {
"stage": 3,
"offload_optimizer": {
"device": "cpu",
"pin_memory": true
},
"offload_param": {
"device": "cpu",
"pin_memory": true
}
}
}
Otimizadores quantizados substituem Adam padrão com variantes de 8 bits ou 4 bits que usam uma fração da memória. Todos os frameworks suportam Adam de 8 bits do bitsandbytes. Unsloth adicionalmente oferece implementações de otimizadores quantizados personalizados.
Quando Usar Qual: Matriz de Decisão
A escolha do framework deve ser dirigida por seus requisitos específicos em vez de manchetes de benchmarks.
Escolha Unsloth quando estiver trabalhando com uma única GPU e precisar de máxima velocidade de treinamento e eficiência de memória. Unsloth é o claro vencedor para praticantes individuais, equipes pequenas e qualquer cenário onde você esteja treinando em hardware de consumidor ou uma única GPU cloud. Se estiver executando QLoRA em uma RTX 4090 ou uma única A100, Unsloth o levará lá mais rápido.
Escolha TorchTune quando precisar de full fine-tuning multi-GPU com a integração PyTorch mais estreita possível. TorchTune é a escolha certa para equipes que executam trabalhos de treinamento em larga escala, precisam de reprodutibilidade entre versões do PyTorch e querem minimizar dependências externas. Também é a melhor escolha se estiver fazendo fine-tuning dos modelos Llama da Meta, pois recebe suporte de primeira mão para novas arquiteturas Llama.
Escolha TRL quando sua carga de trabalho principal for treinamento de alinhamento (DPO, GRPO, KTO, ORPO). TRL tem a implementação mais madura e completa dos métodos de otimização de preferências. Também é a escolha natural se seu fluxo de trabalho estiver profundamente integrado ao ecossistema Hugging Face.
Escolha Axolotl quando precisar de máxima flexibilidade em uma única ferramenta. Axolotl suporta mais arquiteturas de modelos, métodos de treinamento e formatos de dataset do que qualquer outro framework. É a escolha certa para equipes que treinam muitos modelos diferentes e precisam de uma interface única e consistente.
Escolha LLaMA-Factory quando precisar capacitar não-engenheiros de ML a executar trabalhos de fine-tuning. Sua interface web reduz significativamente a barreira de entrada, e sua CLI é direta para fluxos de trabalho com scripts.
Preparação de Datasets e Tratamento de Formatos
Um dos aspectos mais subestimados ao escolher um framework de fine-tuning é como ele lida com a preparação de datasets. Dados de treinamento do mundo real são bagunçados, inconsistentes e raramente estão no formato exato que um framework espera nativamente.
Axolotl se destaca aqui com suporte para mais de uma dúzia de formatos de dataset, incluindo ShareGPT, Alpaca, completions de chat OpenAI, JSONL com mapeamentos de campos personalizados e formatos de completion brutos. Seu pipeline de pré-processamento de dataset lida com tokenização, aplicação de template de chat e empacotamento de amostras em uma única passada:
datasets:
- path: /data/sharegpt_conversations.jsonl
type: sharegpt
conversation: chatml
- path: /data/alpaca_instructions.jsonl
type: alpaca
- path: /data/completions.jsonl
type: completion
field_instruction: prompt
field_output: response
TRL usa a biblioteca padrão de datasets do Hugging Face e espera dados em formato conversacional com arrays de mensagens. Converter formatos personalizados requer escrever uma função de pré-processamento:
from datasets import load_dataset
def format_conversations(example):
messages = []
for turn in example["conversation"]:
messages.append({
"role": turn["from"],
"content": turn["value"]
})
return {"messages": messages}
dataset = load_dataset("json", data_files="/data/training.jsonl")
dataset = dataset.map(format_conversations)
Unsloth delega o manuseio de datasets ao usuário, fornecendo funções auxiliares para formatos comuns mas esperando que você lide com o pré-processamento por conta própria. Isso dá máxima flexibilidade ao custo de mais código boilerplate.
TorchTune fornece construtores de datasets para formatos comuns e enfatiza segurança de tipos na construção de datasets. Suas classes de dataset validam a estrutura de cada exemplo antes do treinamento, capturando problemas de formato cedo em vez de durante uma execução de treinamento longa.
O empacotamento de amostras, onde múltiplos exemplos curtos são concatenados em uma única sequência para maximizar a utilização de GPU, é uma otimização crítica para datasets com exemplos de comprimento variável. Axolotl e TRL suportam empacotamento de amostras nativamente. Unsloth implementa seu próprio algoritmo de empacotamento otimizado. TorchTune adicionou empacotamento de amostras em meados de 2025 e sua implementação lida corretamente com casos extremos como mascaramento de atenção entre exemplos.
Avaliação e Benchmarking Durante o Treinamento
Avaliar a qualidade do modelo durante o treinamento é essencial para detectar overfitting, selecionar o melhor checkpoint e comparar execuções. Cada framework aborda a avaliação durante o treinamento de maneira diferente.
TRL fornece a integração de avaliação mais fluida porque se baseia no Hugging Face Trainer, que suporta datasets de avaliação, callbacks de métricas personalizadas e seleção automática do melhor checkpoint:
from trl import SFTConfig
training_args = SFTConfig(
output_dir="./output",
evaluation_strategy="steps",
eval_steps=100,
save_strategy="steps",
save_steps=100,
load_best_model_at_end=True,
metric_for_best_model="eval_loss",
per_device_eval_batch_size=4,
)
Axolotl suporta avaliação através de sua configuração YAML com opções similares para frequência de avaliação, seleção de métricas e gerenciamento de checkpoints. Adicionalmente suporta parada antecipada baseada em métricas de avaliação:
eval_steps: 100
save_steps: 100
eval_batch_size: 4
early_stopping_patience: 5
load_best_model_at_end: true
A arquitetura de receitas do TorchTune significa que a lógica de avaliação vive no próprio arquivo Python da receita, dando-lhe controle total sobre quais métricas são calculadas e quando. Você pode adicionar lógica de avaliação personalizada, executar suítes de benchmarks, ou mesmo gerar saídas de amostra durante o treinamento:
# Inside a TorchTune recipe
if step % eval_interval == 0:
model.eval()
eval_loss = compute_eval_loss(model, eval_dataloader)
perplexity = torch.exp(eval_loss)
log_metrics({"eval_loss": eval_loss, "perplexity": perplexity})
model.train()
Unsloth não inclui hooks de avaliação embutidos, dependendo do usuário para implementar avaliação externamente ou usar Unsloth dentro de um TRL SFTTrainer onde a infraestrutura de avaliação do TRL se aplica.
Para treinamento de alinhamento especificamente, a avaliação é mais nuançada do que curvas de perda. TRL suporta avaliação de taxa de vitória contra um modelo de referência durante o treinamento DPO, fornecendo uma medida direta de se o modelo alinhado está melhorando na direção pretendida.
Considerações de Implantação em Produção
O fine-tuning só é valioso se o modelo resultante puder ser implantado de forma confiável. Cada framework tem diferentes histórias de exportação e implantação.
Todos os frameworks exportam formatos de modelo padrão Hugging Face, que podem ser servidos por vLLM, TGI ou qualquer framework de inferência que suporte o formato do hub de modelos Hugging Face. Adaptadores LoRA podem ser mesclados no modelo base antes da implantação ou servidos separadamente usando frameworks que suportam carregamento dinâmico de adaptadores.
Unsloth fornece exportação GGUF otimizada para implantação com llama.cpp e Ollama:
model.save_pretrained_gguf(
"output_model",
tokenizer,
quantization_method="q4_k_m"
)
TorchTune se integra com ExecuTorch para implantação mobile e edge, o que é uma vantagem única se seus alvos de implantação se estendem além de servidores cloud.
Para pipelines de treinamento em produção, considere containerizar seu fluxo de trabalho de treinamento:
docker run --gpus all -v /data:/data -v /models:/models \
axolotl-train:latest \
accelerate launch -m axolotl.cli.train /data/config.yaml
Fixe as versões do seu framework, PyTorch e toolkit CUDA. Resultados de treinamento podem variar significativamente entre versões, e depurar a não-reprodutibilidade entre ambientes é um dos problemas mais demorados em operações de ML.
Qualquer que seja o framework que você escolha, invista em rastreamento de experimentos desde o primeiro dia. Weights and Biases, MLflow, ou mesmo um diretório de logs estruturado economizarão horas de confusão quando você precisar comparar resultados entre execuções de treinamento. Todos os frameworks suportam integração com W&B, e os metadados que ele captura (configuração, hardware, curvas de treinamento, métricas de avaliação) são essenciais para tomar decisões informadas sobre qualidade do modelo e eficiência de treinamento.