Parâmetros de LoRA do FLUX.1: os ajustes que importam

FLUX.1 é um transformer de difusão flow-matching de 12 bilhões de parâmetros, com dois codificadores de texto (CLIP-L, T5-XXL) e um AutoEncoder dedicado no lugar de uma VAE (diffusers, kohya). Este guia cobre os parâmetros de LoRA do FLUX.1 que importam no kohya-ss, no SimpleTuner e no ai-toolkit.

TL;DR

• Comece com rank 16, alpha 16, lr 1e-4, AdamW8bit, bf16 — os padrões do ai-toolkit para Flux; evite ranks 64–128 no modelo 12B.
• Abandone hábitos da era SD. clip_skip, min_snr_gamma e noise_offset não são parâmetros kohya nativos do Flux (docs do kohya para Flux).
• Orçamente a VRAM. Flux precisa de ~50 GB de RAM de sistema para quantizar na inicialização e ~9–30 GB de VRAM conforme a quantização (SimpleTuner); use --blocks_to_swap, --cache_text_encoder_outputs e --gradient_checkpointing.

Flux é um UNet ou um transformer?

Flux é um transformer de difusão, não um UNet (diffusers, kohya). Nomes de parâmetros da SD, como "unet learning rate" e clip_skip, não se aplicam ao Flux. Como modelo flow-matching, Flux usa --timestep_sampling (recomendado flux_shift), --model_prediction_type (recomendado raw) e --guidance_scale (1.0 para treinamento dev; 3.5 é para inferência) — conforme o guia do kohya para Flux. O ai-toolkit espelha isso com noise_scheduler: "flowmatch" (config).

Quantas imagens preciso para um LoRA do Flux?

Guias de praticantes sugerem 10–50 imagens para Flux (20–30 para estilos, 10–20 para personagens), mas esses números são relatos da comunidade; nenhum documento dos treinadores prescreve uma contagem por tipo. O único piso documentado é estrutural: o tamanho mínimo do dataset é train_batch_size * gradient_accumulation_steps, além de mais que vae_batch_size. Abaixo disso, a execução aborta com "no images detected in dataset".

A qualidade das imagens importa mais para Flux do que para SD. O SimpleTuner avisa que Flux "absorve os artefatos das suas imagens _primeiro_, e só depois aprende o conceito/assunto" — marcas d'água e artefatos de compressão corrompem o resultado mais rápido do que em um modelo menor.

Preparação de dataset e bucketing de aspecto

O bucketing por proporção de aspecto agrupa imagens por resolução para que o treinador possa colocar no mesmo batch imagens com o mesmo formato. No kohya, o passo de resolução padrão é 64 px (bucket_reso_steps = 64), e max_bucket_reso/min_bucket_reso precisam ser divisíveis por ele (docs de config do kohya); SDXL exige múltiplos de 32 (docs avançados). O estilo de crop é configurável (center/random no SimpleTuner, random_crop no kohya) — "center crop por padrão" é uma opção, não uma regra.

Nem sempre é preciso recortar antes. O ai-toolkit afirma "Você não precisa recortar/redimensionar suas imagens" — ele reduz e agrupa automaticamente. Flux é nativo em 1024px, e o exemplo do ai-toolkit treina com resolution: [512, 768, 1024] ("flux gosta de múltiplas resoluções", config). O kohya suporta o mesmo via múltiplos blocos [[datasets]] (docs do Flux §6.7).

Legendas para LoRAs do Flux

Arquivos de legenda são .txt irmãos de cada imagem. O ai-toolkit suporta um token [trigger] substituído pelo trigger_word da configuração, e traz caption_dropout_rate: 0.05 no seu exemplo para Flux. O kohya expõe shuffle_caption, keep_tokens e caption_tag_dropout_rate por subset (config TOML).

