ArtificialGuyBR

Home / Blog / Training LoRAs

Guia de Textual Inversion 2025: Embeddings vs LoRAs

Quando usar Textual Inversion em vez de LoRA, ajustes do Kohya_ss e A1111, e a diferença de taxa de aprendizado explicada.

10 sources cited Training LoRAs

On this page

  1. TL;DR
  2. Quando um embedding ainda vence um LoRA
  3. Como a Textual Inversion funciona
  4. Treinando no Kohya_ss (SD 1.5 / SDXL)
  5. Treinando na WebUI A1111
  6. Usando o embedding treinado
  7. Erros comuns e correções
  8. FAQ
  9. Resumo de suporte por modelo
  10. Sources

Guia de treino de Textual Inversion 2025: Embeddings vs LoRAs

O resultado é um arquivo .safetensors minúsculo (normalmente 10–50 KB) que você joga na sua pasta embeddings e invoca pelo nome do arquivo nos prompts Kohya_ss TI docs.

Textual inversion new token → existing weights Learns a vector in token space. Model weights untouched. Kilobytes. Portable inside one base. LoRA low-rank delta → the weights Learns a change to the weights. Alters how the model computes. Megabytes. Tied to its base. Both steer output, at different layers of the stack. Rule of thumb: an embedding can name a thing the model already knows; a LoRA can teach it something new.
Embedding vs LoRA: what each one actually changes

Como o treino de LoRA difere do TI — os dois métodos se complementam para casos de uso diferentes.

TL;DR

  • Use embeddings para: sujeitos, estilos ou objetos únicos onde tamanho de arquivo e portabilidade entre modelos mais importam
  • Use LoRAs para: personagens complexos, composições multicconceito, ou quando você precisa de fidelidade maior
  • Treine em modelos base SD 1.5 ou SDXL originais — embeddings treinados em finetunes raramente transferem bem A1111 wiki
  • O Kohya_ss suporta TI para SD 1.x/2.x e SDXL apenas — não existe suporte a TI para FLUX ou SD3 Kohya_ss FLUX docs

Quando um embedding ainda vence um LoRA

Cenário | Por que o TI vence | Source

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

Portabilidade entre modelos | TI treinado em modelo base original funciona na maioria dos finetunes | A1111 wiki VRAM limitada | Só os embeddings de token são atualizados; U-Net e VAE ficam congelados | Kohya_ss docs Iteração rápida | 1.000–2.000 passos típicos para TI | Kohya_ss docs Transferência de estilo | --use_style_template isola a estética sem viés de sujeito | Kohya_ss docs

Embeddings brilham quando você precisa de um token de conceito portátil que funciona entre modelos derivados da mesma base. LoRAs ainda ganham para cenas com múltiplos sujeitos e controle preciso de pose.

Como a Textual Inversion funciona

O TI adiciona um token de placeholder especial ao tokenizer (ex.: <mychar>), expande a matriz de embeddings em uma linha e então congela o modelo inteiro — U-Net, VAE e codificador de texto — enquanto otimiza apenas essa nova linha. Durante o treino, cada imagem é emparelhada com um template de prompt que contém o placeholder. O gradiente flui pelo codificador de texto congelado até o novo vetor de embedding, empurrando-o até o modelo reconstruir as imagens de treino quando provocado.

O mecanismo é específico do modelo por design. A dimensão do embedding, o vocabulário do tokenizer e a arquitetura do codificador de texto são fixos por família de modelo. O SD 1.5 usa um codificador CLIP-L de 768 dimensões; o SDXL usa codificadores duplos CLIP-L/CLIP-G; FLUX e SD3 usam arquiteturas transformer completamente diferentes Gal et al. 2022. É por isso que um embedding de TI treinado no SD 1.5 não carrega no SDXL ou FLUX — o espaço de IDs de token e as dimensões de embedding não batem.

Treinando no Kohya_ss (SD 1.5 / SDXL)

Pré-requisitos

  • Repositório Kohya_ss sd-scripts clonado e ambiente configurado
  • Dataset preparado (15–25 imagens quadradas em 512×512 para SD 1.5, 1024×1024 para SDXL) Desi_Cafe tutorial
  • Checkpoint de modelo base original (não um finetune)

Parâmetros principais

Parâmetro | Valor recomendado | Observações

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

