FLUX.1 FP16 vs FP8: Velocidade, Qualidade e Trade-offs

FLUX.1 roda em dois modos de precisão que atendem restrições de hardware diferentes. A quantização FP8 reduz o armazenamento de pesos em cerca de metade, mas os exemplos oficiais do ComfyUI avisam que isso "degrades a qualidade um pouco". A compensação fica decisiva quando a VRAM é limitada: uma placa de 12 GB pode precisar do FP8 para rodar o FLUX.1 Dev por completo, enquanto uma de 24 GB tem espaço para o FP16. Para mais sobre quantização GGUF e FP8 juntos, veja métodos de quantização GGUF. Para a configuração mais ampla do fluxo do FLUX, veja fluxos de trabalho Flux ComfyUI. Para rodar FLUX em placas menores, veja FLUX com 8GB de VRAM.

TL;DR

• Placas de 12 GB: Use checkpoints FP8 ou variantes GGUF quantizadas; o Dev em FP16 não encaixa.
• Placas de 24 GB: O Dev em FP16 em 50 passos entrega a melhor qualidade; o FP8 libera cabeçalho.
• Impacto na qualidade: O FP8 "degrades a qualidade um pouco" segundo a documentação do ComfyUI; nenhum benchmark quantifica a diferença perceptual exata.
• Mecanismo de memória: O FP8 armazena os pesos em ponto flutuante de 8 bits (float8_e4m3fn), reduzindo a memória de pesos em comparação ao armazenamento de 16 bits do FP16.

FLUX.1 Dev vs Schnell: Estratégia de Distilação

A Black Forest Labs envia dois modelos de peso aberto com abordagens de distilação diferentes. O FLUX.1-schnell é distilado por timestep: produz imagens em 1 a 4 passos sem samplerndo LCM. O FLUX.1-dev é distilado por guidance: requer cerca de 50 passos de amostragem para um bom resultado.

A diferença de passos decorre das estratégias de distilação: o Schnell aprende a gerar diretamente em poucos passos, enquanto o Dev aprende a refinar a qualidade em muitos passos.

Mecanismos: Como o FP8 altera memória e latência

A quantização armazena pesos em 8 bits ao invés de 16 bits. O processo: quantize() o módulo com o tipo de dados FP8, então freeze() substitui os parâmetros originais pelos quantizados. Citação: "Estamos quantizando para o tipo de dados FP8… Chamamos finalmente freeze() para substituir os parâmetros originais pelos parâmetros quantizados." URL: https://huggingface.co/blog/quanto-diffusers

Nos benchmarks, quantizar apenas o backbone de difusão economizou ~0,5 GB (12,086 → 11,547 GB). Adicionar a quantização do text encoder economizou ~11 GB (16,403 → 5,363 GB). Citação: "Notamos as seguintes economias de memória ao usar FP8… Memória (GB): 12,086 → 11,547." URL: https://huggingface.co/blog/quanto-diffusers

Os mesmos benchmarks mostram que o FP8 aumenta a latência: 1,200 s → 1,540 s. Citação: "Latência (Segundos): 1,200 → 1,540." URL: https://huggingface.co/blog/quanto-diffusers

O ComfyUI integra isso via o nó Load Diffusion Model, que aceita weight_dtype=fp8. O exemplo oficial diz: "Você pode definir o weight_dtype no nó 'Load Diffusion Model' como fp8, o que reduz o uso de memória pela metade, mas pode reduzir um pouco a qualidade." URL: https://comfyanonymous.github.io/ComfyUI_examples/flux/

Requisitos de VRAM por Tamanho de Placa

Placas de 12 GB

Uma placa de 12 GB não pode rodar o FLUX.1 Dev em FP16; o transformer do FLUX.1 Dev tem 12,5 bilhões de parâmetros (segundo a documentação de memória do diffusers), e, somado aos text encoders, ultrapassa o orçamento de 12 GB. Os fluxos de trabalho da comunidade sugerem:

• Checkpoint FP8: flux1-dev-fp8.safetensors + text encoder t5xxl_fp8_e4m3fn_scaled.safetensors
• Variantes GGUF: quantização Q4_K_S ou Q5_K_M via ComfyUI-GGUF

A documentação de memória do diffusers afirma que a quantização "pode ser combinada com outras técnicas de otimização de memória… para equilibrar a velocidade de inferência e o uso de memória". Essas abordagens são essenciais para placas de 12 GB.

Além do FP8: INT8 como Alternativa

A quantização INT8 é outro caminho para menor VRAM, particularmente relevante para modelos de difusão baseados em transformadores. Os benchmarks do HuggingFace Quanto encontraram que a quantização INT8 "é geralmente melhor em termos de latência de inferência" em comparação ao FP8 nos modelos testados (PixArt-Sigma, SD3, Aura Flow). Especificamente, o INT8 atingiu 1,504 s de latência contra 1,601 s do FP8 no PixArt-Sigma (batch=1, TE quantizado). Para o FLUX.1, não foi encontrada comparação INT8 vs FP8 nas fontes abertas, então a vantagem de latência não pode ser confirmada para esse modelo específico. A mesma documentação do Quanto observa que excluir a camada de projeção final ("proj_out") da quantização INT4 ajuda a preservar a qualidade da imagem — um padrão que pode se estender a outros formatos de quantização.

