Treine o Primeiro LoRA Grátis: Dados, Legendas, Configurações

TL;DR

• Reúna 20+ imagens do seu assunto com ângulos, distâncias e iluminação variados.
• Automatize o tagging (WD14 Tagger) para treinamento por palavras-chave ou o captioning (BLIP) para prompts em linguagem natural — ambos disponíveis nos notebooks gratuitos do Colab da hollowstrawberry.
• Configure taxas de aprendizado em 1e-4 para o UNet e 1e-5 para o codificador de texto; treine por 8–12 épocas; use os poupadores de memória do SDXL como --gradient_checkpointing e --cache_latents.
• Comece grátis com o Lora Trainer do Colab da hollowstrawberry, ou rode kohya-ss/sd-scripts localmente na sua própria GPU.

Introdução

Low-Rank Adaptation (LoRA) faz fine-tuning de modelos de difusão injetando pequenas matrizes de pesos treináveis em camadas existentes, mantendo os pesos originais congelados. O resultado é um arquivo portátil que você troca entre projetos para injetar um rosto, estilo ou conceito específico. O baixo custo computacional do LoRA significa que GPUs de consumo ou notebooks gratuitos do Colab funcionam; kohya-ss oferece um pipeline local completo.

Este guia percorre as três fases que determinam o sucesso: preparar seu dataset, legendar corretamente e ajustar as configurações de treinamento.

Fase 1: Preparação do Dataset

Um LoRA treinado num dataset malfeito produz um modelo malfeito. A regra da comunidade: pelo menos 20 imagens, com variedade de ângulo, distância e contexto.

O que incluir

Para LoRAs de personagem: closeups de rosto, fotos de corpo inteiro, imagens de contexto recortadas. Para LoRAs de estilo: varie a composição, mantenha o estilo consistente. LoRAs de palavra-gatilho precisam do conceito de múltiplos pontos de vista.

A comunidade recomenda distâncias variadas do alvo, mencionando explicitamente closeups de rosto junto com imagens de corpo inteiro, para que o modelo aprenda o assunto em múltiplas escalas. O treinamento estilo DreamBooth (tokens de classe, não legendas) se beneficia de um conjunto focado centrado num único assunto (Civitai 7).

Onde coletar imagens

Imagens: Pixiv, Danbooru, Safebooru, Google, Reddit, fotografia própria. O notebook Dataset Maker da hollowstrawberry raspa o Gelbooru, filtra tags, deduplica via FiftyOne — tudo no navegador, sem GPU local (hollowstrawberry/kohya-colab).

Organizando os arquivos

Diretório único, sem subpastas. DreamBooth: token de classe no nome da pasta. Fine-tuning: metadados JSON por subconjunto.

Fase 2: Legendagem

Suas legendas determinam o que o LoRA aprende. Duas ferramentas automatizadas dominam esse espaço e servem a paradigmas de treinamento diferentes.

WD14 Tagger: tags por palavras-chave para DreamBooth

WD14 Tagger gera tags separadas por vírgula com pontuação de confiança. Padrão para treinamento estilo DreamBooth.

Script: finetune/tag_images_by_wd14_tagger.py em kohya-ss/sd-scripts. --onnx para velocidade. Limite padrão 0,35. Flags principais: --remove_underscore, --character_tags_first, --always_first_tags.

Saída: .txt por imagem, ex.: 1girl, long_hair, blue_eyes, wearing_crown, holding_sword.

BLIP: legendas em linguagem natural para fine-tuning

BLIP gera frases: "Uma garota com cabelo roxo longo fica num jardim segurando uma espada." Adequado para fine-tuning por descrições, não por tokens de classe.

Limpeza manual

Revise as saídas. Remova identificações erradas, padronize nomes (holding_sword e não holding_sword, holding weapon), garanta que as palavras-gatilho iniciem as linhas de tag. Use caption_prefix/caption_suffix no .toml para modificadores globais de qualidade como masterpiece, best quality,.

