FluxGym Treinamento FLUX LoRA: Colab e RunPod

TL;DR

• FluxGym é gratuito e roda em GPUs com 12 GB de VRAM ou menos. Seu backend Kohya sd-scripts descarrega blocos do transformer para a RAM da CPU via --blocks_to_swap, permitindo treinar em hardware que o AI-Toolkit não suporta.
• O T4 da Google Colab (16 GB) funciona, mas é lento. FluxGym na Colab é um ponto de entrada gratuito — espere treinamentos mais longos que no RunPod, onde GPUs mais rápidas reduzem consideravelmente a espera.
• O FluxGym esconde todas as configurações avançadas do Kohya atrás de uma aba colapsada. Os padrões servem para testes rápidos, mas parâmetros críticos como --guidance_scale, --timestep_sampling e --model_prediction_type ficam na seção Advanced e devem ser definidos manualmente para os melhores resultados.

O que é o FluxGym e por que ele importa para treinamento de baixa VRAM

FluxGym é uma interface web de código aberto para treinar modelos LoRA FLUX sem usar terminal. Seu frontend Gradio é um fork do AI-Toolkit, que só suporta GPUs com 24 GB de VRAM ou mais, enquanto o backend usa o Kohya sd-scripts, que implementa troca de blocos CPU-GPU para reduzir drasticamente os requisitos de VRAM. O resultado é uma ferramenta que suporta GPUs de 12 GB a 20 GB de VRAM — algo que o AI-Toolkit não faz. Para usuários sem hardware caro, o FluxGym preenche essa lacuna expondo o recurso de troca de blocos do Kohya por uma interface point-and-click. Veja também nosso guia completo Treinamento FLUX LoRA com FluxGym para mais.

FluxGym no Google Colab: Treinamento FLUX LoRA gratuito com GPUs T4

O Google Colab oferece acesso gratuito a GPUs NVIDIA T4 com 16 GB de VRAM. Um membro da comunidade criou um notebook FluxGym Colab que roda a interface completa do FluxGym diretamente no navegador — sem instalação local. A descrição do FluxGym na Colab e o uso do Kohya sd-scripts como base são documentados em Civitai 7345.

Como configurar o FluxGym na Colab

1. Abra o notebook Colab vinculado acima.
2. Rode todas as células para instalar o FluxGym e suas dependências (PyTorch nightly, Kohya sd-scripts do branch sd3).
3. Aguarde o lançamento da interface Gradio — uma URL pública aparece na saída.
4. Faça upload das imagens de treino, escreva legendas usando uma palavra de gatilho e clique em Start.

O notebook também oferece um template RunPod como alternativa paga e mais rápida.

O que o FluxGym esconde dos usuários da Colab

A experiência padrão da Colab expõe apenas os campos básicos: nome do LoRA, diretório de imagens, prefixo de legenda e passos de treinamento. Configurações FLUX críticas que determinam a qualidade da saída estão enterradas na aba Advanced, que vem colapsada por padrão. A documentação do FluxGym confirma que esta aba é "automaticamente construída analisando as flags de lançamento disponíveis na versão mais recente do kohya sd-scripts" — ou seja, todo recurso do Kohya é acessível, mas apenas se você souber expandi-la (README do FluxGym).

As configurações ocultas mais consequentes incluem:

Setting | Valor padrão (no Kohya) | Valor recomendado para FLUX.1 | O que faz

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

--guidance_scale | 3.5 | 1.0 | Desabilita orientação livre de classe para treinamento (o FLUX.1 dev é destilado com CFG embutido) --timestep_sampling | sigma | flux_shift | Desloca a distribuição de timestep baseado na resolução, correspondendo à inferência do FLUX.1 dev --model_prediction_type | sigma_scaled | raw | Usa previsões brutas do modelo sem escala sigma --blocks_to_swap | 0 (nenhum) | 16–22 dependendo da VRAM | Descarrega blocos do transformer para a RAM da CPU --apply_t5_attn_mask | Desligado | Desligado para FLUX (obrigatório para Chroma) | Aplica máscaras de atenção ao codificador de texto T5-XXL

