FLUX.1

Ejecuta FLUX.1 de Black Forest Labs para generación de imágenes en Clore.ai

¡Alternativa más rápida! FLUX.2 Klein genera imágenes en < 0.5 segundos (vs 10–30s para FLUX.1) con calidad comparable. Esta guía sigue siendo relevante para el entrenamiento de LoRA y los flujos de trabajo de ControlNet.

Modelo de generación de imágenes de vanguardia de Black Forest Labs en GPUs de CLORE.AI.

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de CLORE.AI Marketplace.

¿Por qué FLUX.1?

• Mejor calidad - Superior a SDXL y Midjourney v5

• Renderizado de texto - Texto realmente legible en imágenes

• Seguir el prompt - Excelente adherencia a las instrucciones

• Variantes rápidas - FLUX.1-schnell para generación rápida

Variantes de modelo

Modelo	Velocidad	Calidad	VRAM	Licencia
FLUX.1-schnell	Rápido (4 pasos)	Genial	12GB+	Apache 2.0
FLUX.1-dev	Medio (20 pasos)	Excelente	16GB+	No comercial
FLUX.1-pro	Solo API	Mejor	-	Comercial

Despliegue rápido en CLORE.AI

Imagen Docker:

ghcr.io/huggingface/text-generation-inference:latest

Puertos:

22/tcp
7860/http

Para el despliegue más sencillo, usa ComfyUI con nodos FLUX.

Métodos de instalación

Método 1: ComfyUI (Recomendado)

# Instalar ComfyUI
git clone https://github.com/comfyanonymous/ComfyUI
cd ComfyUI
pip install -r requirements.txt

# Descargar modelos FLUX
cd models/unet
wget https://huggingface.co/black-forest-labs/FLUX.1-schnell/resolve/main/flux1-schnell.safetensors

# Descargar componentes requeridos
cd ../clip
wget https://huggingface.co/comfyanonymous/flux_text_encoders/resolve/main/clip_l.safetensors
wget https://huggingface.co/comfyanonymous/flux_text_encoders/resolve/main/t5xxl_fp16.safetensors

cd ../vae
wget https://huggingface.co/black-forest-labs/FLUX.1-schnell/resolve/main/ae.safetensors

# Ejecutar ComfyUI
python main.py --listen 0.0.0.0

Método 2: Diffusers

pip install diffusers transformers accelerate torch

python << 'PYEOF'
import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

image = pipe(
    "Un gato con un traje espacial en Marte",
    num_inference_steps=4,
    guidance_scale=0.0,
).images[0]

image.save("flux_output.png")
PYEOF

Método 3: Fooocus

Fooocus tiene soporte FLUX incorporado:

git clone https://github.com/lllyasviel/Fooocus
cd Fooocus
pip install -r requirements.txt

# Descargar modelo FLUX a models/checkpoints/
python launch.py --listen

Flujo de trabajo en ComfyUI

FLUX.1-schnell (Rápido)

Nodos necesarios:

1. Cargar Modelo de Difusión → flux1-schnell.safetensors

2. DualCLIPLoader → clip_l.safetensors + t5xxl_fp16.safetensors

3. CLIP Text Encode → tu prompt

4. Imagen latente SD3 vacía → establecer dimensiones

5. KSampler → steps: 4, cfg: 1.0

6. VAE Decode → ae.safetensors

7. Guardar imagen

FLUX.1-dev (Calidad)

Mismo flujo de trabajo pero:

• Pasos: 20-50

• CFG: 3.5

• Usa guidance_scale en el prompt

API de Python

Generación básica

import torch
from diffusers import FluxPipeline

# Cargar modelo
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.to("cuda")

# Generar
image = pipe(
    prompt="Un sereno jardín japonés con cerezos en flor",
    height=1024,
    width=1024,
    num_inference_steps=4,
    guidance_scale=0.0,
).images[0]

image.save("output.png")

Con optimización de memoria

from diffusers import FluxPipeline
import torch

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)

# Habilitar optimizaciones
pipe.enable_model_cpu_offload()  # Ahorra ~10GB de VRAM
pipe.enable_vae_slicing()
pipe.enable_vae_tiling()

image = pipe(
    "Retrato de un samurái cyberpunk",
    height=1024,
    width=1024,
    num_inference_steps=4,
).images[0]

Generación por lotes

prompts = [
    "Una puesta de sol sobre montañas",
    "Una ciudad futurista de noche",
    "Un arrecife de coral submarino",
]

