Unsloth: finetune um LLM em uma placa grande public

#A questão a resolver antes de instalar qualquer coisa

Sim, é possível fazer fine-tuning de um modelo de 7 ou 8 bilhões de parâmetros em uma placa de vídeo de consumo: a documentação do Unsloth indica um mínimo de 5 a 6 GB de VRAM com QLoRA de 4 bits, então uma placa de 12 GB é adequada, com margem para o contexto e o lote. O Unsloth reescreve as etapas mais pesadas do fine-tuning com LoRA e QLoRA para, segundo o desenvolvedor, chegar a ser duas vezes mais rápido com 70% menos VRAM, números que se aplicam apenas a alguns notebooks. O resultado pode ser exportado em GGUF para rodar no Ollama. Mas a verdadeira pergunta vem antes da instalação: o fine-tuning muda o comportamento de um modelo (tom, formato, registro), não mantém seus conhecimentos atualizados. Se você quer que ele conheça seus documentos, construa primeiro um sistema de busca documental. Considere também que a preparação do conjunto de dados leva mais tempo que o treinamento.

O fine-tuning altera a forma como um modelo se comporta. A busca documental muda o que ele sabe no momento de responder. Confundir os dois faz você perder semanas.

• Fine-tuning ou RAG: a árvore de decisão detalhada
• LoRA e QLoRA: como realmente funcionam
• Um exemplo completo de fine-tuning LoRA
• Avaliar se um RAG faria melhor, com números

#O que o Unsloth muda de fato

O método não é novo: congelamos os pesos do modelo e treinamos apenas matrizes finas adicionadas a cada peso, cerca de 1% dos parâmetros segundo o guia do Unsloth. O LoRA mantém o modelo original em 16 bits, o QLoRA o quantiza em 4 bits, economizando 75% de memória. É a abordagem padrão, não pertence ao Unsloth.

O que a biblioteca oferece é a implementação, com kernels de cálculo reescritos para as etapas pesadas. O projeto existe em três formas: Unsloth Desktop, um aplicativo nativo, Unsloth Studio, uma interface web, e Unsloth Core, a versão controlada por código mencionada neste artigo. É publicado sob duas licenças: Apache 2.0 para o núcleo e AGPL-3.0 para alguns componentes opcionais, como a interface Studio. O projeto afirma treinar modelos de linguagem, de difusão, de síntese de voz e de embeddings duas vezes mais rápido com 70% menos VRAM, sem perda de precisão. Nas arquiteturas com mistura de especialistas (MoE), o ganho publicado aumenta ainda mais: até 12 vezes mais rápido com mais de 35% de VRAM economizada em alguns modelos recentes. Como todos os números divulgados pelos desenvolvedores, esses descrevem o melhor caso: o próprio README mostra que o “duas vezes, 70%” vale apenas para alguns notebooks.

#Qual placa para qual modelo

A documentação especifica que esses números são mínimos absolutos: conforme o modelo, pode ser necessário mais. Ela indica que o tamanho do lote excessivo é uma causa frequente de saturação de memória, devendo ser reduzido para 1, 2 ou 3, e recomenda um comprimento de contexto de 2048 para os primeiros testes.

#O conjunto de dados é o verdadeiro trabalho

Um fine-tuning nunca falha devido à biblioteca. Ele falha devido aos dados.

Formato

Um conjunto de dados com duas colunas, pergunta e resposta, geralmente na estrutura de conversa esperada pelo modelo. O guia recomenda começar com um modelo Instruct: ele aceita diretamente os templates de conversa (ChatML, ShareGPT) e exige menos dados do que um modelo base. A consistência conta mais que o volume.

Quantidade

O guia do Unsloth recomenda, como mínimo absoluto, 100 linhas e mais de 1.000 linhas para resultados melhores. O tom e o formato mudam com poucos exemplos; um comportamento realmente adequado ao domínio de negócio exige mais exemplos, coerentes entre si.

Qualidade

O modelo imita o que lhe é mostrado, incluindo os erros. Um defeito sistemático nos dados torna-se um defeito sistemático no modelo.

Conjunto de controle

Exemplos que o modelo nunca viu durante o treinamento. Sem eles, impossível distinguir aprendizado de simples memorização.

Sem código

O Unsloth Studio oferece Data Recipes, que transformam PDF, CSV ou DOCX em conjuntos de dados por meio de um fluxo visual, com pré-visualização antes de iniciar a construção completa.

#Do adaptador ao modelo utilizável

O processo se divide em três etapas: carregar um modelo em 4 bits, treiná-lo com um dos notebooks oficiais e exportá-lo. O primeiro bloco de código carrega o modelo e adiciona os adaptadores LoRA; o treinamento propriamente dito é feito com um dos notebooks do Unsloth, que o guia recomenda copiar para o seu ambiente local.