Rodar com padrões em um T4 GPU significa que o script de treinamento usa --guidance_scale 3.5 (o valor de inferência) e --model_prediction_type sigma_scaled, ambos os quais a documentação do Kohya recomenda explicitamente mudar para treinamento FLUX.1. O padrão de escala de orientação é particularmente importante: a documentação do Kohya afirma que o "padrão é 3.5, então certifique-se de especificar" 1.0 para FLUX.1 dev (fonte).

A armadilha da máscara de atenção T5

Para cada nível de VRAM, veja Configurações de GPU VRAM para treinamento LoRA Flux.

O FLUX.1 é um grande modelo transformer. A documentação oficial do Kohya fornece uma referência de VRAM por nível para flux_train_network.py. Todas as recomendações abaixo assumem que --fp8_base está habilitado:

GPU VRAM | Configurações necessárias | Notas

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

24 GB | Configurações básicas, batch size 2 | Nenhuma troca de blocos necessária 16 GB | Batch size 1 + --blocks_to_swap | O Colab T4 se enquadra aqui 12 GB | --blocks_to_swap 16 + AdamW8bit | 10 GB | --blocks_to_swap 22 + checkpoint T5-XXL fp8 | Relatos da comunidade descrevem lentidão significativa versus níveis de VRAM mais altos (Civitai 6860) 8 GB | --blocks_to_swap 28 + checkpoint T5-XXL fp8 | Nível prático máximo de baixa VRAM Source: Documentação de treinamento FLUX do Kohya sd-scripts

O mecanismo --blocks_to_swap move os pesos dos blocos do transformer do FLUX.1 entre a VRAM da GPU e a RAM da CPU. O FLUX.1 suporta até 35 blocos para troca. Contagens maiores de blocos reduzem o uso de VRAM, mas aumentam a sobrecarga de transferência CPU-GPU, diminuindo o treinamento proporcionalmente. Para GPUs abaixo de 10 GB, a documentação do Kohya também recomenda um checkpoint T5-XXL no formato fp8.

Note que --fp8_base reduz o uso de VRAM, mas a documentação do Kohya adverte que "os resultados do treinamento podem variar" — troca precisão por economia de memória.

RunPod: Treinamento mais rápido em GPUs pagas

O RunPod fornece GPUs na nuvem com cobrança por segundo. Um template FluxGym RunPod construído pela comunidade pré-instala o FluxGym e suas dependências, eliminando a configuração manual.

Preços do RunPod para GPUs comuns de treinamento FLUX

GPU | VRAM | Preço/hora | Melhor para

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

A40 | 48 GB | $0.44 | Treinamento FLUX.1 dev econômico, batch size 2 L40S | 48 GB | $0.99 | Treinamento mais rápido, mesmo nível de VRAM A100 PCIe | 80 GB | $1.39 | Batch sizes grandes, mínima troca A100 SXM | 80 GB | $1.49 | Opção A100 mais rápida Source: Página de preços do RunPod

Em uma GPU de 48 GB como a A40 ou L40S, você pode treinar FLUX.1 com batch size 2 e nenhuma troca de blocos — a configuração mais simples possível. Isso elimina a penalidade de velocidade que torna o treinamento na Colab lento.

Erros comuns no RunPod

Para mais detalhes sobre o fluxo de trabalho e configuração do RunPod, veja nosso guia de treinamento FLUX LoRA no RunPod.

Dois problemas aparecem frequentemente em relatos da comunidade. Primeiro, a interface web do RunPod pode carregar indefinidamente se um programa antivírus (notavelmente o Avast) bloquear suas chamadas de API — desabilitar temporariamente o antivírus resolve. Segundo, a interface de treinamento no RunPod requer caminhos que começam com uma barra (por exemplo, /workplace/seu-dataset); omiti-la causa falha silenciosa no treinamento. Os usuários também devem salvar manualmente as configurações antes de relançar o treinamento, ou as mudanças são descartadas (relatos da comunidade).

O que o Kohya sd-scripts realmente recomenda para treinamento FLUX.1

Além da aba Advanced no FluxGym, a própria documentação do Kohya especifica estes parâmetros de linha de base para treinamento FLUX.1:

--network_dim=16 --network_alpha=1
--learning_rate=1e-4
--optimizer_type="AdamW8bit"
--lr_scheduler="constant"
--mixed_precision="fp16"
--gradient_checkpointing
--sdpa
--guidance_scale=1.0
--timestep_sampling="flux_shift"
--model_prediction_type="raw"

Source: Documentação de treinamento FLUX do Kohya

A documentação também fornece uma combinação recomendada verificada: --timestep_sampling shift --discrete_flow_shift 3.1582 --model_prediction_type raw --guidance_scale 1.0. Para modelos Chroma, use --timestep_sampling sigmoid e --guidance_scale 0.0 em vez disso.

Passos de treinamento: o que a comunidade relata

Experiência da comunidade sugere que 3.000 passos geralmente produzem melhores resultados que 4.000 para LoRA FLUX, pois contagens maiores de passos podem levar a saídas superajustadas. Modelos estilizados foram relatados em apenas 1.000 passos. Estes são números reportados pela comunidade de treinadores individuais, não benchmarks controlados [Civitai 7431].

Outros recursos ocultos do FluxGym

Além da aba Advanced, o FluxGym inclui várias capacidades que não são imediatamente visíveis:

• Geração automática de imagens de amostra. Configure prompts e um intervalo de passos para gerar imagens de pré-visualização durante o treinamento. Cada prompt suporta flags: --d para seed, --w/--h para dimensões, --l para escala CFG, --s para contagem de passos [README do FluxGym].
• Publicação no Hugging Face. Insira seu token HF na interface para publicar um LoRA treinado diretamente no Hugging Face.
• Suporte Docker. Instale via docker compose up -d --build para implantação em contêiner.
• Instalação em um clique via Pinokio. Instalação local através do launcher Pinokio evita passos manuais de git clone e pip install.

Erros comuns e correções

Problema | Causa provável | Correção

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

Página do RunPod carrega indefinidamente | Avast ou antivírus bloqueando API do RunPod | Desabilite o antivírus temporariamente Treinamento falha silenciosamente no RunPod | Caminho sem barra / inicial, ou configurações não salvas | Use /workplace/[caminho] e salve antes de lançar OOM em GPU de 12 GB | blocks_to_swap muito baixo ou ausente | Defina --blocks_to_swap 16 + --fp8_base OOM em GPU de 10 GB | Precisa de troca agressiva de blocos + fp8 T5 | Defina --blocks_to_swap 22 + baixe checkpoint T5-XXL fp8 Saídas do LoRA com aparência errada ou baixa qualidade | --guidance_scale deixado no padrão 3.5 | Defina --guidance_scale 1.0 para FLUX.1 dev Erros PyTorch na série RTX 50 | Versão CUDA incorreta | Instale torch nightly cu128 + atualize bitsandbytes

Perguntas frequentes (FAQ)

Quão lento é o treinamento LoRA FLUX em uma GPU T4 da Colab?

Nenhuma fonte fornece uma medição concreta. O criador do notebook descreve o treinamento T4 como "um pouco lento." A arquitetura Turing do T4 mais a sobrecarga de troca de blocos tornam-no significativamente mais lento que uma GPU RunPod de 48 GB, mas não custa nada.

Posso treinar LoRA FLUX com apenas 10 GB de VRAM?

Sim. A documentação do Kohya recomenda --blocks_to_swap 22 plus o checkpoint T5-XXL no formato fp8. Relatos da comunidade descrevem lentidão significativa versus setups de maior VRAM — nenhum benchmark independente fixa a penalidade exata.

O que é --blocks_to_swap e por que ele deixa o treinamento mais lento?

Ele descarrega blocos do transformer do FLUX.1 da VRAM da GPU para a RAM da CPU durante o treinamento, e os troca de volta sob demanda. O FLUX.1 suporta até 35 blocos para troca.

Preciso mudar as configurações da aba Advanced do FluxGym?

Sim. No mínimo, defina --guidance_scale 1.0, --timestep_sampling flux_shift e --model_prediction_type raw para FLUX.1 dev. Os padrões do Kohya (orientação 3.5, amostragem sigma, previsões sigma_scaled) estão sintonizados para outras arquiteturas.