Entrena una LoRA de Stable Diffusion por menos de 10 $ en una GPU alquilada

Entrenar una LoRA para SDXL o para un modelo Flux pequeño en una GPU alquilada cuesta bastante menos de 10 $. En septiembre de 2026, una RTX 4090 se alquila por unos 0,31 $ la hora en Vast.ai y por 0,74 $ la hora en RunPod, y una sesión de LoRA de SDXL, con preparación y pruebas, dura algo más de una hora. Eso son entre 0,34 $ y 0,80 $ por intento, así que con 10 $ tienes para una docena.

Lo difícil no es el dinero. Lo difícil son las imágenes, las descripciones y saber cuándo parar. Esta guía lo cubre todo, con comandos que puedes copiar y pegar. Los precios y las versiones de las herramientas se comprobaron en septiembre de 2026; las fuentes están al final.

El proceso en cinco pasos

Qué es una LoRA y por qué sale barata

LoRA (Low-Rank Adaptation) congela el modelo base y entrena dos matrices pequeñas junto a algunas de sus capas. El artículo original informaba de una reducción de 10.000 veces en los parámetros entrenables y de 3 veces en la memoria de GPU frente al fine-tuning completo de GPT-3 175B. Los modelos de imagen funcionan igual: el checkpoint base de SDXL es un archivo de 6,9 GB, mientras que la LoRA que entrenas es un archivo pequeño y aparte que cargas encima con la intensidad que quieras.

Por eso basta con una sola GPU de consumo, y por eso una sesión dura decenas de minutos y no días.

Elige la GPU por la VRAM

La VRAM decide qué puedes entrenar. La velocidad decide cuántos minutos facturados dura la sesión, así que una tarjeta más rápida y más cara por hora puede acabar costando más o menos lo mismo por sesión.

Familia de modelos	Mínimo documentado	Holgado	Notas
SD 1.5	8 GB	12 GB o más	Entrena a 512x512, lo más barato y rápido
SDXL	8 GB (10 GB recomendados)	24 GB	Solo U-Net, latentes y salidas del codificador de texto en caché
FLUX.1 [dev] (12B)	8 GB con mucho intercambio de bloques	24 GB	sd-scripts documenta ajustes para 24, 16, 12, 10 y 8 GB
FLUX.2 [klein] 4B/9B	no se indica	24 GB	BFL: unos 13 GB de pesos en bf16, una LoRA cabe en menos de 24 GB

Los ajustes para poca VRAM funcionan, pero son lentos. sd-scripts mete FLUX.1 en 8 a 16 GB intercambiando bloques del transformer entre la GPU y la RAM del sistema, y cada intercambio cuesta un tiempo que pagas. En una máquina alquilada, lo sensato es una tarjeta de 24 GB: una RTX 3090 o 4090. La RTX 5090 (32 GB) también sirve, pero sd-scripts avisa de que necesita PyTorch 2.8.0 con CUDA 12.8 o 12.9, así que comprueba que tu plantilla trae una versión lo bastante reciente.

Las tarjetas de centro de datos son más rápidas, pero RunPod anuncia una A100 de 80 GB a 1,59 $ la hora, más del doble que una 4090. Para una LoRA con 20 o 30 imágenes, la velocidad extra rara vez compensa; tienen más sentido con conjuntos de datos grandes o con fine-tuning completo.

Dónde alquilar y cuánto cuesta

Necesitas una plataforma que te dé una máquina: una shell o un notebook de Jupyter, un disco y una forma de subir y bajar archivos. Vast.ai y RunPod son las dos opciones más habituales para este tipo de trabajo.

GPU	VRAM	Vast.ai (desde)	Página de precios de RunPod	RunPod, lo más barato registrado
RTX 3090	24 GB	unos 0,11–0,13 $/h	0,50 $/h	0,22 $/h
RTX 4090	24 GB	unos 0,31–0,33 $/h	0,74 $/h	0,34 $/h
RTX 5090	32 GB	unos 0,41–0,47 $/h	0,99 $/h	0,69 $/h