--pretrained_model_name_or_path | caminho para v1-5-pruned-emaonly.safetensors ou base SDXL | Deve ser o modelo base original --token_string | string única como mychar123 | Não deve existir no tokenizer --init_word | palavra do conceito como woman ou cat | Múltiplas palavras permitidas (ex.: anime girl) --num_vectors_per_token | 1 (padrão) ou 4–5 para sujeitos complexos | Mais vetores = mais tokens de prompt consumidos --learning_rate | 1e-6 (docs do Kohya) ou 2e-6 (padrão do código) ou 0.005 (paper) | Veja nota sobre taxa de aprendizado --lr_scheduler | constant | --optimizer_type | AdamW8bit (preferido) ou AdamW | AdamW8bit + bf16 pode dar erro no Linux --mixed_precision | bf16 (RTX 30/40) ou fp16 | --max_train_steps | 1000–2000 | Salve checkpoints a cada 200 passos Kohya_ss TI docs --cache_latents | habilitado | Reduz VRAM significativamente --use_object_template | habilitado (para sujeitos) | Ignora arquivos de legenda --use_style_template | habilitado (para estilos) | Ignora arquivos de legenda

Discrepância na taxa de aprendizado

Três valores circulam na comunidade:

  • 0.005 — usado no paper original de Gal et al. 2022 com Adam original em fp32, 3–5 imagens Gal et al. 2022
  • 1e-6 — recomendação da documentação do Kohya_ss para AdamW8bit, fp16/bf16, datasets maiores Kohya_ss TI docs
  • 2e-6 — padrão do código do Kohya_ss (padrão de --learning_rate em library/args.py) Kohya_ss args.py

Todos produzem embeddings funcionais. O valor 0.005 reproduz a configuração do paper; 1e-6/2e-6 levam em conta o otimizador, a precisão e os tamanhos de dataset típicos do Kohya_ss. Comece em 1e-6 e aumente apenas se a convergência travar.

Comando de exemplo (SD 1.5)

accelerate launch --num_cpu_threads_per_process 2 train_textual_inversion.py \
  --pretrained_model_name_or_path="models/Stable-diffusion/v1-5-pruned-emaonly.safetensors" \
  --train_data_dir="data/mychar" \
  --output_dir="output/mychar" \
  --output_name="mychar-ti" \
  --save_model_as=safetensors \
  --token_string="mychar123" \
  --init_word="woman" \
  --num_vectors_per_token=5 \
  --learning_rate=1e-6 \
  --lr_scheduler="constant" \
  --optimizer_type="AdamW8bit" \
  --mixed_precision="bf16" \
  --cache_latents \
  --use_object_template \
  --vae="models/VAE/vae-ft-mse-840000-ema-pruned.safetensors" \
  --max_train_steps=1000 \
  --save_every_n_steps=200

Para SDXL, use sdxl_train_textual_inversion.py com --resolution=1024,1024 e o checkpoint base SDXL Kohya_ss TI docs.

Tutorial passo a passo de treino de LoRA — se você decidir que LoRA se encaixa melhor no seu caso de uso.

Treinando na WebUI A1111

  1. Abra a aba Textual Inversion
  2. Criar embedding: dê um nome, defina o texto de inicialização (ex.: woman), escolha os vetores por token (1–16) A1111 wiki
  3. Pré-processar: aponte para as imagens de origem, habilite "Create flipped copies" para aumento de dados
  4. Treinar: selecione o embedding, defina a taxa de aprendizado (padrão 0.005), passos máximos (1.000–5.000), diretório de log A1111 wiki
  5. Template: use subject.txt para objetos/pessoas, style.txt para estéticas
  6. Iniciar treino — monitore a loss e as imagens de prévia

O A1111 suporta agendamento da taxa de aprendizado via sintaxe de prompt: 0.005:100, 1e-3:1000, 1e-5 reduz a LR nos passos especificados. A1111 wiki

Usando o embedding treinado

  1. Copie o arquivo .safetensors para stable-diffusion-webui/embeddings/
  2. Não é preciso reiniciar — o embedding carrega imediatamente
  3. Nos prompts, use o nome do arquivo (sem extensão) como token: photo of mychar-ti
  4. Pese como qualquer token: (mychar-ti:1.2) aumenta a influência

Guia de embeddings negativos e ponderação de tokens — combine seu embedding treinado com a ponderação correta para melhores resultados.

Erros comuns e correções

Sintoma | Causa | Correção

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

Loss: nan | Taxa de aprendizado alta demais | Reduza para 1e-6 ou menos; use scheduler constant Kohya_ss TI docs Token string already exists in tokenizer | Placeholder colide com o vocabulário | Adicione números/caracteres especiais: mychar123, <mychar> CUDA setup error com AdamW8bit + bf16 | Incompatibilidade da plataforma Linux | Troque para AdamW + bf16 ou AdamW8bit + fp16 Embedding funciona só no modelo de treino | TI é específico do modelo por design | Treine em modelo base original para melhor portabilidade Sem melhora após 500+ passos | String de token ausente nas legendas/templates | Garanta que --use_object_template esteja habilitado ou que o token apareça nas legendas Kohya_ss TI docs Artefatos de overtraining em 1.300+ passos | Passos demais para o tamanho do dataset | Pare em 800–1.000 passos; use um checkpoint anterior Desi_Cafe tutorial

