Como funcionam os LoRAs e como usá-los no Stable Diffusion

Um LoRA (Low-Rank Adaptation) é um pequeno patch que modifica modelos Stable Diffusion sem substituí-los. Em vez de baixar um checkpoint inteiramente novo, você carrega um arquivo LoRA que injeta ajustes treináveis em camadas específicas. Este artigo explica a matemática por trás dos LoRAs, como controlar sua força e como combiná-los ao seu modelo base.

Para um guia prático sobre preparar seu primeiro dataset e treinar, veja nosso tutorial treine seu primeiro LoRA gratuitamente. Se você está montando uma biblioteca de estilos, nosso guia gerenciamento de biblioteca de LoRAs cobre organização e versionamento. Para dicas específicas de SDXL, veja dicas de LoRA fotorealista para SDXL.

TL;DR

• Matemática: A fórmula principal é $h = W_0 x + BAx$, onde $W_0$ é o peso original congelado e $BA$ é a atualização treinável
• Controle de força: Peso na inferência (ex.: <lora:model:0.7>) controla o efeito do LoRA
• Empilhamento: Vários LoRAs somam seus efeitos (encadeie nós no ComfyUI ou use set_adapters no Diffusers)
• Compatibilidade: Combine a arquitetura do LoRA às dimensões do modelo base (SDXL vs SD 1.5)
• Instalação: models/loras/ para ComfyUI, models/Lora/ para AUTOMATIC1111

Como o LoRA funciona no momento da inferência

Fundamentos matemáticos

Ao carregar um LoRA, você não substitui os pesos do modelo base. Você adiciona pequenos ajustes treináveis a eles.

A atualização segue uma fórmula simples:

$$h = W_0 x + BAx$$

Cada termo:

• $W_0$: A matriz de pesos original do seu modelo base. Ela permanece congelada—nunca muda durante treinamento ou inferência.
• $x$: Ativações de entrada (de embeddings de texto ou camadas intermediárias).
• $B$: Primeira matriz de baixo posto. Formato: dimensão de saída × rank (ex.: dmodel × r).
• $A$: Segunda matriz de baixo posto. Formato: rank × dimensão de entrada (ex.: r × dmodel).
• $BA$: A atualização treinável. Multiplicar essas matrizes gera uma aproximação de posto r da atualização completa que seria treinada no fine-tuning.

O artigo original do LoRA constatou que os pesos dos modelos vivem em uma variedade de baixa dimensão intrínseca, o que significa que atualizações de peso podem ser representadas com muito menos parâmetros que os pesos originais.

"Nós hipotetizamos que a mudança nos pesos durante a adaptação do modelo também tem um baixo 'posto intrínseco' durante a adaptação." — https://arxiv.org/abs/2106.09685

Por que isso importa para o Stable Diffusion

Para as camadas de atenção do UNet do Stable Diffusion, matrizes de peso padrão são de posto completo (ex.: 768×768 para SDXL). Em vez de atualizar 768² parâmetros, o LoRA atualiza apenas r×768 + 768×r = 1536r parâmetros.

Com r = 8, isso dá 12,288 parâmetros treináveis contra 589,824 pesos de posto completo—uma redução de 48×.

"Na inferência: latência adicional zero versus um modelo totalmente fine-tuned por construção." — https://arxiv.org/abs/2106.09685

A maioria das UIs funde o LoRA permanentemente no modelo base durante o carregamento. A atualização $W_0 + BA$ é calculada uma vez e armazenada como novos pesos. Isso elimina sobrecarga de tempo de execução—pesos fundidos são parâmetros normais do modelo sem custo adicional de memória.

Controles de força: alfa versus peso

Confundir "alfa" e "peso" é o erro mais comum ao usar LoRAs. Eles operam em níveis diferentes:

Alfa no treinamento (α):

• Faz parte dos hiperparâmetros de treinamento (kohya-ss: --network_alpha, padrão 1; PEFT: lora_alpha, padrão igual ao rank)
• Controla o escalonamento da taxa de aprendizado durante o treinamento: (α/r) escala a atualização
• Referência: https://github.com/kohya-ss/sd-scripts/blob/main/docs/train_network.md

Peso na inferência (o número em <lora:model:1>):

• Multiplicador aplicado em tempo de execução a toda a atualização ΔW = BA
• Peso = 1 → efeito total do LoRA
• Peso = 0 → nenhum efeito (modelo base puro)
• Peso = 0.5 → metade do efeito

O paper original define escalonamento como (α/r)·BA. Implementações diferentes lidam com isso de forma diferente—o repositório cloneofsimo sugere que o peso de inferência substitui o escalonamento de alfa inteiramente, enquanto outras implementações multiplicam ambos.

Como vários LoRAs se empilham

Quando você aplica vários LoRAs, seus efeitos somam:

$$h = W_0 x + \frac{\alpha_1}{r_1} B_1 A_1 x + \frac{\alpha_2}{r_2} B_2 A_2 x$$

Se dois LoRAs miram a mesma camada de atenção (ex.: ambos modificam Wq), suas atualizações somam.

Encadeando LoRAs

ComfyUI: Encadeie nós LoraLoader sequencialmente:

LoraLoader node 1 → LoraLoader node 2 → [...]

Cada nó adiciona suas próprias matrizes de baixo posto aos pesos base. Referência: https://comfyanonymous.github.io/ComfyUI_examples/lora/

Diffusers: Use set_adapters() para controle ponderado:

pipeline.set_adapters(["style1", "style2"], adapter_weights=[0.7, 0.8])

Parâmetros de configuração LoRA (rank, lora_alpha, escala de inicialização): https://huggingface.co/docs/peft/main/en/conceptual_guides/lora

"LoRA é ortogonal a muitos outros métodos eficientes em parâmetros e pode ser combinado com muitos deles, como prefix-tuning." — https://arxiv.org/abs/2106.09685

Combinando LoRAs ao modelo base

Matrizes LoRA são moldadas para corresponder às dimensões de arquitetura do modelo base em que foram treinadas. Um LoRA SD1.5 tem matrizes B/A dimensionadas para as dimensões de atenção do UNet do SD1.5; um LoRA SDXL tem dimensões maiores.

Exemplos de incompatibilidade de arquitetura:

• LoRA SDXL → base SD1.5: ❌ incompatibilidade de dimensão de matriz
• LoRA SD1.5 → base SD1.5: ✅ dimensões compatíveis

"LoRAs também precisam ser usadas com outro modelo." — https://huggingface.co/docs/diffusers/main/en/using-diffusers/loading_adapters

Diferentes modelos base também têm números variados de camadas de atenção e podem miram tipos de camada diferentes (self-attention versus cross-attention).

Onde instalar arquivos LoRA

UI | Caminho

|---|---

ComfyUI | models/loras/ AUTOMATIC1111 / Forge | models/Lora/ Diffusers (código) | Qualquer caminho; carregado via load_lora_weights("path/to/loras") Treinamento kohya-ss | Definido por --output_dir Referência: https://comfyanonymous.github.io/ComfyUI_examples/lora/

Erros comuns e correções

Erro | Causa provável | Correção

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

LoRA não tem efeito visível | Peso definido como 0 ou LoRA não ativado na UI | Verifique a sintaxe <lora:nome:1>; confirme peso > 0 Erro de incompatibilidade de arquitetura | LoRA SDXL carregado em modelo SD1.5 (ou vice-versa) | Verifique se o modelo base corresponde à arquitetura de treino do LoRA Segundo LoRA sobrescreve o primeiro | Empilhamento não habilitado na UI | Encadeie nós LoraLoader (ComfyUI) ou use set_adapters() (Diffusers) Erro de arquivo corrompido | Download incompleto ou formato incorreto | Baixe novamente o arquivo .safetensors de uma fonte confiável

Perguntas frequentes (FAQ)

Quanta VRAM um LoRA adiciona? As matrizes LoRA são pequenas (1–6 MB para baixo rank, até ~200 MB para ranks maiores). O modelo base carrega normalmente. Depois da fusão, não há custo adicional de VRAM.

Posso aplicar LoRAs a camadas que não são de atenção? Em princípio, LoRA pode miar qualquer matriz de peso. Na prática, a maioria dos LoRAs para SD miram apenas camadas de atenção (Wq, Wk, Wv, Wo). O kohya-ss suporta camadas Conv2d via LoRA-C3Lier (referência: https://github.com/kohya-ss/sd-scripts/blob/main/docs/train_network.md).

Qual é o rank ideal para LoRAs? O paper original testou ranks 4–8 para modelos de linguagem. Para SD, ranks 8–128 são comuns; ranks menores (4–16) trocam qualidade por velocidade e eficiência de VRAM.

Quantos LoRAs posso empilhar? Não há limite rígido. Cada LoRA adiciona pequenas matrizes às mesmas camadas. Retornos decrescentes aparecem quando mais LoRAs modificam as mesmas matrizes de peso, mas o empilhamento prático de vários LoRAs é comum.

Preciso de software especial para usar LoRAs? Qualquer UI que suporte LoRAs funciona—AUTOMATIC1111, ComfyUI, Forge e Diffusers lidam com eles nativamente.

Como saber se um LoRA funciona com meu modelo base? Verifique o cartão do modelo ou a descrição. A maioria lista modelos base compatíveis (ex.: "SDXL v1.0 base", "SD 1.5"). Em caso de dúvida, inspecione as dimensões do arquivo .safetensors.