images = pipe(
    prompts,
    height=1024,
    width=1024,
    num_inference_steps=4,
).images

for i, img in enumerate(images):
    img.save(f"output_{i}.png")

FLUX.1-dev (Mayor Calidad)

from diffusers import FluxPipeline
import torch

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

image = pipe(
    prompt="Retrato hiperrealista de un pescador anciano",
    height=1024,
    width=1024,
    num_inference_steps=50,
    guidance_scale=3.5,
).images[0]

Consejos para prompts

FLUX destaca en:

• Texto en imágenes: "Un letrero de neón que dice 'OPEN 24/7'"

• Escenas complejas: "Una calle concurrida de Tokio de noche con reflejos"

• Estilos específicos: "Pintura al óleo al estilo de Monet"

• Descripciones detalladas: Los prompts largos y detallados funcionan bien

Ejemplos de Prompts

# Fotorrealista
Una fotografía profesional de un cachorro golden retriever jugando entre hojas de otoño, 
profundidad de campo baja, cálida luz de la tarde, Canon EOS R5

# Artístico
Una pintura impresionista de un café parisino bajo la lluvia, 
óleo sobre lienzo, pinceladas visibles, colores cálidos

# Renderizado de texto
Un cartel de película vintage con el título "COSMIC VOYAGE" en letras retro en negrita,
estética sci-fi de los años 60, ilustración de un astronauta

# Escena compleja
El interior de una acogedora biblioteca con estanterías de piso a techo, 
un sillón de cuero junto a una chimenea, lluvia visible a través de una ventana,
luz cálida de lámpara, fotorrealista

Optimización de memoria

Para 12GB VRAM (RTX 3060)

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.float16  # Usa fp16 en lugar de bf16
)
pipe.enable_model_cpu_offload()
pipe.enable_vae_slicing()
pipe.enable_vae_tiling()

# Generar a menor resolución
image = pipe(prompt, height=768, width=768, num_inference_steps=4).images[0]

Para 8GB de VRAM

Usa la versión cuantizada o ComfyUI con GGUF:

# En ComfyUI, instala nodos GGUF
cd custom_nodes
git clone https://github.com/city96/ComfyUI-GGUF

# Descargar modelo cuantizado
wget https://huggingface.co/city96/FLUX.1-schnell-gguf/resolve/main/flux1-schnell-Q4_K_S.gguf

Comparación de rendimiento

Modelo	Pasos	Tiempo (4090)	Calidad
FLUX.1-schnell	4	~3 seg	Genial
FLUX.1-dev	20	~12 seg	Excelente
FLUX.1-dev	50	~30 seg	Mejor
SDXL	30	~8 seg	Bueno

Requisitos de GPU

Configuración	Mínimo	Recomendado
FLUX.1-schnell	12GB	16GB+
FLUX.1-dev	16GB	24GB+
Con descarga a CPU	8GB	12GB+
Cuantizado (GGUF)	6GB	8GB+

Preajustes de GPU

RTX 3060 12GB (Económica)

# Usar modelo cuantizado
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.float16
)
pipe.enable_model_cpu_offload()
pipe.enable_vae_tiling()

# Ajustes:
# - sólo schnell (dev puede OOM)
# - 512x512 a 768x768
# - 4 pasos
# - Tamaño de lote 1

RTX 3090 24GB (Óptima)

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_vae_tiling()

# Ajustes:
# - schnell: 1024x1024, lote 2
# - dev: 1024x1024, lote 1
# - 20-30 pasos para dev
# - Habilitar tiling de VAE para alta resolución

RTX 4090 24GB (Alto rendimiento)

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.float16
)
pipe.to("cuda")

# Ajustes:
# - schnell: 1024x1024, lote 4
# - dev: 1024x1024, lote 2
# - 30-50 pasos para mejor calidad
# - Puede hacer 1536x1536 con tiling

A100 40GB/80GB (Producción)

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)
pipe.to("cuda")

# Ajustes:
# - schnell: 1024x1024, lote 8+
# - dev: 1024x1024, lote 4
# - 50 pasos para máxima calidad
# - 2048x2048 posible

Estimación de costos

GPU	Por hora	Imágenes/Hora
RTX 3060 12GB	~$0.03	~200 (schnell)
RTX 3090 24GB	~$0.06	~600 (schnell)
RTX 4090 24GB	~$0.10	~1000 (schnell)
A100 40GB	~$0.17	~1500 (schnell)