FAQ

Quando devo usar um embedding em vez de um LoRA? Use embeddings quando o tamanho do arquivo importa (compartilhar, mobile), você precisa de portabilidade entre modelos, ou está treinando um único sujeito/estilo com VRAM limitada. LoRAs lidam melhor com cenas multicconceito e fidelidade maior.

Qual taxa de aprendizado é melhor para textual inversion? Comece em 1e-6 com o Kohya_ss (AdamW8bit, fp16/bf16). Use 0.005 apenas se reproduzir a configuração do paper original (Adam original, fp32, 3–5 imagens) Gal et al. 2022. Ambos convergem; 1e-6 é mais seguro para datasets maiores.

Posso usar embeddings entre diferentes modelos Stable Diffusion? Apenas dentro da mesma família de arquitetura. Um embedding SD 1.5 funciona na maioria dos finetunes SD 1.5, mas não no SDXL, SD3 ou FLUX. Cada família de modelo precisa do seu próprio treino de TI. O diffusers não tem TI para FLUX ou SD3 HuggingFace diffusers TI e o Kohya_ss não tem TI para FLUX Kohya_ss FLUX docs.

Quantas imagens de treino preciso para textual inversion? O paper original mostrou que 3–5 imagens bastam Gal et al. 2022. A prática da comunidade usa 15–25 para robustez. Mais imagens exigem proporcionalmente mais passos.

Textual inversion funciona com SDXL ou FLUX? SDXL: sim, via sdxl_train_textual_inversion.py. FLUX e SD3: não — suas arquiteturas transformer não têm implementações de TI no Kohya_ss ou no diffusers. Kohya_ss FLUX docs HuggingFace diffusers TI

Por que meu embedding não funciona em outros modelos? O TI se vincula ao tokenizer e ao codificador de texto de um modelo específico. Finetunes que modificam o codificador de texto (ex.: CLIP skip, modelos mesclados) quebram a compatibilidade. Treine na base original para portabilidade máxima.

O que faz o --num_vectors_per_token? Cada vetor consome um token do limite de 77 tokens do prompt. O padrão é 1. Valores 4–5 capturam sujeitos complexos melhor, mas reduzem o espaço de prompt. O paper concluiu que um único vetor muitas vezes basta Gal et al. 2022.

Resumo de suporte por modelo

Família de modelo | Suporte a TI | Script | Source

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

SD 1.x / 2.x | Sim | train_textual_inversion.py | Kohya_ss TI docs SDXL | Sim | sdxl_train_textual_inversion.py | Kohya_ss TI docs SD 3 / 3.5 | Não | Apenas LoRA | Kohya_ss FLUX docs FLUX.1 | Não | Apenas LoRA | Kohya_ss FLUX docs HunyuanImage | Não | Apenas LoRA | Kohya_ss LoRA docs Anima | Não | Apenas LoRA | Kohya_ss LoRA docs

Para SD3, FLUX e arquiteturas mais novas, o LoRA continua sendo a única opção de personalização no Kohya_ss.

Sources

  • Kohya_ss Textual Inversion documentation — https://github.com/kohya-ss/sd-scripts/blob/main/docs/train_textual_inversion.md
  • Kohya_ss train_textual_inversion.py source — https://github.com/kohya-ss/sd-scripts/blob/main/train_textual_inversion.py
  • Kohya_ss shared args module — https://github.com/kohya-ss/sd-scripts/blob/main/library/args.py
  • A1111 WebUI Textual Inversion wiki — https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/Textual-Inversion
  • Gal et al. 2022 "An Image is Worth One Word" — https://arxiv.org/abs/2208.01618
  • Desi_Cafe Kohya_ss Dreambooth TI tutorial — https://civitai.com/articles/618
  • Malcolm Rey Textual Inversion training guide — https://civitai.com/articles/3114
  • HuggingFace diffusers Textual Inversion training — https://huggingface.co/docs/diffusers/en/training/text_inversion
  • Kohya_sd-scripts FLUX docs (no TI support) — https://github.com/kohya-ss/sd-scripts/blob/main/docs/flux_train_network.md
  • Kohya_sd-scripts LoRA training guide (shared args reference) — https://github.com/kohya-ss/sd-scripts/blob/main/docs/train_network.md