Como Fine-Tunar uma Rede Neural 8B em um Laptop com GPU de 4 GB

Qualquer pessoa que já tentou fazer fine-tuning de um LLM sabe esse ritual: você configura o ambiente, luta com versões do CUDA, ajusta o batch size, pega erros intermináveis de CUDA out of memory e acaba alugando um H100 na nuvem só para rodar algumas épocas em um pequeno dataset. Em algum momento, configurar scripts e mexer com servidores começa a tomar mais tempo do que preparar dados e analisar resultados.

Recentemente encontrei o repositório Soup de Alpamis Makazhan. O autor definiu uma meta ambiciosa: reduzir todo o pipeline de ajuste a um único comando no console e um arquivo YAML simples. O mais interessante do projeto é a capacidade de fazer fine-tuning de um modelo Llama 3.1 com 8 bilhões de parâmetros em um RTX 3050 mobile com apenas 4 GB de memória de vídeo.

Parece um truque de marketing, mas por trás existe uma engenharia interessante e um preprint aberto com benchmarks. Vamos analisar como funciona e como se sai na prática.

O que o Soup Pode Fazer

Essencialmente, o Soup é um wrapper CLI em torno de uma pilha popular de ML (PyTorch, Transformers, PEFT, TRL). A ideia principal é cuidar da rotina: detectar hardware disponível, quantização, auto-tuning do batch size e formatação de datasets.

O utilitário cobre o fluxo de trabalho completo do modelo:

• inicializa templates para diferentes tarefas (chat, código, tool-calling, classificação);
• detecta automaticamente formatos de dados (Alpaca, ShareGPT, ChatML) de JSONL, Parquet ou CSV;
• executa treinamento com métodos SFT, DPO, ORPO, SimPO ou KTO;
• testa o resultado quanto a regressões e faz merge dos adaptadores LoRA nos pesos do modelo;
• exporta o modelo para formato GGUF para rodar no Ollama ou llama.cpp.

Para uso básico, você nem precisa do PyTorch: uma versão CLI leve instala em poucos segundos e ajuda a inspecionar dados. E se você precisar do treinamento em si, a pilha completa é puxada.

# Установка пакета с зависимостями для обучения
pip install "soup-cli[train]"

# Создание конфига через мастер или из готового шаблона
soup init --template chat

# Запуск процесса
soup train

Como um Modelo 8B Cabe em 4 GB de Memória de Vídeo

Normalmente, um modelo de 8 bilhões de parâmetros mesmo na forma quantizada de 4 bits (NF4) requer cerca de 5-6 GB de VRAM só para carregar na memória. Se você adicionar contexto, ativações e adaptadores LoRA, uma placa com 4 GB inevitavelmente vai lançar um erro de falta de memória.

O autor do Soup usou uma técnica de streaming de camadas.

O modelo base não é mantido inteiramente na memória de vídeo. Ele fica armazenado na RAM do computador (ou até mesmo lido diretamente de um disco NVMe rápido) e alimentado para a GPU camada por camada. Apenas os adaptadores LoRA treináveis e a camada do decodificador atual são mantidos permanentemente na VRAM.

Em testes em um laptop RTX 3050 com 4 GB de VRAM, o modelo Llama-3.1-8B-Instruct com quantização NF4 mostrou consumo de memória de pico de apenas 3,32 GB a uma velocidade de cerca de 119 tokens por segundo. Os cálculos produzem resultados bit-identicos ao treinamento convencional residente.

O streaming de camadas é habilitado literalmente com uma única linha no config soup.yaml:

base: meta-llama/Llama-3.1-8B-Instruct
task: sft

data:
  train: ./data/train.jsonl
  format: alpaca

training:
  stream_layers: true      # стриминг слоев из RAM
  quantization: 4bit       # NF4 квантование
  batch_size: 4
  stream_source: auto      # RAM или NVMe
  lora:
    r: 64
    alpha: 16

output: ./output

Nas versões 0.72+, o streaming de camadas foi estendido não apenas para SFT clássico, mas também para métodos de alinhamento como DPO e ORPO. Com DPO, você precisa do modelo base para comparação, o que geralmente dobra o uso de memória. Aqui o utilitário usa o mesmo streaming de camadas com o adaptador desabilitado, sem criar um duplicado na memória.

Verificação de Qualidade e Proteção Contra Erros Ocultos

Um problema comum no fine-tuning: o modelo parece ter aprendido a responder suas perguntas específicas, mas esqueceu completamente como chamar funções ou começou a produzir JSON quebrado.

O Soup tem uma ferramenta de verificação integrada soup ship. Este é um gate de qualidade interno com um conjunto de testes (aritmética, seguimento de schema JSON, tool calling, segurança) que roda tanto os modelos originais quanto os ajustados.

soup ship --base ./base --adapter ./my-lora --task-eval my_task.jsonl

O comando retorna um veredito específico: SHIP ou DON'T SHIP. Por exemplo, se o adaptador melhorou as respostas na tarefa alvo mas quebrou a sintaxe de tool call, o utilitário vai sair com código não-zero e mostrar onde ocorreu a regressão.

Exportação e Uso

Uma vez que o adaptador está treinado e verificado, você pode empacotá-lo no formato desejado imediatamente:

# Проверить ответы в интерактивном режиме
soup chat --model ./output

# Влить LoRA в базовые веса
soup merge --adapter ./output

# Сконвертировать в GGUF для Ollama
soup export --model ./output --format gguf --quant q4_k_m

# Или поднять локальный API-сервер с OpenAI-совместимыми ручками
soup serve --model ./output

Se você precisa rodar o treinamento em uma máquina remota ou em isolamento sem instalar drivers manualmente, o projeto tem uma imagem Docker pronta no GitHub Packages (GHCR).

Para Quem Este Projeto Será Útil

O Soup é direcionado a desenvolvedores que precisam de um ciclo de experimento rápido sem mergulhar nas profundezas do treinamento distribuído.

O projeto definitivamente vale a pena experimentar se você:

1. Quer experimentar com modelos pequenos (Qwen 2.5, Llama 3.1, Gemma) em um PC ou laptop caseiro.
2. Está procurando um pipeline pronto: de dataset cru para um arquivo GGUF para uso local.
3. Está cansado de escrever os mesmos scripts baseados no HuggingFace TRL para tarefas típicas de SFT.

Limitações: Python 3.10–3.12 é estritamente necessário (as builds do PyTorch para 3.13 estão instáveis atualmente). Pré-treinamento completo do zero em clusters enormes via Soup não é recomendado—use Megatron ou DeepSpeed diretamente para isso. Mas para fine-tuning aplicado e prototipagem em GPUs de consumo, esta é uma ferramenta conveniente e bem pensada.