Solución de problemas

Memoria insuficiente

# Usar descarga a CPU
pipe.enable_model_cpu_offload()

# O descarga secuencial a CPU (más lento pero menos VRAM)
pipe.enable_sequential_cpu_offload()

# Reducir resolución
height=768, width=768

Generación lenta

• Usa FLUX.1-schnell (4 pasos)

• Habilita torch.compile: pipe.unet = torch.compile(pipe.unet)

• Usa fp16 en lugar de bf16 en GPUs antiguas

Calidad pobre

• Usa más pasos (FLUX-dev: 30-50)

• Aumenta guidance_scale (3.0-4.0 para dev)

• Escribe prompts más detallados

---

FLUX LoRA

Los pesos LoRA (Low-Rank Adaptation) te permiten afinar FLUX para estilos, personajes o conceptos específicos sin reentrenar el modelo completo. Cientos de LoRAs comunitarios están disponibles en HuggingFace y CivitAI.

Instalación

pip install diffusers transformers accelerate peft

Cargando un único LoRA

import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

# Cargar pesos LoRA desde un archivo local
pipe.load_lora_weights("path/to/lora.safetensors")

image = pipe(
    "Un retrato al estilo de Van Gogh, pinceladas ondulantes",
    num_inference_steps=20,
    guidance_scale=3.5,
    generator=torch.Generator(device="cuda").manual_seed(42),
).images[0]
image.save("flux_lora_output.png")

Cargando desde HuggingFace Hub

import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

# Cargar LoRA directamente desde un repo de HuggingFace
pipe.load_lora_weights(
    "username/my-flux-lora",          # ID del repo en HF
    weight_name="my_lora.safetensors" # nombre de archivo en el repo
)

image = pipe(
    "palabra_disparadora un hermoso paisaje",
    num_inference_steps=20,
    guidance_scale=3.5,
).images[0]
image.save("output.png")

Escala LoRA (Intensidad)

# Controla la influencia de LoRA con cross_attention_kwargs
image = pipe(
    "Un personaje cyberpunk, luces de neón",
    num_inference_steps=20,
    guidance_scale=3.5,
    cross_attention_kwargs={"scale": 0.8},  # 0.0 = sin efecto, 1.0 = efecto completo
).images[0]

Combinando múltiples LoRAs

from diffusers import FluxPipeline
import torch

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

# Cargar primer LoRA
pipe.load_lora_weights(
    "path/to/style_lora.safetensors",
    adapter_name="style"
)

# Cargar segundo LoRA
pipe.load_lora_weights(
    "path/to/character_lora.safetensors",
    adapter_name="character"
)

# Combinar con pesos
pipe.set_adapters(["style", "character"], adapter_weights=[0.7, 0.9])

image = pipe(
    "character_trigger vistiendo un atuendo elaborado, artistic_trigger estilo",
    num_inference_steps=25,
    guidance_scale=3.5,
).images[0]
image.save("combined_lora.png")

Descargando LoRA

# Eliminar pesos LoRA para restaurar el modelo base
pipe.unload_lora_weights()

Entrenando tu propio FLUX LoRA

# Usa kohya-ss o ai-toolkit para entrenamiento de LoRA en FLUX
git clone https://github.com/ostris/ai-toolkit
cd ai-toolkit
pip install -r requirements.txt

# Preparar dataset: 10-30 imágenes con subtítulos
# Edita el YAML de configuración, luego:
python run.py config/flux_lora_train.yaml

Fuentes recomendadas de LoRA

Origen	URL	Notas
CivitAI	civitai.com	Gran biblioteca comunitaria
HuggingFace	huggingface.co/models	Filtrar por FLUX
Replicate	replicate.com	Explorar modelos entrenados

---

ControlNet para FLUX

ControlNet permite guiar la generación de FLUX con entradas estructurales como bordes canny, mapas de profundidad y esqueletos de pose. XLabs-AI ha lanzado los primeros modelos ControlNet específicamente para FLUX.1.

Instalación

pip install diffusers transformers accelerate controlnet-aux pillow

FLUX ControlNet Canny (XLabs-AI)

import torch
import numpy as np
from PIL import Image
from diffusers import FluxControlNetPipeline, FluxControlNetModel
from diffusers.utils import load_image
from controlnet_aux import CannyDetector

# Cargar el modelo FLUX ControlNet (variante Canny)
controlnet = FluxControlNetModel.from_pretrained(
    "XLabs-AI/flux-controlnet-canny-diffusers",
    torch_dtype=torch.bfloat16
)

