Guía de Dimensionamiento · 9 min de lectura

# Cómo elegir una tarjeta para modelos de imagen y vídeo.

Un modelo de imagen no tiene ninguna conversación que recordar, así que se dimensiona con una regla completamente distinta a la de un modelo de lenguaje —y la tarjeta más barata que lo aloja casi nunca es la tarjeta que le conviene alquilar.

La respuesta corta

- **A precisión completa:** SDXL 1.0 **8.0 GB** · Stable Diffusion 3.5 Large **18.4 GB** · FLUX.1 dev **27.6 GB** · Wan 2.1 video 14B **32.2 GB** — margen de ejecución incluido
- **La línea incómoda:** Todas las tarjetas de 24 GB del catálogo se quedan justo por debajo de FLUX.1 dev en BF16. FP8 lo reduce a la mitad y todas superan el listón
- **La más barata que lo aloja:** [NVIDIA L4](https://gpuserver.io/es/gpu/nvidia-l4) a $125 al mes, FLUX.1 dev en FP8
- **Qué compra una segunda tarjeta:** El doble de imágenes por hora, y ni un segundo menos en una sola imagen

## Qué necesita cada modelo

Empiece por la diferencia que decide todo lo demás. Un modelo de lenguaje mantiene una [caché de clave/valor](https://gpuserver.io/es/guides/vram-sizing) que crece con cada token de contexto, por lo que el mismo modelo de 70B puede necesitar 40 GB o 140 GB según cuánta conversación conserve. Un modelo de difusión no tiene caché en absoluto. Lee un prompt, elimina el ruido de un latente durante un número fijo de pasos, y olvida. Los pesos son, por tanto, casi toda la cuestión de memoria, y la respuesta no cambia aunque sus prompts sean más largos.

**Memoria necesaria para cada modelo de imagen y vídeo, por precisión**

| Modelo | Parámetros | BF16 / FP16 | FP8 | 4-bit (AWQ, GPTQ) |
|---|---|---|---|---|
| SDXL 1.0 Imágenes fijas | 3.5 B | 8.0 GB | 4.0 GB | 2.0 GB |
| Stable Diffusion 3.5 Large Imágenes fijas | 8 B | 18.4 GB | 9.2 GB | 4.6 GB |
| FLUX.1 dev Imágenes fijas | 12 B | 27.6 GB | 13.8 GB | 6.9 GB |
| Wan 2.1 video 14B Vídeo, generado como un bloque de fotogramas | 14 B | 32.2 GB | 16.1 GB | 8.0 GB |

Los pesos más un margen de ejecución del 15 % para activaciones, el contexto de CUDA y la fragmentación del asignador de memoria — el mismo margen que aplica el [configurador](https://gpuserver.io/es/configure), para que pueda contrastar estas cifras con él. No hay columna de contexto porque no hay nada que poner en ella.

Hay dos líneas de esa tabla en las que merece la pena detenerse, porque son exactamente donde una compra sale mal.

**FLUX.1 dev en BF16 necesita 27.6 GB.** Eso supera cualquier tarjeta de 24 GB que alquilamos, y no por poco. Es la sorpresa más habitual en el trabajo con imagen: el modelo que «funciona en una 4090 según todo internet» se está ejecutando cuantizado, y nadie lo dice.

**Wan 2.1 video 14B en BF16 necesita 32.2 GB.** Se queda a una fracción de gigabyte de una tarjeta de 32 GB. Nuestro margen es deliberadamente conservador y normalmente puede recuperar esa diferencia manteniendo el codificador de texto fuera de la tarjeta — pero no debería tener que planificar una compra en torno a un error de redondeo, así que la respuesta honesta es que el vídeo necesita 40 GB o más.

## Qué aloja cada tarjeta

Todas las máquinas de una sola tarjeta que alquilamos, y la mejor precisión que cada una admite para los dos modelos exigentes. La columna de ancho de banda está ahí para el próximo capítulo; léala después de haber leído este.

**Nodos de una sola tarjeta, y qué precisión admite cada uno**

| Nodo | Memoria de la tarjeta | Ancho de banda | FLUX.1 dev | Wan 2.1 video 14B | Al mes |
|---|---|---|---|---|---|
| [NVIDIA L4](https://gpuserver.io/es/gpu/nvidia-l4) Ada Lovelace · PCIe 5.0 | 24 GB | 300 GB/s2.4 GB/s por $ | FP8 | FP8 | $125/mes |
| [NVIDIA RTX 4090](https://gpuserver.io/es/gpu/rtx-4090) Ada Lovelace · PCIe 5.0 | 24 GB | 1,008 GB/s5.2 GB/s por $ | FP8 | FP8 | $193/mes |
| [NVIDIA RTX A6000](https://gpuserver.io/es/gpu/rtx-a6000) Ampere · PCIe 5.0 | 48 GB | 768 GB/s2.7 GB/s por $ | BF16 / FP16 | BF16 / FP16 | $286/mes |
| [NVIDIA RTX 5090](https://gpuserver.io/es/gpu/rtx-5090) Blackwell · PCIe 5.0 | 32 GB | 1,792 GB/s5.3 GB/s por $ | BF16 / FP16 | FP8 | $335/mes |
| [NVIDIA A100 PCIe](https://gpuserver.io/es/gpu/a100-40gb) Ampere · PCIe 5.0 | 40 GB | 1,555 GB/s4.0 GB/s por $ | BF16 / FP16 | BF16 / FP16 | $392/mes |
| [NVIDIA L40S](https://gpuserver.io/es/gpu/l40s) Ada Lovelace · PCIe 5.0 | 48 GB | 864 GB/s1.2 GB/s por $ | BF16 / FP16 | BF16 / FP16 | $714/mes |
| [NVIDIA A100 PCIe](https://gpuserver.io/es/gpu/a100-80gb) Ampere · PCIe 5.0 | 80 GB | 1,935 GB/s1.8 GB/s por $ | BF16 / FP16 | BF16 / FP16 | $1,091/mes |
| [NVIDIA H100 PCIe](https://gpuserver.io/es/gpu/h100-pcie) Hopper · PCIe 5.0 | 80 GB | 2,000 GB/s1.4 GB/s por $ | BF16 / FP16 | BF16 / FP16 | $1,469/mes |

El verde son los pesos de referencia, el ámbar son los cuantizados. Cuantizar un modelo de difusión no es la comida gratis que es para un modelo de lenguaje: el mismo prompt y la misma semilla producen una imagen visiblemente distinta, normalmente algo más suave. Es un buen trato en FP8 y una decisión de criterio en 4 bits.

Lea la columna de precios desde abajo y el panorama es tajante. [NVIDIA L4](https://gpuserver.io/es/gpu/nvidia-l4), a $125 al mes, es la máquina más barata que alquilamos capaz de alojar FLUX.1 dev — en FP8. La más barata que lo aloja en BF16 completo es [NVIDIA RTX A6000](https://gpuserver.io/es/gpu/rtx-a6000), a $286. Vídeo a precisión completa empieza en esa misma tarjeta.

## La columna que todo el mundo interpreta mal

Aquí está la parte que distingue el trabajo con imagen de todo lo demás en este sitio, y es la razón por la que la tarjeta más barata de esa tabla es una trampa.

Cuando un modelo de lenguaje genera un token, lee de memoria cada peso activo una vez, realiza una pequeña cantidad de operaciones aritméticas con cada uno, y escribe un único token. Vuelve a hacerlo para el siguiente token, y para el siguiente. La tarjeta se pasa la vida esperando al bus de memoria, por lo que nuestras estimaciones de rendimiento para modelos de lenguaje son esencialmente el ancho de banda dividido entre los pesos leídos, y por lo que la columna de ancho de banda es la que importa en [una guía de servicio](https://gpuserver.io/es/guides/serve-llama-70b).

Un paso de difusión no se parece a eso. Los mismos pesos se aplican a un tensor latente entre veinte y cincuenta veces, y cada pasada realiza una gran cantidad de operaciones aritméticas por cada byte leído. Los pesos permanecen residentes; el trabajo son convoluciones y atención sobre un tensor pequeño. Eso invierte la restricción: un modelo de imagen está limitado por el rendimiento del tensor, no por el bus de memoria. De ahí se derivan tres cosas, y las tres cuestan dinero si se hacen mal.

### «Cabe» no es «es rápido»

La tarjeta de entrada de la tabla de arriba aloja FLUX.1 dev en FP8 por $125 al mes, y es un componente de bajo consumo diseñado para servir modelos pequeños de forma densa, no para mover píxeles. La memoria es el primer filtro, nunca el último.

### Una segunda tarjeta no reduce la espera a la mitad

ComfyUI y los pipelines de diffusers no reparten un único bucle de eliminación de ruido entre varias GPU como sí hace vLLM con un transformer. Dos tarjetas ejecutan dos workers: el doble de imágenes por hora, los mismos segundos por imagen. [Aquí NVLink no le aporta nada](https://gpuserver.io/es/guides/nvlink-vs-pcie).

### La tarjeta de centro de datos no es automáticamente la respuesta

Para servir modelos de lenguaje, una tarjeta HBM gana en el número que decide el trabajo. Para el trabajo con imagen, lo que compra es rendimiento de tensor y memoria, y las tarjetas diseñadas para gráficos le dan más de ambas cosas por dólar de lo que sugiere su posición en nuestra lista de precios.

El ancho de banda por dólar es un indicador — aproximado — de la clase de tarjeta que está valorando, y en nuestro catálogo coloca a [NVIDIA RTX 5090](https://gpuserver.io/es/gpu/rtx-5090) y [NVIDIA RTX 4090](https://gpuserver.io/es/gpu/rtx-4090) en primer y segundo lugar por un margen amplio. Eso no es casualidad ni una ganga a la que le estemos empujando: son los componentes diseñados exactamente para este tipo de cálculo, y están cerca del final de nuestra lista de precios porque el mercado los valora frente al gaming, no frente a los clústeres de entrenamiento.

**Por qué no hay columna de imágenes por minuto.** Publicamos una estimación de tokens por segundo para los modelos de lenguaje porque la fórmula que hay detrás es defendible y se la mostramos. Para difusión no existe un equivalente que estemos dispuestos a respaldar: los segundos por imagen varían por un factor de cinco según el sampler, el número de pasos, la resolución y si ha compilado el modelo, antes incluso de que la tarjeta entre en juego. Una cifra que nos hubiéramos inventado para esta tabla sería lo más citable de la página y lo menos cierto. Alquile durante un mes, mida su propio pipeline, y la respuesta vale más que cualquier benchmark.

## Resolución, lote y vídeo

Los pesos son fijos. Lo que varía es el conjunto de trabajo, y varía con los píxeles, no con los parámetros. El latente en sí es insignificante — son las activaciones que atraviesan la red a esa resolución las que llenan la tarjeta.

Adónde va realmente la memoria

```
latent_elements = (H / 8) * (W / 8) * C * batch
# C = 4 latent channels on SDXL, 16 on SD 3.5 and FLUX.

# 1024x1024, batch 1, SDXL:
128 * 128 * 4 * 1     = 65,536 elements   = 128 KB in FP16

# 2048x2048, batch 4, SDXL:
256 * 256 * 4 * 4     = 1,048,576         = 2 MB in FP16

# The latent is never the problem. The activations that pass through the
# network at that resolution are, and they scale by the SAME factor:
# doubling the edge quadruples the pixel count, and roughly quadruples
# the working set. Batch multiplies it linearly on top.
```

Tres consecuencias prácticas, en el orden en que se las encontrará:

1. **El pico suele producirse en la decodificación VAE, no en el bucle de muestreo.** La decodificación expande el latente de vuelta a la resolución completa en una sola pasada, y ese momento concreto es lo que dispara el error de memoria agotada justo al final de un trabajo que llevaba un minuto funcionando bien. La decodificación en mosaico lo soluciona y cuesta algo de tiempo.
2. **El procesamiento por lotes es la forma de aprovechar una tarjeta grande.** Si el modelo le deja 20 GB libres, generar cuatro imágenes a la vez es un uso mucho mejor de esa memoria que una imagen con margen — los pesos se leen una sola vez para todo el lote, que es el único punto en el que un pipeline de difusión sí se comporta como una tarea limitada por el ancho de banda.
3. **El vídeo añade una dimensión, no un porcentaje.** Wan 2.1 video 14B genera un bloque de fotogramas a la vez, así que los fotogramas multiplican el mismo conjunto de trabajo que ya multiplican la altura y la anchura. Por eso un modelo de vídeo de 14 000 millones de parámetros pide una tarjeta mucho más grande que un modelo de imagen de 12 000 millones, y por eso la tabla de pesos de arriba lo subestima más que ninguna otra fila.

**Una regla práctica.** Tome la cifra de la primera tabla y deje libre, además, aproximadamente un tercio de la tarjeta para una imagen de un megapíxel cada vez. Si tiene previsto usar lotes, suba de nivel de memoria en vez de recortar el lote — en un plazo mensual, el nivel le cuesta un número fijo de dólares, mientras que un lote de una sola imagen le cuesta rendimiento cada hora de cada día.

## Poner en marcha ComfyUI

ComfyUI es una de las imágenes que podemos dejar escritas en la máquina antes de la entrega, lo que hace que esta sección sea opcional. Si prefiere montarlo usted mismo, es un contenedor y un túnel.

En una máquina recién entregada

```
$ ssh root@203.0.113.42
$ nvidia-smi --query-gpu=name,memory.total --format=csv

# Checkpoints, LoRAs, ControlNets and VAEs on the fast local NVMe.
# This directory is the reason you are renting by the month.
$ mkdir -p /scratch/comfy/models
$ df -h /scratch
```

El servidor, vinculado a loopback

```
$ docker run -d --name comfy --restart unless-stopped \
    --gpus all --ipc=host \
    -v /scratch/comfy:/data \
    -p 127.0.0.1:8188:8188 \
    your-comfyui-image --listen 0.0.0.0 --port 8188

# From YOUR machine, not the server: a tunnel, then a local browser tab.
$ ssh -N -L 8188:127.0.0.1:8188 root@203.0.113.42
# http://127.0.0.1:8188
```

**Fíjese en `127.0.0.1:` delante del puerto.** ComfyUI no tiene inicio de sesión, ni contraseña, ni concepto de usuario. Publicado en una dirección pública, es una interfaz gráfica a su GPU, su biblioteca de modelos y el sistema de archivos subyacente, ofrecida a cualquiera que escanee el puerto — y se escanean en cuestión de minutos. Vincúlelo a loopback y acceda a través de SSH. La [documentación](https://gpuserver.io/es/docs) detalla el firewall y la primera hora con más profundidad.

## Qué compra un mes

La razón por la que el trabajo con imagen encaja con una máquina mensual no es el precio de la GPU. Es la biblioteca. Una instalación seria de ComfyUI son varios cientos de gigabytes de checkpoints, LoRAs, ControlNets, upscalers y VAEs que ha ido curando y no quiere volver a descargar.

**El disco está incluido en el precio, en todas las máquinas de una sola tarjeta.** 2 × 2 TB NVMe y 1 Gbit/s, sin contador en ambas direcciones — igual en el nodo $125 que en el $1,469. Nada de eso se factura por gigabyte, nada sigue facturando cuando la tarjeta está inactiva, y no se le cobra de nuevo el día que vuelva a descargar la biblioteca tras una reinstalación.

Esa es la columna que hay que comparar, y es la que las plataformas por horas omiten del titular. Allí el disco es una partida aparte, con precio por gigabyte al mes, y sigue facturando mientras la instancia está detenida — o lo borra, y tiene que volver a descargar varios cientos de gigabytes la próxima vez que se ponga a trabajar.

Esa es la misma trampa que describe el [punto de equilibrio por horas](https://gpuserver.io/es/guides/monthly-vs-hourly), en la forma que adopta para el trabajo con imagen. La facturación por segundo parece segura porque puede detener la instancia, y nadie la detiene, porque detenerla significa perder la biblioteca. La pregunta honesta no es «cuántas horas voy a generar» sino «cuántas horas necesita existir esta máquina» — y para cualquiera con un directorio de modelos curado, la respuesta es todas. El pago es [una sola transferencia en cripto](https://gpuserver.io/es/guides/pay-in-crypto), no hay cuota de configuración, y [no le preguntamos quién es](https://gpuserver.io/es/no-kyc-gpu-server): los prompts, las LoRAs que ha entrenado y el trabajo de clientes que aún no ha entregado permanecen en una máquina en la que solo usted tiene acceso root.

## Cuándo no alquilar una tarjeta

Preferimos que no alquile una de estas máquinas y luego se arrepienta, así que aquí tiene los casos en los que la respuesta es no.

**Genera un par de docenas de imágenes a la semana.** Un endpoint alojado le costará unos pocos dólares al mes y ninguna tarde. Vuelva cuando la cola, los límites de resolución o las normas de contenido empiecen a decidir su trabajo por usted.

**Quiere el modelo cerrado más reciente.** Los servicios de imagen más conocidos no publican los pesos. Ninguna máquina de esta página los ejecuta, y ninguna cantidad de memoria lo cambia.

**Quiere una imagen más rápida y está mirando nodos multi-GPU.** Compre en su lugar una única tarjeta más rápida. Las tarjetas adicionales le dan workers en paralelo, y los workers en paralelo valen mucho — pero no para quien está mirando una sola barra de progreso.

**Todavía no se ha decidido por un modelo.** Alquile por horas en algún sitio hasta que sepa si va a ejecutar SDXL 1.0 a 1024 px o Wan 2.1 video 14B a cinco segundos por clip. Esas dos respuestas distan $161 al mes, y no hay motivo para adivinar.

En cualquier otro caso — una biblioteca que ha construido, un pipeline que sigue cambiando, trabajos por lotes que se ejecutan durante la noche, o un trabajo que simplemente no debería salir de su propio disco — una tarjeta dedicada al mes es la opción más barata y más tranquila. El [configurador](https://gpuserver.io/es/configure) le dirá, para cada nodo del [catálogo](https://gpuserver.io/es/#catalog), si el modelo que tiene en mente cabe en una tarjeta antes de que pague nada.

## Compruebe que su modelo cabe antes de pagar.

El configurador indica la memoria que necesita un modelo y si cabe en una sola tarjeta, para cada máquina del catálogo.

[Abrir el configurador](https://gpuserver.io/es/configure) [Leer las guías](https://gpuserver.io/es/guides)

## Otras guías

- [Dimensionamiento · 10 min Elegir un formato de cuantización Lo que cuestan AWQ, GPTQ, GGUF y FP8 en memoria, velocidad y calidad — y por qué el formato con los pesos más pequeños rara vez da el modelo más pequeño. Leer la guía](https://gpuserver.io/es/guides/awq-vs-gptq-vs-fp8)
- [Dimensionamiento · 10 min Ejecutar un modelo de mezcla de expertos Los parámetros totales deciden la máquina; los activos, la velocidad. Cuánta VRAM necesitan DeepSeek V3 y Qwen 3 235B, y qué nodo alquilar para ellos. Leer la guía](https://gpuserver.io/es/guides/mixture-of-experts)
- [Coste · 6 min Cuándo el alquiler mensual gana al alquiler por horas El punto de equilibrio con cifras reales, los tres costes que un precio por hora oculta hasta la factura, y la trampa del tiempo inactivo que la triplica. Leer la guía](https://gpuserver.io/es/guides/monthly-vs-hourly)

---

Fuente: https://gpuserver.io/es/guides/gpu-for-flux-sdxl/. Este archivo se genera a partir de los mismos datos que el sitio web; si una cifra aquí difiere de la de una página, prevalece la página y este archivo está desactualizado: la fuente canónica es https://gpuserver.io/.