Precios de septiembre de 2026. «Vast.ai (desde)» y «RunPod, lo más barato registrado» salen del rastreador de precios de getdeploying.com; la columna central es la página de precios de RunPod. En Vast.ai cada host fija su precio, así que las ofertas que veas cambiarán según la ubicación y la puntuación de fiabilidad.

Las dos facturan por segundo. Los extras son distintos, y en un trabajo de una hora pesan más de lo que sugiere el precio por hora:

• Vast.ai cobra el almacenamiento «mientras exista tu instancia, esté o no en marcha», y cobra el ancho de banda por byte, a la tarifa que fija cada host. Descargar un modelo base de 7 GB en un host con ancho de banda caro se nota. Borra la instancia; no te limites a pararla.
• RunPod cobra 0,10 $ por GB al mes por el disco del contenedor mientras funciona, nada una vez parado, y 0,20 $ por GB al mes por un disco de volumen parado. No cobra la entrada ni la salida de datos.

Las dos tienen plantillas listas para usar. El autor de ai-toolkit mantiene una plantilla oficial para RunPod, y el README de kohya_ss cita RunPod como entorno compatible. Una plantilla te ahorra diez minutos o más instalando PyTorch con el contador en marcha. Para una comparativa de precios más amplia, consulta GPUFlow frente a Vast.ai, RunPod y SaladCloud y los costes ocultos de alquilar una GPU.

Prepara las imágenes y las descripciones

Haz todo esto en tu propio ordenador antes de alquilar nada.

Imágenes

• Cantidad. Entre 15 y 40 imágenes para una persona, un objeto o un estilo. Black Forest Labs recomienda «15–40 imágenes que compartan un mismo aspecto» para FLUX.2 [klein]. Más no es mejor si las imágenes de más son peores.
• Coherencia y variedad. Todas las imágenes tienen que mostrar el concepto. Todo lo demás debe variar: ángulo, luz, fondo, encuadre. Si en todas las fotos tu producto está sobre la misma mesa blanca, la LoRA aprende la mesa.
• Calidad. Nítidas, bien expuestas, sin marcas de agua ni textos superpuestos. La LoRA aprende el ruido y los bloques de JPEG con la misma fidelidad que todo lo demás.
• Resolución. Al menos 1024 píxeles en el lado corto para SDXL y Flux, 512 para SD 1.5. No hace falta recortar en cuadrado: con el bucketing activado, sd-scripts agrupa las imágenes por relación de aspecto.

Descripciones

Cada imagen lleva un archivo de texto con el mismo nombre (photo01.jpg, photo01.txt). La descripción (el caption) le dice al modelo lo que ya queda explicado con palabras, para que la LoRA aprenda lo que no. Pon primero una palabra clave poco común y después describe todo lo que quieras que siga siendo modificable:

zxq_mug, a ceramic coffee mug on a wooden desk, morning light from the left, shallow depth of field

Hay dos herramientas que te escriben un primer borrador:

• WD14 tagger, incluido en sd-scripts, genera etiquetas separadas por comas. Va bien para modelos de estilo anime y para fine-tunes de SDXL entrenados con etiquetas:

  python finetune/tag_images_by_wd14_tagger.py --onnx \
    --repo_id SmilingWolf/wd-swinv2-tagger-v3 --batch_size 4 /workspace/dataset/img

• JoyCaption, un modelo de descripción abierto (Apache 2.0) creado para entrenar modelos de difusión, escribe frases en lenguaje natural, que a Flux le sientan mejor que las etiquetas. Su README dice que necesita unos 17 GB de VRAM en bf16, con versiones de 8 y 4 bits para tarjetas más pequeñas.

OneTrainer también genera descripciones con BLIP, BLIP2 y WD-1.4. Uses lo que uses para el borrador, lee cada descripción y corrígela. Es la media hora más rentable de todo el proyecto.

Elige el entrenador

Cuatro herramientas cubren a casi todo el mundo. Todas son gratuitas y de código abierto.

