- ae.safetensors é o arquivo de pesos do VAE (autoencoder variacional) distribuído com os modelos de imagens FLUX.1 da Black Forest Labs. Ele decodifica os latentes do FLUX em pixels RGB e codifica imagens de volta em latentes para tarefas img2img.
- Baixe-o do oficial safetensors" rel="noopener" target="_blank">black-forest-labs/FLUX.1-schnell ou FLUX.1-dev repositórios no Hugging Face. O arquivo tem cerca de 335 MB.
- No ComfyUI, coloque-o na pasta
ComfyUI/models/vae/e carregue-o com o nó Load VAE . No Forge/A1111, coloque-o na pastamodels/VAE/. - O mesmo
ae.safetensorsfunciona para FLUX.1-dev, FLUX.1-schnell e a maioria dos fine-tunes FLUX — você não precisa de um VAE separado para cada checkpoint.
ae.safetensors é o arquivo de pesos do autoencoder (VAE) distribuído junto com os modelos de difusão FLUX.1 da Black Forest Labs. O FLUX gera imagens em um espaço latente compactado; ae.safetensors é o decodificador que transforma esses latentes em pixels visíveis (e também o codificador usado para tarefas de image-to-image e inpainting). Sem ele, o ComfyUI, Forge, SwarmUI ou diffusers não conseguem renderizar uma imagem final a partir de um checkpoint FLUX.
O arquivo é armazenado no formato safetensors — um contêiner somente de tensores, mapeável na memória, que não executa código Python arbitrário ao ser carregado, diferentemente dos antigos arquivos .ckpt serializados com pickle. É por isso que quase todos os lançamentos modernos de modelos distribuem seus pesos no formato .safetensors.
O que exatamente há em ae.safetensors
FLUX.1 é um transformer baseado em fluxo retificado que opera em latentes de 16 canais com resolução espacial reduzida a 1/8. O arquivo ae.safetensors contém apenas os pesos do VAE — nenhum transformer, nenhum codificador de texto. Especificações aproximadas:
| Propriedade | Valor |
|---|---|
| Tamanho do arquivo | ~335 MB (fp16) |
| Canais latentes | 16 |
| Compressão espacial | 8× (uma imagem de 1024×1024 → latente de 128×128×16) |
| Formato | safetensors (somente tensores, sem pickle) |
| Checkpoints compatíveis | FLUX.1-dev, FLUX.1-schnell, FLUX.1-pro (API), a maioria dos fine-tunes FLUX e LoRAs |
| Licença | Licença não comercial para o VAE do FLUX.1-dev; licença Apache-2.0 para o VAE do FLUX.1-schnell |
O VAE do FLUX não é o mesmo arquivo que os VAEs do SD 1.5 ou do SDXL. Seu espaço latente de 16 canais é incompatível com esses modelos — não os substitua.
De onde baixar ae.safetensors
Obtenha-o nos repositórios oficiais da Black Forest Labs no Hugging Face. Ambos os arquivos têm a mesma arquitetura; o repositório schnell possui licença Apache-2.0 e pode ser redistribuído livremente, razão pela qual a maioria dos pacotes de terceiros faz referência a ele.
- black-forest-labs/FLUX.1-schnell → ae.safetensors (Apache-2.0)
- black-forest-labs/FLUX.1-dev → ae.safetensors (licença não comercial do FLUX.1-dev; exige aceitação do gate)
Download via linha de comando com a CLI do Hugging Face:
pip install -U "huggingface_hub[cli]"
huggingface-cli login # necessário apenas para o FLUX.1-dev com gate
huggingface-cli download black-forest-labs/FLUX.1-schnell ae.safetensors --local-dir .Verifique o hash SHA-256 contra o valor exibido na página do arquivo no Hugging Face antes de usá-lo.
Instalação de ae.safetensors por ferramenta
ComfyUI (Windows, macOS, Linux)
O ComfyUI é a interface de referência para FLUX. Coloque o arquivo na pasta VAE:
# Linux / macOS
mv ae.safetensors ~/ComfyUI/models/vae/
# Windows (PowerShell)
Move-Item .ae.safetensors $HOME\ComfyUI\models\vaeNo grafo, adicione um nó Load VAE e selecione ae.safetensors no menu suspenso, depois conecte sua saída VAE saída para o Decodificador VAE nó antes do Salvar Imagem nó. Se você estiver usando o ponto de verificação FLUX tudo-em-um (pesos + VAE + codificadores de texto em um único arquivo) da Comfy-Org, não precisa ae.safetensors separadamente — a VAE já está incorporada.
Forge / Automatic1111 / reForge
Coloque o arquivo em stable-diffusion-webui-forge/models/VAE/ (o Forge detecta-a automaticamente). Na interface do Forge, defina o modo UI como flux, depois, no seletor de VAE / Codificador de Texto na parte superior, escolha ae.safetensors juntamente com os codificadores CLIP-L e T5-XXL. O Automatic1111 padrão não oferece suporte oficial ao FLUX; use o Forge em vez disso.
SwarmUI / StableSwarmUI
Arraste o arquivo para Models/VAE/. A Swarm detecta automaticamente pontos de verificação FLUX e selecionará ae.safetensors automaticamente, caso seja a única VAE compatível com FLUX presente.
diffusers (Python)
Se você estiver carregando o repositório completo do FLUX do Hugging Face, a VAE já está incluída e você não precisa manipulá-la ae.safetensors diretamente. Para carregar uma VAE autônoma ae.safetensors:
from diffusers import AutoencoderKL, FluxPipeline
import torch
vae = AutoencoderKL.from_single_file(
"ae.safetensors", torch_dtype=torch.bfloat16
)
pipe = FluxPipeline.from_pretrained(
"black-forest-labs/FLUX.1-schnell",
vae=vae,
torch_dtype=torch.bfloat16,
).to("cuda")Consulte a documentação atual da pipeline FLUX do diffusers — o nome exato da classe da VAE do FLUX mudou entre versões do diffusers, portanto fixe sua versão.
Observações sobre VRAM e desempenho
A própria VAE é pequena (~335 MB em fp16, ~168 MB em fp8); ela não é o que torna o FLUX pesado. O transformador é o principal consumidor de recursos: o FLUX.1-dev ocupa cerca de 23 GB em bf16 e aproximadamente 12 GB em fp8. Em uma placa de 24 GB (RTX 3090/4090), é possível executar o FLUX com a VAE residente na GPU; em placas de 12 GB, normalmente é necessário descarregar a VAE para a CPU entre as chamadas de decodificação.
Para ter uma ideia geral de quanto memória de GPU é consumida por modelos de difusão e LLM, utilize o calculadora de VRAM da Convly e o melhores GPUs para modelos locais guia.
Decodificação em Alta Resolução
A VAE do FLUX atinge seu pico de uso de VRAM no momento da decodificação, proporcional à resolução de saída. Uma decodificação em 2048×2048 consome aproximadamente quatro vezes mais VRAM de pico do que uma em 1024×1024. Se você encontrar um erro de falta de memória (OOM) apenas na etapa final de decodificação, habilite a VAE em blocos (tiled VAE):
- ComfyUI: substitua Decodificador VAE com Decodificador VAE (em Blocos).
- diffusers:
pipe.vae.enable_tiling()antes da inferência. - Forge: marque a opção VAE em Blocos no painel de configurações.
Erros comuns com ae.safetensors
| Erro | Causa | Corrigir |
|---|---|---|
Erro ao desserializar o cabeçalho: HeaderTooLarge |
Download truncado | Baixe novamente e verifique o SHA-256 |
| Imagem de saída preta/verde | VAE incorreta (VAE do SDXL carregada para o FLUX) | Confirme se ae.safetensors está selecionada, e não sdxl_vae.safetensors |
Chave(s) ausente(s) no state_dict |
Carregando a VAE do FLUX em um pipeline do SD 1.5/SDXL | O melhor editor completo FluxPipeline/AutoencoderKL.from_single_filemodel-index StableDiffusionPipeline |
| O arquivo tem 335 MB, mas foi rejeitado como inválido | Foi baixada uma página HTML de acesso restrito em vez do arquivo | Aceite a licença na página do modelo ou use huggingface-cli com um token |
ae.safetensors versus o checkpoint FLUX tudo-em-um
Você verá dois estilos de distribuição no Hugging Face e no Civitai:
- Arquivos divididos (layout oficial da BFL):
flux1-dev.safetensors(transformer) +ae.safetensors(VAE) +clip_l.safetensors+t5xxl_fp16.safetensors. Preferido para diffusers, fluxos avançados no ComfyUI e ajuste fino — você pode substituir o transformer sem precisar baixar novamente os 20 GB de codificadores de texto. - Tudo-em-um (reempacotamento da Comfy-Org, por exemplo,
flux1-dev-fp8.safetensors): todos os componentes agrupados em um único arquivo. Mais simples para fluxos de trabalho no ComfyUI com um clique; você não precisa doae.safetensorscomo arquivo separado.
Onde o FLUX se encaixa no panorama mais amplo de modelos
O FLUX é um modelo local de geração de imagens, auto-hospedado. Se você está escolhendo entre executá-lo na sua própria GPU ou chamar uma API hospedada de geração de imagens ou vídeos — Sora 2, Veo 3.1, Kling 2.5, Wan 2.5 — a troca envolve custo fixo de hardware versus cobrança por segundo. Consulte o calculadora de ponto de equilíbrio entre hospedagem local e uso de API para estimar o ponto de equilíbrio e o base de dados de modelos Convly para conhecer os preços atuais das APIs entre os provedores.
Para modelos de linguagem, divisões de arquivos no estilo VAE não se aplicam — os LLMs incluem apenas os pesos do transformer. Se você também executa LLMs locais ao lado do FLUX, ferramentas como Ollama e LM Studio gerenciam modelos da mesma forma que o ComfyUI gerencia ativos de difusão.
Perguntas frequentes
O arquivo ae.safetensors é o mesmo para FLUX.1-dev e FLUX.1-schnell?
Sim — a arquitetura e os pesos do VAE são idênticos entre o FLUX.1-dev e o FLUX.1-schnell. Os dois repositórios fornecem o mesmo ae.safetensors, apenas sob licenças diferentes (schnell usa a Apache-2.0, enquanto dev é não comercial). Você pode usar qualquer cópia de forma intercambiável.
Posso usar o VAE do SDXL com FLUX para economizar VRAM?
Não. O FLUX utiliza um espaço latente de 16 canais; o SDXL usa 4 canais. Carregar o VAE do SDXL nos latentes do FLUX resulta em saída de cor sólida ou ruído, e o diffusers normalmente aciona um erro de incompatibilidade de dimensões. Use ae.safetensors.
É seguro baixar ae.safetensors de terceiros?
O formato safetensors em si não pode executar código ao ser carregado, portanto um arquivo corrompido ou malicioso não pode comprometer sua máquina da maneira como um arquivo pickle .ckpt poderia. Dito isso, um VAE adulterado poderia gerar imagens de qualidade reduzida. Prefira os repositórios oficiais da Black Forest Labs e verifique o hash SHA-256.
Preciso de ae.safetensors se usar FLUX apenas por meio de uma API?
Não. As APIs hospedadas (Replicate, fal.ai, própria API da BFL, Together) executam todo o pipeline no servidor. Você só precisa do ae.safetensors ao executar o FLUX localmente no ComfyUI, Forge, SwarmUI ou diffusers.
Por que ele é chamado de “ae” e não de “vae”?
A nomenclatura interna da Black Forest Labs usa "ae" (autoencoder) em vez da etiqueta mais comum "vae" do ecossistema Stable Diffusion. Funcionalmente, desempenha o mesmo papel: codificar pixels em latentes e decodificar latentes de volta em pixels. O autoencoder do FLUX é tecnicamente mais próximo de um AE simples regularizado por KL do que o VAE do SD 1.5, mas todas as interfaces gráficas o tratam como um VAE.
Posso fazer fine-tuning de ae.safetensors?
Você pode fazê-lo, mas quase nunca vale a pena. O VAE foi treinado em bilhões de imagens e seu ajuste fino geralmente prejudica o alinhamento do transformer com o espaço latente, reduzindo a qualidade. Os ajustes finos comunitários do FLUX e os LoRAs modificam apenas o transformer e reutilizam o ae.safetensors.