Legend tudo o que você não quer que o LoRA aprenda (meio, enquadramento, fundo), e deixe sem legenda apenas o que a palavra-gatilho deve ligar. Flux "não é muito diverso" com prompts curtos e parecidos, então o SimpleTuner recomenda prompts de validação mais longos e descritivos. Veja nosso guia de legendas para LoRAs de difusão para mais.

Qual network dim e alpha usar para um LoRA do Flux?

Configuração | Exemplo kohya Flux | Exemplo ai-toolkit Flux | Faixa comum | Fonte ---|---|---|---|--- network_dim / linear (rank) | 16 | 16 | 4–128 | kohya train_network.md, config ai-toolkit network_alpha / linear_alpha | 1 | 16 | ≈ metade do dim, ou igual ao dim | kohya train_network.md, config ai-toolkit Learning rate | 1e-4 | 1e-4 | Mais baixo que SD; 1e-3 "torra", 1e-5 "não faz nada" | SimpleTuner FLUX.md Otimizador | AdamW8bit | adamw8bit | AdamW8bit (econômico em memória, amplamente usado) | kohya train_network.md Precisão mista | fp16/bf16 | bf16 | bf16 recomendado para Flux | SimpleTuner FLUX.md Esses dois existem por causa da decomposição de rank: LoRA injeta matrizes treináveis $A$ e $B$ de modo que a atualização é $\Delta W = BA$ com rank $r \ll \min(d,k)$, e o artigo do LoRA escala $\Delta W x$ por $1/r$ para manter a atualização estável conforme $r$ cresce. Os treinadores generalizam isso para alpha (escalando por $\alpha/r$), então o padrão do kohya (alpha=1, dim=16) e o do ai-toolkit (alpha=16, dim=16) diferem em 16× na força efetiva — não são intercambiáveis. O kohya recomenda alpha "cerca de metade do valor de network_dim."

Para um modelo 12B, mantenha o rank pequeno. O SimpleTuner aconselha "Tente um network menor primeiro (rank-1, rank-4) … Ranks tão grandes quanto 64 a 128 podem ser indesejáveis em um modelo 12B." --lora_rank=4 também reduz o uso de VRAM.

Qual learning rate para treinamento de LoRA do Flux?

Use 1e-4 como ponto de partida e fique abaixo da faixa da SD. O SimpleTuner relata que em um modelo 12B "LoRA a 1e-3 pode torrar tudo. LoRA a 1e-5 quase não faz nada." (Por que um modelo 12B prefere LRs mais baixos não está documentado; trate como empírico.) O kohya divide a taxa com --text_encoder_lr 1e-4 1e-5 ao treinar codificadores de texto; o ai-toolkit define train_text_encoder: false e usa steps: 2000 (500–4000 é uma boa faixa).

Treinamento de LoRA do Flux usa clip_skip, min_snr_gamma ou noise_offset?

Não — não como parâmetros kohya nativos do Flux. O guia do kohya para Flux lista --clip_skip sob "Argumentos Incompatíveis/Obsoletos": "Estes são argumentos específicos do Stable Diffusion e não são usados no treinamento do FLUX.1." Sua lista específica do Flux cobre --guidance_scale, --timestep_sampling, --sigmoid_scale, --model_prediction_type e --discrete_flow_shift — nem --min_snr_gamma nem --noise_offset aparecem.

Essa omissão combina com a teoria: Min-SNR pesa timesteps pela razão sinal-ruído e offset noise corrige um viés de valor médio do DDPM — ambos são técnicas de ruído gaussiano/DDPM, não flow-matching. A ponderação de perda do Flux usa --weighting_scheme, --logit_mean, --logit_std e --mode_scale no lugar. Se as flags herdadas afetam uma execução do Flux não está documentado; trate relatos da comunidade com ceticismo. Veja nosso guia de configurações de treinamento de LoRA para SDXL.

Quanta VRAM preciso para treinar um LoRA do Flux?