Herramienta	Interfaz	Modelos (septiembre de 2026)	Encaja bien en
kohya-ss/sd-scripts	Línea de comandos	SD 1.x/2.x, SDXL, SD3/3.5, FLUX.1, Lumina, HunyuanImage-2.1, Anima	Sesiones reproducibles, control total
bmaltais/kohya_ss	Interfaz web sobre sd-scripts	Los mismos que sd-scripts	sd-scripts sin memorizar opciones
Nerogar/OneTrainer	Interfaz de escritorio y CLI	SD 1.5 a 3.5, SDXL, FLUX.1, FLUX.2, Chroma, Qwen Image y más	Descripciones y máscaras integradas
ostris/ai-toolkit	Interfaz web y configuraciones YAML	SD 1.5, SDXL, FLUX.1, FLUX.2, Qwen-Image, vídeo Wan y más	Flux y modelos más nuevos, plantilla para RunPod

sd-scripts va por la versión 0.11.1 (junio de 2026), está probado con Python 3.10 y necesita PyTorch 2.6.0 o posterior. ai-toolkit recomienda Python 3.12 y ahora instala PyTorch 2.13.0 compilado para CUDA 13.0. OneTrainer necesita Python de la 3.10 a la 3.13.

Yo uso sd-scripts para SDXL, porque la línea de comandos es toda la configuración y eso hace que las sesiones sean fáciles de repetir y comparar, y ai-toolkit para Flux.

Entrena una LoRA de SDXL con sd-scripts

En una instancia Linux recién creada con driver de NVIDIA, la instalación son unos pocos comandos:

git clone https://github.com/kohya-ss/sd-scripts.git
cd sd-scripts
python -m venv venv && source venv/bin/activate
pip install torch==2.6.0 torchvision==0.21.0 --index-url https://download.pytorch.org/whl/cu124
pip install --upgrade -r requirements.txt
accelerate config default --mixed_precision bf16

# SDXL base model (not gated, CreativeML Open RAIL++-M license)
hf download stabilityai/stable-diffusion-xl-base-1.0 sd_xl_base_1.0.safetensors \
  --local-dir /workspace/models

Copia tu carpeta de imágenes y descripciones .txt a /workspace/dataset/img con scp, rsync o el explorador de archivos de la plataforma. Después describe el conjunto de datos en /workspace/dataset.toml:

[general]
caption_extension = ".txt"
enable_bucket = true

[[datasets]]
resolution = 1024
batch_size = 1

  [[datasets.subsets]]
  image_dir = "/workspace/dataset/img"
  num_repeats = 10

Y lanza el entrenamiento:

accelerate launch --num_cpu_threads_per_process 1 sdxl_train_network.py \
  --pretrained_model_name_or_path=/workspace/models/sd_xl_base_1.0.safetensors \
  --dataset_config=/workspace/dataset.toml \
  --output_dir=/workspace/output --output_name=zxq_mug \
  --save_model_as=safetensors \
  --network_module=networks.lora --network_dim=16 --network_alpha=8 \
  --network_train_unet_only \
  --optimizer_type=AdamW8bit --learning_rate=1e-4 \
  --lr_scheduler=constant_with_warmup --lr_warmup_steps=100 \
  --max_train_epochs=8 --save_every_n_epochs=2 \
  --mixed_precision=bf16 --save_precision=bf16 \
  --cache_latents --cache_latents_to_disk --cache_text_encoder_outputs \
  --gradient_checkpointing --sdpa --seed=42 \
  --sample_prompts=/workspace/prompts.txt --sample_every_n_epochs=2

prompts.txt tiene un prompt de prueba por línea, con las opciones en línea de sd-scripts para tamaño, semilla y pasos:

zxq_mug, a ceramic coffee mug on a kitchen counter --w 1024 --h 1024 --d 42 --s 28
zxq_mug, a ceramic coffee mug held by a hiker on a mountain top --w 1024 --h 1024 --d 42 --s 28

Qué hace cada ajuste