from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Qwen3-8B-unsloth-bnb-4bit",  # quantification dynamique 4 bits d'Unsloth
    max_seq_length=2048,
    load_in_4bit=True,
)
model = FastLanguageModel.get_peft_model(model, r=16, lora_alpha=16)

O sufixo do nome importa. De acordo com o guia, um modelo cujo nome termina em unsloth-bnb-4bit usa uma quantização dinâmica de 4 bits do Unsloth: ela consome um pouco mais de VRAM do que uma quantização padrão do BitsAndBytes, mas oferece uma precisão significativamente superior. Um nome que termina apenas em bnb-4bit indica a versão padrão. O guia acrescenta que o treinamento e a disponibilização do modelo se beneficiam do uso da mesma precisão: disponibilizá-lo em 4 bits significa treiná-lo em 4 bits.

1. 01
   Treinar

   O resultado é um adaptador LoRA, de cerca de 100 MB no exemplo do Unsloth, não um modelo completo.
2. 02
   Avaliar

   Compare com o conjunto de controle e com o modelo original. Ser “melhor” é algo que se demonstra, não que se presume. O guia observa que as ferramentas de avaliação automática podem não refletir bem seus critérios.
3. 03
   Mesclar ou manter separado

   O adaptador pode permanecer separado e ser trocado, ou ser fundido nos pesos: model.save_pretrained_merged com save_method="merged_16bit".
4. 04
   Exportar para GGUF e quantizar

   model.save_pretrained_gguf gera o arquivo, com q4_k_m, q8_0 ou f16 à sua escolha. É isso que permite executar o resultado com Ollama ou llama.cpp em hardware comum.

model.save_pretrained_gguf(
    "mon-modele-q4", tokenizer, quantization_method="q4_k_m"
)
# puis, avec le Modelfile fourni : ollama create mon-modele -f Modelfile

• Importar um GGUF no Ollama
• Escolher o nível de quantização do seu modelo

#As armadilhas comuns

Começar com um modelo base sem saber

O guia recomenda modelos Instruct: eles aceitam templates de conversa e exigem menos dados. Um modelo base exige um formato diferente (Alpaca, Vicuna) e mais exemplos.

Esquecer o template de conversa

Exemplos formatados de forma diferente da esperada pelo modelo resultam em treinamento tecnicamente bem-sucedido e praticamente inútil.

Medir nos exemplos de treinamento

É esse erro que leva a anunciar resultados espetaculares e entregar modelos decepcionantes.

Acreditar que substituirá a pesquisa documental

O que ensinamos ao modelo fica desatualizado no dia em que suas informações mudam, e o modelo não cita suas fontes. Para fatos que evoluem, a pesquisa documental continua mais segura.

Subestimar a limpeza dos exemplos

Duplicatas quase idênticas no conjunto de dados enviesam o treinamento para esses casos específicos sem que isso seja indicado nas métricas monitoradas.

Mudar vários ajustes ao mesmo tempo

Modificar a taxa de aprendizado, o rank do adaptador e o comprimento da sequência em uma mesma tentativa impede de saber qual produziu a mudança observada.

#Casos de uso concretos

Atendimento ao cliente com tom constante

Um modelo ajustado com base em interações reais responde com a voz da marca, sem instruções de estilo repetidas em cada prompt.

Extração em formato estrito

Fazer fine-tuning com exemplos de entrada e saída define o formato de saída de maneira mais confiável do que apenas um prompt, o que é útil antes de enviar o resultado a um sistema em uma etapa posterior.

Um ponto em comum nesses casos: cada um pode ser medido. Antes de iniciar um treinamento, defina o critério de sucesso em uma frase verificável — por exemplo: 'o formato JSON é respeitado em pelo menos 95% das saídas do conjunto de controle' — em vez de uma impressão geral de melhora. É esse critério, e não a intuição, que dirá se o resultado justifica o tempo investido.

• Fonte: repositório oficial Unsloth (funções, hardware, licença dupla)
• Fonte: pré-requisitos e VRAM mínima por tamanho do modelo
• Fonte: guia de fine-tuning do Unsloth
• Fonte: exportação para GGUF e problemas de template
• Fonte: dados de desempenho dos modelos MoE

#O custo real, além do preço da placa

A placa de vídeo é apenas um dos itens de custo. Coletar e limpar exemplos coerentes, criar um conjunto de avaliação que o modelo nunca verá e depois comparar cada versão com o modelo original costuma pesar mais do que o treinamento em si, que o guia do Unsloth ilustra com um teste de 60 passos.

É por isso que o Unsloth, por mais rápido que seja no treinamento, não reduz a duração de um projeto tanto quanto se espera: ele elimina o gargalo técnico, não o trabalho com os dados.

#FAQ

Hardware recomendado: RTX 5070 Ti 16 GB — placa NVIDIA de 16 GB, suficiente para fazer o ajuste fino de um modelo 7–8B com QLoRA. Todo o hardware de IA →