Fase 3: Configurações de Treinamento

Dataset pronto, legendado — agora configure.

Linha de base de comandos (SD 1.5)

accelerate launch --num_cpu_threads_per_process 1 train_network.py \
 --pretrained_model_name_or_path="<caminho do modelo SD>" \
 --dataset_config="my_dataset_config.toml" \
 --output_dir="<saída>" --output_name="my_lora" \
 --save_model_as=safetensors --network_module=networks.lora \
 --network_dim=16 --network_alpha=1 --learning_rate=1e-4 \
 --optimizer_type="AdamW8bit" --lr_scheduler="constant" \
 --sdpa --max_train_epochs=10 --save_every_n_epochs=1 \
 --mixed_precision="fp16" --gradient_checkpointing

SDXL: sdxl_train_network.py com network_dim=32, network_alpha=16, taxas de LR separadas no codificador de texto (--text_encoder_lr1/--text_encoder_lr2), bf16, --cache_text_encoder_outputs + --cache_latents (kohya-ss sdxl_train_network.md).

Configurações que importam

Taxa de aprendizado — 1e-4 padrão. Muito baixo (1e-6) = fraco; muito alto (1e-2) = artefatos. Docs do Kohya: "valores relativamente mais altos (ex., 1e-4 a 1e-3) são frequentemente usados." LR do codificador de texto ≈ 1e-5 para evitar overfitting (kohya-ss train_network.md).

Épocas — 8–12. Abaixo de 8 = fraco; acima de 12 = retornos decrescentes/sobreajuste. num_repeats no .toml multiplica o tamanho efetivo do dataset.

network_dim / network_alpha — network_dim varia de 4 a 128. Início: 16 (SD 1.5), 32 (SDXL). Maior = mais detalhe, arquivo maior. network_alpha ≈ metade do network_dim; igual ao dim imita o LoRA antigo.

Otimizador — AdamW8bit (8-bit via bitsandbytes) reduz a memória pela metade. Alternativas: Lion, DAdaptation, Adafactor (docs do Kohya-ss).

Precisão mista + gradient checkpointing — --mixed_precision="bf16" (SDXL) ou "fp16" (SD 1.5) reduz a VRAM pela metade. --gradient_checkpointing troca velocidade por VRAM. SDXL: --cache_latents + --cache_text_encoder_outputs; o caching do codificador de texto força --network_train_unet_only.

Multi-LoRA — ComfyUI LoRA Stack (comfyroll). Força: ~0,6 múltiplo, 0,7–0,8 único. Forças negativas suportadas.

Ambientes de treinamento gratuitos

Notebooks Colab da hollowstrawberry

Notebooks prontos para rodar: Dataset Maker, Lora Trainer, XL Lora Trainer. GPUs T4 gratuitas; XL suporta A100 quando disponível. Persistência no Google Drive.

Dataset Maker: raspagem de Gelbooru → deduplicação com FiftyOne → tagging WD14 → captioning BLIP → um clique para o Lora Trainer.

Civitai 1591 (guia SDXL do malcolmrey) observa que o SDXL precisa de mais VRAM do que a maioria dos usuários tem localmente — Colab em nuvem ou GPU paga (RunPod) é prático. T4 gratuito continua sendo a entrada mais barata.

Local: kohya-ss/sd-scripts

Repositório no GitHub (licença Apache 2.0) — LoRA, LoCon/LyCORIS, textual inversion, fine-tuning. Instale com Python 3.10.x e Git. Treinamento via CLI. Referência completa de train_network.py nos docs.

Erros comuns e correções

Sintoma | Causa | Correção | Source

|---------|-------|-----|--------

