Ejecutar Flux 2 en tu propio hardware significa no tener límites de uso ni tarifas, y tener control total sobre cada parámetro. Este artículo recorre dos vías de instalación, ComfyUI para un flujo de trabajo visual sin código y Hugging Face Diffusers para un control mediante scripts, además de la optimización de VRAM para tarjetas de 8 GB y cómo acceder a Flux 2 Pro sin ninguna configuración local.
Ejecutar un modelo de texto a imagen de última generación directamente en tu equipo cambia por completo la forma de trabajar. Sin límites de uso, sin colas y sin cuotas de suscripción que reduzcan el presupuesto de cada experimento. Flux 2, de Black Forest Labs, es uno de los modelos de generación de imágenes de pesos abiertos más capaces que existen hoy, y instalarlo en local es más accesible de lo que la mayoría espera. Este artículo recorre todo el proceso, desde los requisitos del sistema hasta tu primera imagen generada.
Flux 2 es la segunda generación de la arquitectura Flux, creada por Black Forest Labs, el equipo detrás de algunos de los modelos de pesos abiertos más fotorrealistas disponibles hoy. Parte de la familia original Flux.1 y mejora la adherencia al prompt, la precisión anatómica en sujetos humanos y el detalle nítido en resoluciones estándar. El modelo usa una arquitectura de difusión basada en transformers que se diferencia de forma fundamental de los diseños U-Net de los modelos Stable Diffusion anteriores.
La familia Flux 2 incluye varias versiones distintas, cada una orientada a un nivel de hardware y a un caso de uso diferente:
| Modelo | VRAM necesaria | Ideal para |
|---|---|---|
| flux-2-dev | 16–24 GB | Investigación, ajuste fino, trabajo en local |
| flux-2-pro | Solo en la nube | Producción comercial |
| flux-2-max | Solo en la nube | Máximo detalle y resolución |
| flux-2-flex | Solo en la nube | Control flexible de la relación de aspecto |
| flux-2-klein-4b | 8–12 GB | Inferencia rápida en hardware de consumo |
| flux-2-klein-9b-base | 16 GB | Generación local de alta fidelidad |
Para la instalación en local, flux-2-dev y flux-2-klein-4b son tus principales opciones. Las versiones Pro, Max y Flex funcionan exclusivamente a través de la API y no se distribuyen como pesos descargables.
Hay motivos concretos más allá del ahorro. La inferencia en local significa que tus prompts y las imágenes generadas nunca salen de tu equipo, algo que importa en trabajos comerciales con temas sensibles. Controlas directamente cada parámetro de muestreo. Puedes procesar por lotes cientos de imágenes durante la noche sin preocuparte por el precio por generación. Y para el ajuste fino con conjuntos de datos propios o para acoplar adaptadores LoRA, la instalación en local es la única vía viable.
Antes de descargar nada, comprueba que tu hardware y tu software cumplen estos requisitos. Las dependencias que no encajan causan la mayoría de los fallos habituales de instalación.
Flux 2 es muy exigente desde el punto de vista computacional. Este es el desglose real:
Configuración mínima viable:
Configuración recomendada:
Las GPU AMD funcionan con ROCm en Linux, pero el soporte de controladores en Windows es irregular. Espera tener que resolver más problemas en comparación con las configuraciones CUDA.
Apple Silicon (M1/M2/M3/M4) puede ejecutar versiones cuantizadas de Flux 2 mediante el framework MLX. Los tiempos de generación son de 2 a 4 veces más lentos que con una tarjeta NVIDIA comparable, pero la calidad de imagen es equivalente.
💡 Consejo: Si tu GPU tiene exactamente 8 GB de VRAM, usa la cuantización GGUF Q4_K_S. La calidad baja un poco, pero el modelo funciona sin errores de memoria con la mayoría de los prompts.
Tu conjunto de software tiene que estar alineado antes de que funcione correctamente cualquier instalación de paquetes de Python:
nvidia-smi en una terminal.En Windows, instala CUDA desde el portal de desarrolladores de NVIDIA. En Ubuntu 22.04 o posterior, el instalador runfile evita conflictos de paquetes con los controladores preinstalados.
Existen dos métodos bien soportados para ejecutar Flux 2 en local. Ninguno es objetivamente mejor, y la opción correcta depende por completo de cómo trabajes.
ComfyUI es una interfaz gráfica basada en nodos para ejecutar modelos de difusión. Conectas nodos en un lienzo visual para construir pipelines de generación. Tras la configuración inicial no hace falta escribir scripts en Python. Para la mayoría de las personas es el camino más rápido desde cero hasta una instalación de Flux 2 funcionando.
Elige ComfyUI cuando:
La biblioteca diffusers es la API estándar de Python para ejecutar modelos de difusión de forma programática. Escribes scripts de inferencia y tienes control total sobre cada parámetro, desde el tipo de precisión dtype hasta los schedulers personalizados.
Elige Diffusers cuando:
Es la vía recomendada para la mayoría de usuarios que quieran resultados rápidos sin escribir código.
Paso 1: clona el repositorio de ComfyUI y entra en el directorio:
git clone https://github.com/comfyanonymous/ComfyUI
cd ComfyUI
Paso 2: instala PyTorch con soporte para CUDA. Usa el selector de pytorch.org para obtener el comando correcto para tu versión de CUDA. Para CUDA 12.1:
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
Paso 3: instala el resto de dependencias de ComfyUI:
pip install -r requirements.txt
Paso 4: inicia el servidor:
python main.py --gpu-only
Abre http://127.0.0.1:8188 en tu navegador. ComfyUI ya está en marcha.
💡 Consejo: En Windows, la versión portátil independiente de la página oficial de ComfyUI en GitHub incluye Python y PyTorch preinstalados. Se inicia con un doble clic y evita casi por completo los problemas de configuración del entorno.
Los pesos de Flux 2 están alojados en Hugging Face. Necesitas una cuenta gratuita y debes aceptar el acuerdo de licencia del modelo en su página antes de que la descarga se complete.
Para flux-2-dev (requiere 16 GB o más de VRAM):
huggingface-cli download black-forest-labs/FLUX.2-dev \
flux2-dev.safetensors \
--local-dir ./models/checkpoints/
Para flux-2-klein-4b (funciona en tarjetas de 8 GB):
huggingface-cli download black-forest-labs/FLUX.2-klein-4b \
--local-dir ./models/checkpoints/
También necesitas los codificadores de texto y el VAE compartidos. Estos componentes se reutilizan en todas las versiones de Flux:
# T5 text encoder in fp8 (saves approximately 8 GB VRAM vs full precision)
huggingface-cli download comfyanonymous/flux_text_encoders \
t5xxl_fp8_e4m3fn.safetensors \
--local-dir ./models/clip/
# CLIP text encoder
huggingface-cli download openai/clip-vit-large-patch14 \
--local-dir ./models/clip/
# VAE (shared from Flux.1)
huggingface-cli download black-forest-labs/FLUX.1-schnell \
ae.safetensors \
--local-dir ./models/vae/
Carga el JSON oficial del flujo de trabajo de Flux en ComfyUI con el botón Load. Los nodos principales que hay que configurar son:
Pulsa Queue Prompt y empezará tu primera generación con Flux 2.
Para flujos de trabajo con scripts y desarrollo de aplicaciones, la biblioteca diffusers de Hugging Face ofrece el control más amplio sobre cada aspecto de la generación de imágenes.
Aísla siempre los proyectos de IA en un entorno virtual para evitar conflictos de paquetes entre proyectos.
python -m venv flux2-env
# Windows activation
flux2-env\Scripts\activate
# Linux and macOS activation
source flux2-env/bin/activate
pip install --upgrade pip
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu121
pip install diffusers transformers accelerate sentencepiece protobuf
pip install huggingface_hub
Para el soporte de cuantización GGUF en tarjetas con poca VRAM:
pip install gguf
💡 Consejo: Tras una instalación que funcione, ejecuta
pip freeze > requirements.txtpara fijar tus versiones. La bibliotecadiffusersse actualiza con frecuencia y algunos cambios que rompen compatibilidad afectan a la API del pipeline de Flux.
Un script mínimo que funciona para flux-2-dev:
import torch
from diffusers import FluxPipeline
pipe = FluxPipeline.from_pretrained(
"black-forest-labs/FLUX.2-dev",
torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()
prompt = "A photorealistic portrait of a woman in soft natural light, film grain, 8K"
image = pipe(
prompt,
height=1024,
width=1024,
guidance_scale=3.5,
num_inference_steps=28,
max_sequence_length=512,
generator=torch.Generator("cpu").manual_seed(42)
).images[0]
image.save("flux2_output.png")
Ejecútalo con:
python generate.py
La primera ejecución descarga unos 24 GB de pesos del modelo. Las siguientes cargan desde la caché en unos 30 segundos en un SSD NVMe moderno.
No todo el mundo tiene una GPU de 24 GB. Estas dos estrategias te permiten ejecutar Flux 2 en tarjetas de 8 a 12 GB sin perder la calidad de imagen que hace que el modelo merezca la pena.
GGUF es un formato de cuantización adaptado del ecosistema llama.cpp que hoy también funciona con modelos de difusión de imagen. Reduce la precisión del modelo de números de coma flotante de 16 bits a enteros de 4 u 8 bits, lo que recorta los requisitos de VRAM entre un 50 y un 75 %.
En Hugging Face hay archivos GGUF cuantizados por la comunidad para Flux 2. Esta es la contrapartida práctica en cada nivel de cuantización:
| Archivo | Uso de VRAM | Calidad |
|---|---|---|
| flux2-dev-Q8_0.gguf | ~10 GB | Casi sin pérdidas |
| flux2-dev-Q4_K_S.gguf | ~6 GB | Buena, con una ligera suavización |
| flux2-dev-Q3_K_M.gguf | ~5 GB | Aceptable para pruebas rápidas |
En ComfyUI, instala la extensión de nodo personalizado ComfyUI-GGUF y luego carga el archivo de checkpoint .gguf igual que cargarías cualquier checkpoint .safetensors. No hace falta cambiar nada más en el flujo de trabajo.
Dos estrategias adicionales de reducción de memoria que se combinan bien entre sí:
Carga del transformer en fp8 en Diffusers:
from diffusers import FluxPipeline, FluxTransformer2DModel
import torch
transformer = FluxTransformer2DModel.from_pretrained(
"black-forest-labs/FLUX.2-dev",
subfolder="transformer",
torch_dtype=torch.float8_e4m3fn
)
pipe = FluxPipeline.from_pretrained(
"black-forest-labs/FLUX.2-dev",
transformer=transformer,
torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()
Descarga secuencial a la CPU (más lenta, pero funciona en tarjetas de 8 GB):
pipe.enable_sequential_cpu_offload()
💡 Consejo: Combina GGUF Q4_K_S con
enable_model_cpu_offload()para el mejor equilibrio en tarjetas de 8 GB. Espera tiempos de generación de 3 a 5 minutos por imagen de 1024x1024, algo perfectamente viable para trabajo personal iterativo.
Si quieres probar Flux 2 antes de comprometerte con una configuración completa en local, o si necesitas acceder a las versiones Pro y Max, que solo están en la nube, PicassoIA ofrece todos los modelos de Flux 2 directamente en el navegador, sin instalar nada.
flux-2-pro y flux-2-max no están disponibles como pesos descargables. Funcionan exclusivamente a través de una API en la nube. PicassoIA ofrece acceso desde el navegador a ambos, además de flux-2-flex para dimensiones de salida flexibles y flux-2-klein-4b para una generación rápida.
Pasos para generar con Flux 2 en PicassoIA:
Para una calidad equivalente a ejecutar flux-2-dev en local con una GPU de 24 GB, la implementación de PicassoIA produce resultados equivalentes sin tiempo de configuración.
Flux 2 responde bien a prompts en lenguaje natural. No necesitas corchetes con pesos ni apilar tokens. Escribe lo que quieres como una frase clara y concreta.
Lo que funciona bien:
Lo que conviene evitar:
💡 Consejo: Para flux-2-klein-4b, mantén el guidance scale entre 2,5 y 4,0. Los valores más altos sobresaturan los colores en el modelo más pequeño.
Tanto si seguiste la vía de ComfyUI, si escribiste un script de Diffusers o si abriste flux-2-pro en PicassoIA, ya tienes todo lo necesario para trabajar con Flux 2.
El verdadero valor de tener Flux 2 funcionando en local, o a través de una plataforma como PicassoIA, es la velocidad de iteración. Escribes un prompt, ves un resultado en menos de un minuto, refinas la descripción y vuelves a generar. Ese ciclo de retroalimentación tan ajustado es donde se desarrolla la habilidad real para escribir prompts y ajustar parámetros.
PicassoIA te da acceso inmediato a flux-2-dev, flux-2-pro, flux-2-max, flux-2-flex y al eficiente flux-2-klein-4b, sin configurar CUDA, sin descargar 24 GB de pesos y sin preparar un entorno virtual. Es la forma más rápida de comparar lo que realmente produce cada versión antes de decidir si merece la pena una instalación completa en local para tu flujo de trabajo.
Empieza con un prompt que te importe. Ejecútalo en flux-2-dev y luego compáralo con flux-2-klein-4b. Fíjate en lo que cambia entre los dos. Esa comparación te dice exactamente qué inversión en hardware se justifica para tu caso de uso concreto, sin ninguna suposición.
Elige tu idioma
