Mesclar checkpoints do Stable Diffusion: métodos e pesos por bloco

TL;DR

• Escolha o método pelo objetivo: Soma Ponderada (Weighted Sum) mistura dois modelos numa linha; Add Difference injeta a direção aprendida de um modelo em outro; pesos por bloco definem a proporção por estágio do U-Net para pegar rostos de um modelo mantendo a iluminação de outro.
• Sum Twice usa β como peso do terceiro modelo, não α·β. A operação é uma mistura aninhada — lerp(lerp(A,B,α),C,β) — então o terceiro modelo entra com peso β. Vários guias da comunidade erram isso como α·β.
• Merge roda na CPU e produz um checkpoint independente; um LoRA é modificador de runtime que não roda sozinho. Use merge quando quiser um modelo autocontido; use LoRA para trocar efeitos na hora.

Mesclar dois ou mais checkpoints do Stable Diffusion mistura os pesos treinados com aritmética — sem GPU, sem dados de treino, sem otimizador — e gera um novo arquivo .safetensors. As ferramentas principais — o mergor integrado do AUTOMATIC1111, o SuperMerger, o Chattiori Model Merger e o kohya-ss — compartilham a mesma matemática central. Os exemplos visam SDXL; SD 1.5…

Os quatro métodos de merge que importam

Método | Fórmula | Precisa | Melhor para

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

Soma Ponderada (WS) | (1−α)A + αB | 2 modelos, α | Mesclar dois modelos similares | CMM, A1111 Add Difference (AD) | A + α(B − C) | 3 modelos, α | Enxertar conceito de B em A, usando C como base | CMM, A1111 Triple Sum (TRS) | (1−α−β)A + αB + βC | 3 modelos, α, β | Misturar três modelos com proporções independentes | CMM, SuperMerger Sum Twice (ST) | (1−β)((1−α)A + αB) + βC | 3 modelos, α, β | Mistura em dois estágios: mistura A e B, depois incorpora C | CMM, SuperMerger

Qual a diferença entre Soma Ponderada e Add Difference?

Soma Ponderada interpola linearmente entre dois modelos — em α=0 a saída é modelo A, em α=1 é modelo B. AUTOMATIC1111 define como A * (1 - M) + B * M; o merge.py do CMM implementa com torch.lerp(A, B, alpha) — mesma operação sob bandeira diferente.

Add Difference usa três modelos. Escala o vetor de C para B por α e soma sobre A — A + (B - C) * M. Use quando um modelo base já tem o visual que você quer e quer enxertar um conceito sem diluir a base.

Por que Sum Twice não é o mesmo que Triple Sum

Ambos usam três modelos e duas proporções, mas diferem na estrutura.

Triple Sum mistura os três de uma vez: A mantém peso 1−α−β, B recebe α, C recebe β. Sum Twice mistura duas vezes — primeiro A e B em α, depois o resultado intermediário com C em β. O código do CMM torna a estrutura aninhada explícita:

def sum_twice(theta0, theta1, theta2, alpha, beta):
    out = torch.empty_like(theta0)
    torch.lerp(theta0, theta1, float(alpha), out=out)   # out = lerp(A,B,alpha)
    torch.lerp(out,   theta2, float(beta),  out=out)    # out = lerp(out,C,beta)
    return out

Expandindo o segundo lerp mostra que o terceiro modelo entra com peso β, não α·β. A documentação do SuperMerger concorda, publicando a fórmula como $(1-\beta)((1-\alpha)A+\alpha B)+\beta C$. Alguns guias da comunidade escrevem o coeficiente de C como α·β — isso só valeria se o segundo lerp usasse α·β como proporção, e ele usa β. Ao ajustar um merge Sum Twice, trate β como o controle de quanto o modelo C aparece.

Pesos por bloco: direcionando o merge por estágio do U-Net

Um alpha plano aplica a mesma proporção a todo tensor. Merge com pesos por bloco — "MBW" no SuperMerger, string de 20 valores no CMM — define proporção diferente para cada bloco do U-Net, então um bloco pode tender ao modelo A enquanto outro tende ao B.

O que os blocos IN, OUT, MID e BASE controlam?

O U-Net do Stable Diffusion é uma pilha de estágios, e um merge com pesos por bloco os endereça um a um. A ordem oficial de blocos para SDXL é:

BASE, IN00, IN01, IN02, IN03, IN04, IN05, IN06, IN07, IN08, MID00, OUT00, OUT01, OUT02, OUT03, OUT04, OUT05, OUT06, OUT07, OUT08

São 20 valores para SDXL; SD 1.5 e 2.x chegam a 26 (IN00–IN11 e OUT00–OUT11). BASE é o text encoder; IN, MID e OUT são estágios de downsampling, gargalo e upsampling do U-Net. O SuperMerger resume o ganho: "cada bloco pode corresponder a representação de fundo, personagens, estilo artístico, etc., você pode criar vários modelos mesclados mudando a proporção de cada bloco."

