# FLUX.1

{% hint style="info" %}
**¡Alternativa más rápida!** [**FLUX.2 Klein**](https://docs.clore.ai/guides/guides_v2-es/generacion-de-imagenes/flux2-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.
{% endhint %}

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

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## ¿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)

```bash
# 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

```bash
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:

```bash
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

```python
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

```python
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

```python
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)

```python
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)

```python
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:

```bash
# 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)

```python
# 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)

```python
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)

```python
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)

```python
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

```python
# 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

```bash
pip install diffusers transformers accelerate peft
```

### Cargando un único LoRA

```python
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

```python
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)

```python
# 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

```python
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

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

### Entrenando tu propio FLUX LoRA

```bash
# 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

```bash
pip install diffusers transformers accelerate controlnet-aux pillow
```

### FLUX ControlNet Canny (XLabs-AI)

```python
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

```python
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

```python
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

```python
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

```python
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

```python
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

```python
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](https://docs.clore.ai/guides/guides_v2-es/generacion-de-imagenes/comfyui) - Mejor interfaz para FLUX
* [Fooocus](https://docs.clore.ai/guides/guides_v2-es/generacion-de-imagenes/fooocus-simple-sd) - Alternativa simple
* [ControlNet](https://docs.clore.ai/guides/guides_v2-es/procesamiento-de-imagenes/controlnet-advanced) - Generación guiada
* [Entrenamiento Kohya](https://docs.clore.ai/guides/guides_v2-es/entrenamiento/kohya-training) - Entrenar LoRAs de FLUX