Flux consome memória em duas frentes, e o teto é a sua placa — veja nossos requisitos de VRAM por modelo para o que cabe em 8, 12, 16 e 24GB. O SimpleTuner nota que "quantizar o modelo na inicialização requer cerca de 50GB de memória de sistema", e o diffusers concorda que "requer ~50GB de RAM/VRAM para carregar todos os componentes do modelo". A VRAM de GPU para um LoRA de rank-16 escala com a quantização: Quantização | VRAM aprox. | Fonte ---|---|--- Nenhuma (base bf16/fp16) | ~30 GB | SimpleTuner FLUX.md int8 + bf16 | ~18 GB | SimpleTuner FLUX.md int4 + bf16 | ~13 GB | SimpleTuner FLUX.md NF4 / int2 + bf16 | ~9 GB | SimpleTuner FLUX.md O SimpleTuner chama de "o mínimo absoluto … uma única 3080 10G" e "um mínimo realista … uma única 3090 ou V100." A tabela por placa do kohya mapeia 24 GB (batch 2), 16 GB (batch 1 + --blocks_to_swap), 12 GB (--blocks_to_swap 16 + AdamW de 8 bits), 10 GB (--blocks_to_swap 22 + T5-XXL em fp8) e 8 GB (--blocks_to_swap 28 + T5-XXL em fp8). Uma RTX 3060 12 GB a 512 é relatada pela comunidade como viável.

Técnicas de redução de VRAM que funcionam para Flux

• --blocks_to_swap troca blocos do transformer CPU↔GPU (até 35 para Flux); não pode combinar com --cpu_offload_checkpointing (kohya).
• --cache_text_encoder_outputs / --cache_latents pré-calcula saídas do codificador/AE; armazenar saídas do codificador de texto em cache desativa o LoRA do codificador de texto, então adicione --network_train_unet_only (docs SDXL do kohya).
• --gradient_checkpointing — SimpleTuner: ative "praticamente em toda situação, em todo dispositivo."
• --fp8_base carrega Flux, CLIP-L e T5-XXL em FP8; "os resultados do treinamento podem variar" (kohya).
• Offloading em grupo (diffusers v0.33+, SimpleTuner) reduz VRAM mas é mutuamente exclusivo com --enable_model_cpu_offload (SimpleTuner).
• gradient_accumulation_steps simula um batch maior sem VRAM extra (batch efetivo = train_batch_size × grad_accum, kohya) a um custo de tempo linear (SimpleTuner).

Batch size, repeats e passos

Mantenha train_batch_size em 1 para datasets pequenos (SimpleTuner). num_repeats multiplica o tamanho efetivo do dataset (20 imagens × 5 repeats se comporta como 100) e é a correção documentada quando um dataset é pequeno demais para começar. O bucketing restringe o batching: imagens de dimensões diferentes não podem dividir um batch, então contagens ímpares de buckets atenuam o benefício de batches maiores. Para gradient accumulation no Flux, o SimpleTuner revisou a orientação anterior: "A orientação anterior era evitar esses com treinamento bf16, pois degradariam o modelo. Testes posteriores mostraram que não é necessariamente o caso …

Erros comuns e correções

Sintoma | Causa | Correção ---|---|--- "no images detected in dataset" | Dataset menor que batch × grad_accum ou vae_batch | Aumente repeats, ou reduza batch/acum (SimpleTuner) SIGKILL após descarga dos codificadores de texto | RAM de sistema insuficiente (~50 GB) para quantizar Flux | Use --base_model_precision=bf16 ou --quantize_via=accelerator; adicione memória ao sistema (SimpleTuner) OOM na inicialização em placas de ≤16 GB | Quantizar na GPU esgota a VRAM | Adicione --quantize_via=cpu (SimpleTuner) LoRA do codificador de texto não treina | --cache_text_encoder_outputs o desativa | Remova o cache ou adicione --network_train_unet_only (docs SDXL do kohya) Artefatos de grade quadrada nos exemplos | Sobretreino, LR alto, proporções estranhas | Reduza LR, selecione os dados, evite proporções extremas (SimpleTuner) Colapso de modelo NF4 | Otimizador Lion + instabilidade NF4 | Mude para variantes de AdamW; adicione --max_grad_norm=0.01 (SimpleTuner) voluptuous.error.MultipleInvalid: required key not provided | Opção TOML ausente ou com erro de digitação | Adicione a opção que o caminho do erro indica (docs de config do kohya)