Em grão mais fino, as notas de elemental-merge do SuperMerger destacam as camadas de atenção: "attn é responsável por informação de rosto e roupa. As camadas IN07, OUT03, OUT04 e OUT05 parecem ter influência particularmente forte." Além disso, tabelas precisas de papel por bloco (ex.: "IN00 controla dedos") vêm de praticantes individuais e não são documentadas oficialmente — trate como pontos de partida para testar, não fato estabelecido.

Escrevendo um vetor de pesos por bloco

No CMM o argumento alpha aceita string separada por vírgula nessa ordem de blocos. Exemplo Sum Twice com 20 valores:

CM A + B +S C "0,1,1,0.2,0.2,0.3,0.3,0,0,0,0,0.2,0.1,0.1,0.1,0.4,0.4,0.4,0.4,0.4" \
   "0,0,0,0.3,0.3,0.2,0.2,0.3,0,0,0,0.1,0.1,0.1,0.2,0.2,0.2,0.2,0.2,0.2" Result

Aqui BASE e os primeiros blocos IN tendem a B, os IN posteriores e MID ficam perto de A, e os blocos OUT puxam C — padrão para manter anatomia de um modelo emprestando acabamento de outro.

Quando mesclar vs usar LoRA

Quando devo mesclar dois checkpoints em vez de treinar ou usar LoRA?

Merge produz checkpoint autocontido sem arquivo adapter. LoRA (Low-Rank Adaptation) congela pesos base e injeta duas matrizes pequenas de baixo rank por camada adaptada, aplicado sobre checkpoint na inferência. O paper original do LoRA mostra redução de parâmetros treináveis de ~10.000× para modelos grandes; na prática um LoRA de Stable Diffusion tem 2–200 MB contra 2–7 GB do checkpoint — "geralmente 10 a 100 vezes menor," segundo o guia do stable-diffusion-art.

Essa diferença de tamanho é o fator decisivo. Use merge quando quiser modelo único que "funciona direto" sem ajustar peso de LoRA a cada prompt — mix de personagem, fusão de estilo permanente, ou base para redistribuir. Use LoRA quando quiser aplicar efeitos na hora, testar muitos estilos sem guardar checkpoints completos, ou empilhar vários modificadores numa imagem. Como LoRA "não pode ser usado sozinho" e "precisa ser usado com arquivo de checkpoint do modelo," é ferramenta errada quando o objetivo é entregável independente.

Assando (baking) LoRA num checkpoint

As duas abordagens se encontram no "bake". Merge-to-Checkpoint do SuperMerger e lora_bake.py do CMM (o Universal Model Merge Scripter operador LB) dobram um ou mais LoRAs permanentemente nos pesos do checkpoint, com proporções que "podem ser qualquer valor, inclusive negativos. Não há restrição que o total deve somar 1." Baking troca flexibilidade de runtime por modelo autocontido. Para treino de LoRA, veja guia grátis de treino LoRA e referência de parâmetros Flux LoRA.

DARE: drop e rescale de parâmetros delta

O que é DARE merge e por que dropa e resescala parâmetros?

DARE (Drop And REscale) vem do paper de modelo de linguagem "Language Models are Super Mario" e foi adaptado para Stable Diffusion pelo repositório safetensors-merge-supermario (implementação de referência do paper é MergeLM). Zera aleatoriamente fração p dos parâmetros delta (diferença entre pesos de dois modelos) e resescala os sobreviventes por $1/(1-p)$ para preservar magnitude global da camada.

O raciocínio do paper é específico a fine-tuning supervisionado: SFT muda poucos parâmetros, com magnitudes pequenas, e a maior parte da mudança é redundante. Remover 90% ou até 99% desses deltas e resescalar o resto "aproximadamente preserva os embeddings originais." Duas cautelas seguem:

• Rescaling é obrigatório. "A operação de rescale é crucial para garantir sucesso do DARE, e dropar 30% ou 40% dos parâmetros delta sem rescaling levaria a resultados visivelmente piores."
• DARE assume deltas pequenos. O paper reporta deltas de SFT tipicamente dentro de ~0.002, e avisa que "quando modelos passam por pre-training contínuo, os parâmetros delta podem rapidamente chegar a ~0.03, tornando DARE inviável." A adaptação para modelos de imagem aplica a mesma aritmética a (model1 − model0), mas a garantia de poda 90–99% foi medida em tarefas de linguagem, não checkpoints de difusão — não assuma que as mesmas taxas valem.

No CMM o operador +D mapeia para modo DARE, com alpha como força da mistura e beta como probabilidade de drop p, reproduzível via --seed.

Preciso de GPU para mesclar checkpoints do Stable Diffusion?

Não. Merge é aritmética pura de pesos — soma, escala, lerp — rodada chave por chave sobre state dicts, sem forward pass, dados ou otimizador. CMM "roda em CPU por padrão (GPU opcional)," e o paper do DARE descreve o método como precisando "sem GPUs." A restrição real é memória: autor do SuperMerger nota "mínimo de 64GB de RAM de CPU exigidos para merge de modelo XL," e rodar outros apps junto com merge grande de SDXL pode desestabilizar o sistema.

