# FLUX.1

{% hint style="info" %}
**¡Alternativa más rápida!** [**FLUX.2 Klein**](/guides/guides_v2-es/generacion-de-imagenes/flux2-klein.md) genera imágenes en < 0,5 segundos (frente a 10–30 s para FLUX.1) con una 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 última generación 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 [Mercado de CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## ¿Por qué FLUX.1?

* **Mejor calidad** - Superior a SDXL y Midjourney v5
* **Renderizado de texto** - Texto realmente legible en las imágenes
* **Seguimiento de instrucciones** - Excelente adherencia a las instrucciones
* **Variantes rápidas** - FLUX.1-schnell para generación rápida

## Variantes del modelo

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

## Despliegue rápido en CLORE.AI

**Imagen de 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 compatibilidad FLUX integrada:

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

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

## Flujo de trabajo de 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. **Codificación de texto CLIP** → tu prompt
4. **Imagen latente SD3 vacía** → establecer dimensiones
5. **KSampler** → pasos: 4, cfg: 1.0
6. **Decodificación VAE** → ae.safetensors
7. **Guardar imagen**

### FLUX.1-dev (calidad)

El 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 flores de cerezo",
    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 ~10 GB de VRAM
pipe.enable_vae_slicing()
pipe.enable_vae_tiling()

image = pipe(
    "Retrato de un samurái ciberpunk",
    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 concurrida calle 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

### Prompts de ejemplo

```
# Fotorrealista
Una fotografía profesional de un cachorro de golden retriever jugando en hojas de otoño, 
profundidad de campo reducida, luz cálida 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 póster de película vintage con el título "COSMIC VOYAGE" en letras retro en negrita,
estética de ciencia ficción de los años 60, ilustración de astronauta

# Escena compleja
Un acogedor interior de biblioteca con estanterías de suelo 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 12 GB de 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 8 GB de VRAM

Usa la versión cuantizada o ComfyUI con GGUF:

```bash
# En ComfyUI, instala los 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 s         | Excelente |
| FLUX.1-dev     | 20    | \~12 s        | Excelente |
| FLUX.1-dev     | 50    | \~30 s        | Mejor     |
| SDXL           | 30    | \~8 s         | Bueno     |

## Requisitos de GPU

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

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

# Configuración:
# - solo schnell (dev puede quedarse sin memoria)
# - 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()

# Configuración:
# - schnell: 1024x1024, lote 2
# - dev: 1024x1024, lote 1
# - 20-30 pasos para dev
# - Habilitar mosaico VAE para alta resolución
```

### [RTX 4090 24GB](https://clore.ai/rent-4090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=flux) (Rendimiento)

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

# Configuración:
# - schnell: 1024x1024, lote 4
# - dev: 1024x1024, lote 2
# - 30-50 pasos para la mejor calidad
# - Puede hacer 1536x1536 con mosaico
```

### A100 40GB/80GB (producción)

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

# Configuración:
# - schnell: 1024x1024, lote 8+
# - dev: 1024x1024, lote 4
# - 50 pasos para la 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 40 GB    | \~$0.17  | \~1500 (schnell) |

## Solución de problemas

### Falta de memoria

```python
# Usar descarga a CPU
pipe.enable_model_cpu_offload()

# O descarga secuencial a CPU (más lenta, 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 más antiguas

### Mala calidad

* 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 (adaptación de bajo rango) te permiten ajustar FLUX para estilos, personajes o conceptos específicos sin volver a entrenar el modelo completo. Hay cientos de LoRAs de la comunidad disponibles en HuggingFace y CivitAI.

### Instalación

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

### Carga de una sola 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 arremolinadas",
    num_inference_steps=20,
    guidance_scale=3.5,
    generator=torch.Generator(device="cuda").manual_seed(42),
).images[0]
image.save("flux_lora_output.png")
```

### Carga 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 el repositorio de HuggingFace
pipe.load_lora_weights(
    "username/my-flux-lora",          # ID del repositorio HF
    weight_name="my_lora.safetensors" # nombre del archivo en el repositorio
)

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

### Escala LoRA (intensidad)

```python
# Controlar la influencia de LoRA con cross_attention_kwargs
image = pipe(
    "Un personaje ciberpunk, 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 total
).images[0]
```

### Combinación de 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 la primera LoRA
pipe.load_lora_weights(
    "path/to/style_lora.safetensors",
    adapter_name="style"
)

# Cargar la segunda 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 con un disfraz elaborado, artistic_trigger style",
    num_inference_steps=25,
    guidance_scale=3.5,
).images[0]
image.save("combined_lora.png")
```

### Descarga de LoRA

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

### Entrenando tu propia FLUX LoRA

```bash
# Usa kohya-ss o ai-toolkit para el entrenamiento de FLUX LoRA
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

| Fuente      | 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 tubería 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      |
| Depth           | 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 de ControlNet

* **conditioning\_scale 0.5–0.8** funciona mejor para FLUX (demasiado alto pierde creatividad)
* Usa **1024×1024** o múltiplos para obtener la 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** (frente a 20–50 para FLUX.1-dev), lo que lo hace ideal para prototipos rápidos y flujos de trabajo de alto rendimiento.

### Diferencias clave frente a FLUX.1-dev

| Funcionalidad    | FLUX.1-schnell                      | FLUX.1-dev   |
| ---------------- | ----------------------------------- | ------------ |
| Pasos            | 4                                   | 20–50        |
| Velocidad (4090) | \~3 s                               | \~12–30 s    |
| Licencia         | **Apache 2.0** (comercial gratuito) | No comercial |
| guidance\_scale  | 0.0 (sin CFG)                       | 3.5          |
| Calidad          | Excelente                           | Excelente    |
| VRAM             | 12GB+                               | 16 GB+       |

> **Nota sobre la licencia:** FLUX.1-schnell tiene licencia 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 una 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 la GPU para mayor 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 animado mercado callejero de Tokio de noche, reflejos de neón",
    "Una fotografía macro de una telaraña cubierta de rocío",
    "Una biblioteca antigua 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 admite relaciones de aspecto flexibles
resolutions = {
    "square":    (1024, 1024),
    "portrait":  (768,  1360),
    "landscape": (1360, 768),
    "tall":      (576,  1792),
    "wide":      (1792, 576),
}

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

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 12 GB de VRAM (RTX 3060/3080)
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.float16  # fp16 ahorra memoria en GPUs más 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")
```

### Puntos de referencia de rendimiento (schnell)

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

### Cuándo usar schnell vs dev

**Use FLUX.1-schnell cuando:**

* Prototipado rápido / pruebas de prompts
* Generación por lotes de gran volumen
* Proyectos comerciales (Apache 2.0)
* Presupuesto limitado de GPU
* Aplicaciones en tiempo real o casi en tiempo real

**Use FLUX.1-dev cuando:**

* La máxima calidad de imagen es la prioridad
* Detalle fino y escenas complejas
* Trabajo de investigación / artístico
* Combinación con LoRA/ControlNet (dev suele responder mejor)

***

## Siguientes pasos

* [ComfyUI](/guides/guides_v2-es/generacion-de-imagenes/comfyui.md) - La mejor interfaz para FLUX
* [Fooocus](/guides/guides_v2-es/generacion-de-imagenes/fooocus-simple-sd.md) - Alternativa sencilla
* [ControlNet](/guides/guides_v2-es/procesamiento-de-imagenes/controlnet-advanced.md) - Generación guiada
* [Entrenamiento Kohya](/guides/guides_v2-es/entrenamiento/kohya-training.md) - Entrenar LoRAs de FLUX


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/generacion-de-imagenes/flux.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.