• Pasos. Imágenes × repeticiones × épocas ÷ tamaño de lote. Con 25 imágenes: 25 × 10 × 8 = 2000 pasos.
• network_dim 16, network_alpha 8. La capacidad de la LoRA. 16 sobra para un objeto o una cara; los estilos a veces piden 32. Los rangos más altos se sobreajustan antes y generan archivos más grandes.
• --network_train_unet_only. Aquí es obligatorio: sd-scripts se niega a cachear las salidas del codificador de texto si a la vez entrenas los codificadores, y de todos modos su documentación dice que entrenar solo la U-Net es «muy recomendable» para las LoRAs de SDXL.
• Caché y gradient checkpointing. Son lo que hace que SDXL quepa en 8 a 10 GB. La caché también desactiva el barajado y el descarte de descripciones, y por eso no aparecen en el archivo del conjunto de datos.
• learning_rate 1e-4 con AdamW8bit. El valor del propio ejemplo de LoRA de SDXL de sd-scripts. Si las muestras apenas cambian después de cuatro épocas, prueba con 2e-4. Si se convierten en copias de tus imágenes de entrenamiento, bájalo o para antes.
• Checkpoints cada 2 épocas. Tendrás archivos de las épocas 2, 4, 6 y 8, y te quedas con el mejor. La mejor LoRA a menudo no es la última.

Cuánto tarda

En un hilo de incidencias de kohya_ss, varios usuarios indicaban entre 1,1 y 1,4 iteraciones por segundo entrenando una LoRA de SDXL a 1024x1024, con tamaño de lote 1, en una RTX 4090 con gradient checkpointing. A esa velocidad, 2000 pasos llevan entre 24 y 30 minutos, más unos minutos para cachear los latentes. El mismo hilo muestra lo mal que va todo cuando una tarjeta se queda sin VRAM y tira de memoria compartida: 50 segundos o más por paso. Si tu velocidad está muy por debajo de lo esperado, mira nvidia-smi antes de culpar a los ajustes.

Flux y modelos más nuevos con ai-toolkit

Para Flux, ai-toolkit es el camino más fácil. En una máquina alquilada:

git clone https://github.com/ostris/ai-toolkit.git
cd ai-toolkit
python3 -m venv venv && source venv/bin/activate
pip3 install --no-cache-dir torch==2.13.0 torchvision==0.28.0 torchaudio==2.11.0 \
  --index-url https://download.pytorch.org/whl/cu130
pip3 install -r requirements.txt
cp config/examples/train_lora_flux_24gb.yaml config/zxq_mug.yml
# edit the dataset path, trigger word and steps, then:
python run.py config/zxq_mug.yml

O arranca la interfaz web con cd ui && npm run build_and_start y abre el puerto 8675. En un servidor al que pueda llegar otra gente, pon antes una contraseña en AI_TOOLKIT_AUTH, como recomienda el README.

Dos cosas sobre licencias antes de elegir un modelo Flux:

• FLUX.1 [dev] tiene acceso restringido en Hugging Face. Aceptas la FLUX.1 [dev] Non-Commercial License y usas un token de lectura de Hugging Face para descargarlo. Su ficha dice que las imágenes generadas se pueden usar comercialmente; los pesos y tu LoRA quedan bajo la licencia no comercial.
• FLUX.2 [klein] 4B es Apache 2.0 y no tiene acceso restringido. La versión 9B usa la FLUX Non-Commercial License.

Black Forest Labs publicó en junio de 2026 una guía para entrenar LoRAs de FLUX.2 [klein] con ai-toolkit: una sesión de 1800 pasos en una RTX 4090 «tarda menos de una hora», y recomiendan revisar los checkpoints entre los pasos 750 y 1500. No he encontrado una cifra publicada igual de sólida para FLUX.1 [dev], que triplica el tamaño de klein 4B; cuenta con más tiempo y mide tu primera sesión.

Prueba la LoRA antes de dejar de pagar

Mira las imágenes de muestra de cada época guardada mientras la máquina sigue en marcha. Te dicen, gratis, si la LoRA ha aprendido el concepto y cuándo empezó a sobreajustarse. Después descarga los checkpoints que te gusten:

rsync -avP user@your-instance:/workspace/output/*.safetensors ./loras/

En casa, pon el archivo en la carpeta models/loras de ComfyUI o en models/Lora de Forge, y prueba con semillas fijas:

• Intensidad. Prueba 0,6, 0,8 y 1,0. Algunas LoRAs quedan mejor por debajo de 1,0.
• Flexibilidad. Pon la palabra clave en escenas que no estaban en tus datos. Una taza en una montaña, una cara en un cuadro. Si solo funciona en escenas parecidas a las de entrenamiento, está sobreajustada: usa una época anterior o menos repeticiones.
• Fugas. Genera sin la palabra clave. Si el concepto aparece igualmente, tus descripciones no describían lo suficiente de la imagen.

Cuando el resultado no es bueno, el arreglo suele estar en los datos: quitar unas cuantas imágenes flojas o escribir descripciones que nombren lo que quieres que varíe. Cambiar la tasa de aprendizaje es lo segundo que hay que probar, no lo primero.

El coste, paso a paso

Una LoRA de SDXL, 25 imágenes, 2000 pasos, en una RTX 4090:

Paso	Tiempo
Arrancar desde una plantilla, instalar sd-scripts	10 min
Descargar SDXL base, subir las imágenes, cachear	10 min
Entrenamiento (2000 pasos a 1,1–1,4 it/s)	30 min
Revisar muestras, descargar checkpoints, borrar la instancia	15 min
Total	65 min (1,08 h)

• Vast.ai a 0,31 $/h: 1,08 × 0,31 $ = 0,34 $, más el almacenamiento y la tarifa de ancho de banda del host.
• RunPod a 0,74 $/h: 1,08 × 0,74 $ = 0,80 $. Un disco de contenedor de 50 GB durante esa hora suma 50 × 0,10 $ ÷ 730 horas = menos de 1 centavo.

Una LoRA de FLUX.2 [klein] con una hora de entrenamiento y 30 minutos de preparación y pruebas sale a 1,5 × 0,74 $ = 1,11 $ en RunPod, o 1,5 × 0,31 $ = 0,47 $ en Vast.ai.

Lo que de verdad se come un presupuesto de 10 $ rara vez es el entrenamiento. Es una instancia que se queda encendida toda la noche (12 horas a 0,74 $ son 8,88 $), una instancia de Vast.ai parada que sigue pagando almacenamiento o una hora describiendo imágenes con el contador en marcha. La facturación por segundo solo ayuda si borras la máquina cuando terminas.

Dónde encaja GPUFlow

En este trabajo, no encaja. GPUFlow alquila acceso a un modelo de lenguaje que un proveedor sirve (normalmente con Ollama) en su propia GPU, mediante una clave API compatible con OpenAI. No hay shell, ni SSH, ni acceso a archivos, así que no puedes instalar un entrenador, subir imágenes ni descargar una LoRA. Además sirve modelos de chat, no modelos de imagen. Entrena en Vast.ai, RunPod o una plataforma parecida que te alquile la máquina.

Si trabajas con texto y no con imágenes, el mismo enfoque de alquilar, entrenar y borrar vale para los modelos de lenguaje: consulta cómo hacer fine-tuning de un LLM en privado en una GPU alquilada.

Fuentes

Todas revisadas en septiembre de 2026.

• Artículo de LoRA: Hu et al., LoRA: Low-Rank Adaptation of Large Language Models
• sd-scripts: README y versiones, entrenamiento de LoRAs de SDXL, notas sobre SDXL y VRAM, configuración del conjunto de datos, entrenamiento de LoRAs de FLUX.1, WD14 tagger
• bmaltais/kohya_ss, Nerogar/OneTrainer, ostris/ai-toolkit, JoyCaption
• Velocidades de SDXL en la 4090: incidencia n.º 1288 de kohya_ss
• Black Forest Labs: Fine-tune FLUX.2 [klein] with a LoRA under 60 minutes, fichas de modelo de FLUX.1 [dev], FLUX.2 [klein] 4B y FLUX.2 [klein] 9B
• Ficha del modelo Stable Diffusion XL base 1.0
• Precios: precios de RunPod, precios y almacenamiento de pods en RunPod, precios de Vast.ai, getdeploying.com para la RTX 3090, la RTX 4090, la RTX 5090 y Vast.ai
• GPUFlow: guía rápida de la API