# Cargar la pipeline con ControlNet
pipe = FluxControlNetPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    controlnet=controlnet,
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

# Preparar la imagen de control (bordes canny)
input_image = load_image("your_input.jpg").resize((1024, 1024))
canny = CannyDetector()
control_image = canny(input_image, low_threshold=50, high_threshold=200)

# Generar con guía de ControlNet
image = pipe(
    prompt="Un paisaje urbano futurista con letreros de neón, fotorrealista, 8K",
    control_image=control_image,
    controlnet_conditioning_scale=0.7,
    num_inference_steps=25,
    guidance_scale=3.5,
    generator=torch.Generator(device="cuda").manual_seed(0),
).images[0]

image.save("controlnet_flux_output.png")

FLUX ControlNet Depth

import torch
from PIL import Image
from diffusers import FluxControlNetPipeline, FluxControlNetModel
from diffusers.utils import load_image
from transformers import pipeline as hf_pipeline

# Cargar estimador de profundidad
depth_estimator = hf_pipeline("depth-estimation", model="LiheYoung/depth-anything-small-hf")

# Preparar mapa de profundidad
input_image = load_image("portrait.jpg").resize((1024, 1024))
depth_result = depth_estimator(input_image)["depth"]
depth_image = depth_result.convert("RGB")

# Cargar ControlNet Depth
controlnet = FluxControlNetModel.from_pretrained(
    "XLabs-AI/flux-controlnet-depth-diffusers",
    torch_dtype=torch.bfloat16
)

pipe = FluxControlNetPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    controlnet=controlnet,
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

image = pipe(
    prompt="Una estatua de mármol de un guerrero, iluminación dramática, foto de museo",
    control_image=depth_image,
    controlnet_conditioning_scale=0.6,
    num_inference_steps=20,
    guidance_scale=3.5,
).images[0]
image.save("depth_controlnet_output.png")

Multi-ControlNet para FLUX

import torch
from diffusers import FluxControlNetPipeline, FluxMultiControlNetModel, FluxControlNetModel
from diffusers.utils import load_image
from controlnet_aux import CannyDetector

# Cargar múltiples ControlNets
controlnet_canny = FluxControlNetModel.from_pretrained(
    "XLabs-AI/flux-controlnet-canny-diffusers",
    torch_dtype=torch.bfloat16
)
controlnet_depth = FluxControlNetModel.from_pretrained(
    "XLabs-AI/flux-controlnet-depth-diffusers",
    torch_dtype=torch.bfloat16
)

# Combinar en MultiControlNet
multi_controlnet = FluxMultiControlNetModel([controlnet_canny, controlnet_depth])

pipe = FluxControlNetPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    controlnet=multi_controlnet,
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

image = pipe(
    prompt="Un caballero con armadura de pie en un bosque, iluminación dramática",
    control_image=[canny_image, depth_image],
    controlnet_conditioning_scale=[0.7, 0.5],
    num_inference_steps=25,
    guidance_scale=3.5,
).images[0]

Modelos FLUX ControlNet disponibles

Modelo	Repositorio	Caso de uso
Canny	XLabs-AI/flux-controlnet-canny-diffusers	Generación guiada por bordes
Profundidad	XLabs-AI/flux-controlnet-depth-diffusers	Generación guiada por profundidad
HED/Borde suave	XLabs-AI/flux-controlnet-hed-diffusers	Control estructural suave
Pose	XLabs-AI/flux-controlnet-openpose-diffusers	Retratos guiados por pose

Consejos para ControlNet

• conditioning_scale 0.5–0.8 funciona mejor para FLUX (si es muy alto se pierde creatividad)

• Usa 1024×1024 o múltiplos para mejor calidad

• Combínalo con LoRA para control de estilo + estructura

• Menos pasos (20–25) suele ser suficiente con ControlNet

---

FLUX.1-schnell: Modo de generación rápida

FLUX.1-schnell es la variante destilada y optimizada para velocidad de FLUX. Genera imágenes de alta calidad en solo 4 pasos (vs 20–50 para FLUX.1-dev), lo que lo hace ideal para prototipado rápido y flujos de trabajo de alto rendimiento.

Diferencias clave vs FLUX.1-dev

Función	FLUX.1-schnell	FLUX.1-dev
Pasos	4	20–50
Velocidad (4090)	~3 seg	~12–30 seg
Licencia	Apache 2.0 (comercial gratuito)	No comercial
guidance_scale	0.0 (sin CFG)	3.5
Calidad	Genial	Excelente
VRAM	12GB+	16GB+