LoRA fraco/nenhum efeito | LR muito baixo ou < 8 épocas | Aumente o LR em direção a 1e-4 ou eleve as épocas para 8+ | rulles (Civitai 60) Imagens lavadas | VAE inativo | Ative o VAE; verifique Quicksettings no A1111 | rulles (Civitai 60) UI trava com LoRA | Arquivo corrompido | Rebaixe do Civitai; modelo base correto | rulles (Civitai 60) OOM durante o treinamento | MP/GC desativados | Adicione --mixed_precision="bf16"/"fp16" + --gradient_checkpointing | kohya-ss train_network.md LoRA do codificador de texto congelado | --cache_text_encoder_outputs desabilita | Remova a flag ou adicione --network_train_unet_only | kohya-ss sdxl_train_network.md Sobreajuste em força 1,0 | Potência total em LoRA(s) único(s) ou empilhado(s) | Reduza para ~0,6 múltiplo / ~0,7–0,8 único | rulles (Civitai 60) Pouco detalhe em alta resolução | network_dim baixo / resolução alta | Aumente network_dim de 16 para 32+; reduza a resolução | kohya-ss train_network.md

Perguntas Frequentes (FAQ)

Quantas imagens? 20 no mínimo. Closeups de rosto, corpo inteiro, ângulos variados. Mais ajuda, mas 20 é o baseline.

Qual taxa de aprendizado? 1e-4 UNet / 1e-5 codificador de texto (kohya-ss train_network.md). Travado → 2e-4; instável → 5e-5.

O que são network_dim / network_alpha? network_dim 4–128. 16 (SD 1.5), 32 (SDXL). network_alpha ≈ metade do network_dim.

Como legendar? DreamBooth: WD14 Tagger (tags por vírgula). Fine-tune: BLIP (frases). Ambos em Colab da hollowstrawberry e nos scripts kohya-ss.

Treinamento gratuito no Colab? Sim. Lora Trainer da hollowstrawberry na T4 gratuita. VRAM da T4 limitada → SDXL funciona com restrições de batch e resolução.

LoRA vs LoCon? LoRA = padrão. LoCon = mais preciso para estilos, precisa do a1111-sd-webui-lycoris para carregar no WebUI. kohya-ss treina LoCon nativamente.

Força máxima de LoRA? Sem teto rígido. Comunidade: ~0,6 múltiplo, ~0,7–0,8 único. 1,0 pode causar overfitting. De Civitai 60.

Quantas épocas? 8–12. <8 = fraco; >12 = platô/sobreajuste. Uma época = uma passagem completa do dataset.

Como usar o WD14 tagger? Roda finetune/tag_images_by_wd14_tagger.py com --onnx. Exemplo nos docs: SmilingWolf/wd-swinv2-tagger-v3; padrão: SmilingWolf/wd-v1-4-convnext-tagger-v2. Em Colab da hollowstrawberry.

O que ainda não foi verificado

• Requisitos exatos de VRAM para treino LoRA SD1.5 vs SDXL — fontes verificadas confirmam que SDXL precisa de mais VRAM, mas o limite específico em GB não está declarado.
• Preços/specs concretos do RunPod — o fonte 1591 menciona, mas não declara custos ou specs mínimas.
• Conteúdo da página do modelo Civitai do malcolmrey (artigo 7) e dos dois guias Rayment (?) — URLs confirmados, corpos inacessíveis.
• Se o plano gratuito T4 do Colab provê VRAM suficiente para todo o fluxo SDXL — os notebooks da hollowstrawberry suportam T4, mas o guia de treinamento SDXL sugere GPU paga como prático.
• Strings de erro reais de primeiras tentativas de treinamento — nenhuma apareceu em fontes verificadas.

Sources

1. https://github.com/kohya-ss/sd-scripts
2. https://github.com/hollowstrawberry/kohya-colab/blob/main/README.md
3. https://huggingface.co/hollowstrawberry/stable-diffusion-guide
4. https://civitai.com/articles/7
5. https://civitai.com/articles/60
6. https://civitai.com/articles/1591
7. https://civitai.com/articles/6831