Erros comuns e correções

Sintoma | Causa | Correção

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

Modelo mesclado parece "queimado" ou super-saturado após vários passos Add Difference | Empilhar diferenças grandes (B−C) em α alto acumula interferência destrutiva | Troque para smoothAdd (add difference filtrado Median+Gaussian), ou baixe α; smoothAdd em α=1 é mais fraco que Add normal, então α pode subir para 2 | SuperMerger calcmode trainDifference distorce modelo alvo | Base real do modelo é mix desconhecido (ex.: SD1.4/1.5), então "treino" medido do ancestral errado | Use trainDifference só na direção onde base de pré-treino real do modelo é conhecida | SuperMerger calcmode Prompts simples "vazam" conceito (ex.: "olhos azuis" tinge imagem toda) após muitos merges | Treino acumulado torna compreensão CLIP/text-encoder "pesada" | Separe modelo mesclado em clipA (clip base) e clipB (clip treinado) e some ponderado para suavizar CLIP | SuperMerger calcmode

DARE degrada em taxas altas de drop | Rescaling ficou desligado | Sempre resescale por $1/(1-p)$; drop-only piora resultados visivelmente | DARE paper

Como avaliar modelo mesclado

Não há score automatizado para "este merge é bom." O fluxo padrão é grade XYZ: varra as proporções do merge contra prompt e seed fixos para ver visualmente como cada alpha, beta ou preset de peso por bloco muda a saída sem salvar novo checkpoint a cada vez. XYZ Plot do SuperMerger "faz geração sequencial de imagens com merge" em todos os modos de merge.

Para leitura preditiva, aba Analysis do SuperMerger quantifica diferença por bloco entre dois modelos com similaridade de cosseno, e modo "ASimilality" em tensores qkv "dá resultado mais próximo da diferença em imagens de saída." Use antes de mesclar para prever quais blocos vão se mover, depois confirme com grade XYZ usando sampler, scheduler e seed fixos (veja referência de samplers e schedulers) para que qualquer mudança visível venha do merge, não das configurações de geração.

FAQ

Qual a diferença entre Soma Ponderada e Add Difference ao mesclar checkpoints?

Soma Ponderada mistura dois modelos com (1−α)A + αB; Add Difference adiciona direção escalada A + α(B − C), usando C como base de onde B foi fine-tuned. Use WS para misturar dois modelos similares; use AD para enxertar conceito em base que quer preservar.

Por que Sum Twice dá peso β ao modelo C e não α·β?

Sum Twice é lerp aninhado: lerp(lerp(A,B,α),C,β), que expande para (1−β)((1−α)A + αB) + βC. Coeficiente de C é β, não α·β — o último só valeria se segundo lerp usasse α·β como proporção, e usa β.

O que os blocos IN, OUT, MID e BASE controlam num merge do Stable Diffusion?

BASE é o text encoder; IN, MID e OUT são estágios de downsampling, gargalo e upsampling do U-Net. SuperMerger documenta que blocos "podem corresponder a representação de fundo, personagens, estilo artístico," e que camadas de atenção mais IN07/OUT03/OUT04/OUT05 afetam fortemente rostos e roupas. Tabelas mais granulares de papel por bloco são intuição de praticantes, não documentação oficial.

Preciso de GPU para mesclar checkpoints do Stable Diffusion?

Não. Merge é aritmética nos tensores de pesos sem forward pass ou treino; CMM roda em CPU por padrão, e paper do DARE descreve método como precisando "sem GPUs." A restrição real é RAM do sistema — SuperMerger sinaliza 64 GB como mínimo para merges SDXL.

Quando devo mesclar dois checkpoints em vez de usar LoRA?

Mescle quando quiser checkpoint único autocontido — fusão de estilo permanente ou modelo que vai redistribuir. Use LoRA quando quiser trocar efeitos por prompt ou guardar espaço, já que LoRA não roda sozinho e é cerca de 10–100× menor que checkpoint.

O que é DARE merge e por que dropa e resescala parâmetros?

DARE zera fração p dos parâmetros delta entre dois modelos e resescala sobreviventes por $1/(1-p)$. O paper mostra deltas de SFT são pequenos e altamente redundantes, então a maioria pode ser removida sem perder capacidade — mas só se rescaling ligado e deltas genuinamente pequenos.

Como avalio se checkpoint mesclado é melhor que os pais?

Rode grade XYZ varrendo proporções do merge contra prompt e seed fixos, mantendo sampler, passos e CFG constantes. Para cheque preditivo, aba Analysis do SuperMerger mede similaridade de cosseno por bloco, com modo ASimilality em tensores qkv que rastreia diferença na imagem de saída.

Posso assar (bake) LoRA permanentemente num checkpoint, e como difere de merge?

Sim. Bake dobra deltas de baixo rank do LoRA nos pesos do checkpoint para rodar sem arquivo adapter; múltiplos LoRAs podem ser assados de vez com proporções que não precisam somar 1. Diferença de merge simples é a entrada — matrizes delta pequenas do LoRA vs pesos completos de dois modelos.