Nota de licencia: FLUX.1-schnell es Apache 2.0 — puedes usarlo libremente en productos comerciales. FLUX.1-dev requiere una licencia comercial separada de Black Forest Labs.

Inicio rápido

import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

image = pipe(
    prompt="Una impresionante vista aérea de la ciudad de Nueva York a la hora dorada, fotorrealista",
    height=1024,
    width=1024,
    num_inference_steps=4,   # ¡Solo se necesitan 4 pasos!
    guidance_scale=0.0,       # CFG desactivado para schnell
    max_sequence_length=256,
    generator=torch.Generator(device="cpu").manual_seed(0),
).images[0]

image.save("schnell_output.png")
print("¡Generado en ~3 segundos en RTX 4090!")

Generación por lotes de alto rendimiento

import torch
from diffusers import FluxPipeline
from pathlib import Path

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.to("cuda")  # Mantener en GPU para velocidad, no usar cpu_offload

output_dir = Path("schnell_outputs")
output_dir.mkdir(exist_ok=True)

prompts = [
    "Un sereno lago de montaña al amanecer, atmósfera brumosa",
    "Un bullicioso mercado callejero de Tokio de noche, reflejos de neón",
    "Una fotografía macro de una telaraña cubierta de rocío",
    "Una antigua biblioteca con libros flotantes y luz mágica",
    "Una ciudad submarina futurista con vida marina bioluminiscente",
]

# Generación por lotes
for i, prompt in enumerate(prompts):
    image = pipe(
        prompt=prompt,
        height=1024,
        width=1024,
        num_inference_steps=4,
        guidance_scale=0.0,
        generator=torch.Generator(device="cuda").manual_seed(i),
    ).images[0]
    image.save(output_dir / f"image_{i:04d}.png")
    print(f"Generado {i+1}/{len(prompts)}: {prompt[:50]}...")

Múltiples relaciones de aspecto con schnell

import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

# FLUX soporta relaciones de aspecto flexibles
resolutions = {
    "square":    (1024, 1024),
    "portrait":  (768,  1360),
    "landscape": (1360, 768),
    "tall":      (576,  1792),
    "wide":      (1792, 576),
}

prompt = "Un majestuoso lobo en un bosque nevado, fotografía profesional de vida silvestre"

for name, (width, height) in resolutions.items():
    image = pipe(
        prompt=prompt,
        height=height,
        width=width,
        num_inference_steps=4,
        guidance_scale=0.0,
    ).images[0]
    image.save(f"schnell_{name}.png")
    print(f"Guardado {name}: {width}x{height}")

schnell con optimizaciones de memoria

import torch
from diffusers import FluxPipeline

# Para 12GB VRAM (RTX 3060/3080)
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.float16  # fp16 ahorra memoria en GPUs antiguas
)
pipe.enable_model_cpu_offload()
pipe.enable_vae_slicing()
pipe.enable_vae_tiling()

image = pipe(
    prompt="Una acogedora cabaña en un bosque otoñal, luz cálida a través de las ventanas",
    height=768,
    width=768,
    num_inference_steps=4,
    guidance_scale=0.0,
).images[0]
image.save("schnell_low_vram.png")

Benchmarks de rendimiento (schnell)

GPU	VRAM	Tiempo/imagen (1024px)	Imágenes/hora
RTX 3060 12GB	12GB	~8 seg	~450
RTX 3090 24GB	24GB	~4 seg	~900
RTX 4090 24GB	24GB	~3 seg	~1200
A100 40GB	40GB	~2 seg	~1800

Cuándo usar schnell vs dev

Usa FLUX.1-schnell cuando:

• Prototipado rápido / probar prompts

• Generación por lotes de alto volumen

• Proyectos comerciales (Apache 2.0)

• Presupuesto de GPU limitado

• Aplicaciones en tiempo real o casi en tiempo real

Usa FLUX.1-dev cuando:

• La máxima calidad de imagen es la prioridad

• Detalle fino y escenas complejas

• Investigación / trabajo artístico

• Combinación con LoRA/ControlNet (dev suele responder mejor)

---

Próximos pasos

• ComfyUI - Mejor interfaz para FLUX

• Fooocus - Alternativa simple

• ControlNet - Generación guiada

• Entrenamiento Kohya - Entrenar LoRAs de FLUX