O nó personalizado ComfyUI-GGUF fornece checkpoints quantizados em GGUF do FLUX.1 que podem despejar pesos inativos na RAM ou no disco do sistema, permitindo rodadas em placas com tão pouco quanto 4 GB de VRAM. Seu README afirma que modelos transformer/DiT como o FLUX "parecem menos afetados pela quantização" em comparação com modelos UNET convolucionais, tornando o GGUF um caminho viável para placas com VRAM muito baixo.

A variante FP8 do modelo Schnell da Comfy-Org afirma explicitamente que rodar em FP8 é "muito mais rápido e usa menos memória" em comparação ao FP16. Essa é a única afirmação direta de desempenho encontrada na documentação para um modo de precisão específico do FLUX.1 — a página FP8 do Dev descreve apenas o benefício de VRAM, não a velocidade.

Combinando pesos do modelo FP8 com offload para CPU, enable_model_cpu_offload() por exemplo, mantém a VRAM de pico menor, com alguma latência adicionada enquanto os pesos se movem entre CPU e GPU. Para orçamentos de VRAM muito apertados, o offload em grupos pode mover grupos de camadas internas para a CPU e voltar em lote. Essas estratégias estão documentadas como compatíveis com quantização e torch.compile.

Configuração Prática para Cada Placa

Configuração de Placa de 12 GB

1. Baixe flux1-dev-fp8.safetensors da Comfy-Org para ComfyUI/models/checkpoints/
2. Baixe t5xxl_fp8_e4m3fn_scaled.safetensors para ComfyUI/models/text_encoders/
3. Use o checkpoint FP8 com o nó "Load Checkpoint"
4. Considere GGUF + ComfyUI-GGUF para VRAM ainda menor

Configuração de Placa de 24 GB

1. Baixe flux1-dev.safetensors da Black Forest Labs para ComfyUI/models/diffusion_models/
2. Baixe t5xxl_fp16.safetensors do repositório de text encoders da Comfy-Org
3. Use o fluxo de trabalho padrão do FLUX Dev com 50 passos e guidance 3,5
4. O FP8 permanece uma opção se você precisar de cabeçalho para modelos adicionais

Erros Comuns e Soluções

Para uma análise mais aprofundada de configurações de samplerndo e schedulers além do que é coberto aqui, veja nosso guia de samplers e schedulers. Para um passeio completo de configuração de fluxos de trabalho do Flux do zero, incluindo caminhos de download de modelos e conexões de nós, veja fluxos de trabalho Flux ComfyUI.

FAQ

Quanto de VRAM o FLUX.1 Dev precisa em FP8? A Comfy-Org afirma que seu checkpoint FP8 em um único arquivo serve a usuários com "menos VRAM (menos de 24gb)". Não há piso exato publicado.

O FLUX.1 Schnell em FP8 perde qualidade visível? Os exemplos oficiais do ComfyUI dizem que o FP8 "degrades a qualidade um pouco" de forma geral. Para o Schnell em 1 a 4 passos, a diferença de qualidade pode ser mínima para muitos prompts.

Qual precisão para uma GPU de 12 GB? O FP8 é obrigatório para o Dev; as variantes GGUF (Q4_K_S) oferecem um caminho alternativo via ComfyUI-GGUF.

FP8 é realmente mais rápido ou só menor? Os mesmos benchmarks de quantização do HuggingFace que documentam os economias de memória do FP8 mostram que ele na verdade aumenta a latência: 1,200 s → 1,540 s. Não está documentado se esse padrão se mantém para o FLUX.1.

Posso misturar componentes FP8 e FP16? Sim. A documentação do diffusers afirma que é possível aplicar quantização diferente a módulos diferentes do pipeline — por exemplo, FP8 para o text encoder e FP16 para o backbone de difusão.

E a quantização INT8? O blog do Quanto afirma que a quantização INT8 "é geralmente melhor em termos de latência de inferência" do que o FP8. Isso se aplica aos modelos testados (PixArt-Sigma, SD3, Aura Flow), mas não existe comparação para o FLUX.1.

Como a escolha do encoder T5 afeta a VRAM? Os exemplos do ComfyUI indicam que o arquivo de encoder T5 em escala fp8 está disponível para menor uso de memória. Citação: "Você pode usar t5xxl_fp8_e4m3fn_scaled.safetensors em vez disso para menor uso de memória, mas o arquivo fp16 é recomendado se você tiver mais de 32GB de ram." URL: https://comfyanonymous.github.io/ComfyUI_examples/flux/