FAQ

Qual network dim e alpha devo usar para um LoRA do Flux? Comece no rank 16 com alpha 16 (padrão do ai-toolkit) ou alpha 1 (padrão do kohya). Os dois não são intercambiáveis: alpha escala a atualização por α/r, então o 16/16 do ai-toolkit e o 1/16 do kohya diferem em 16× na força efetiva (kohya, ai-toolkit). Para um modelo 12B, prefira ranks pequenos — o SimpleTuner sugere rank 1 ou 4 primeiro, e avisa que ranks 64–128 "podem ser indesejáveis."

Treinamento de LoRA do Flux usa clip_skip? Não. O guia do kohya para Flux lista --clip_skip como incompatível: "Estes são argumentos específicos do Stable Diffusion e não são usados no treinamento do FLUX.1." Flux usa CLIP-L e T5-XXL, e seu script de treinamento não consome essa flag.

Flux é um UNet ou um transformer? Flux é um transformer de difusão, não um UNet. O diffusers o chama de "baseado em transformers de difusão", e o kohya nota sua "arquitetura baseada em Transformer." O componente treinável é o transformer (estilo MMDiT), então a terminologia "unet learning rate" da SD não se aplica.

Quanta VRAM preciso para treinar um LoRA do Flux? Planeje ~50 GB de RAM de sistema para quantizar na inicialização, mais 9–30 GB de VRAM de GPU conforme a quantização (SimpleTuner). O mínimo absoluto é uma 3080 de 10 GB; o mínimo realista, uma 3090 ou V100. O kohya mapeia placas de 24/16/12/10/8 GB para valores específicos de --blocks_to_swap e T5-XXL em fp8.

Qual learning rate para treinamento de LoRA do Flux? Use 1e-4 como linha de base e fique abaixo dos valores da era SD. O SimpleTuner relata que no modelo 12B "LoRA a 1e-3 pode torrar tudo. LoRA a 1e-5 quase não faz nada." AdamW8bit é o otimizador comum; bf16 é a precisão mista recomendada.

min_snr_gamma ou noise_offset funcionam para Flux? Eles não estão na lista de parâmetros específicos do Flux do kohya. Ambos são técnicas DDPM/SNR — Min-SNR pesa timesteps por SNR, offset noise corrige um viés de valor médio do DDPM. Flux é flow-matching, então use --weighting_scheme e --timestep_sampling no lugar; o efeito deles quando passados ao Flux não está documentado.

Posso treinar um LoRA do Flux em 12 GB de VRAM? Sim, com compensações. A receita de 12 GB do kohya usa --blocks_to_swap 16 + AdamW de 8 bits; a configuração mais baixa do SimpleTuner (NF4, 512 px, batch 1) mira ~9 GB. Uma RTX 3060 12 GB a 512 px é relatada pela comunidade como viável. Espere treinamento mais lento e sem folga de batch.

Preciso recortar minhas imagens para treinamento de LoRA do Flux? Nem sempre. O ai-toolkit redimensiona e agrupa automaticamente: "Você não precisa recortar/redimensionar suas imagens." O passo de bucket do kohya padrão é 64 px, com crop_style definido como center ou random. Recorte manual nas dimensões exatas do bucket é opcional, útil só para evitar surpresas do recorte automático.

O que é flow matching no treinamento do Flux? Flow matching é o objetivo de treinamento do Flux, usado no lugar da remoção de ruído gaussiano. No ai-toolkit aparece como noise_scheduler: "flowmatch"; no kohya como --timestep_sampling flux_shift e --model_prediction_type raw. Isso muda quais parâmetros de ponderação de perda e timestep se aplicam.