FLUX.1

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

¡Alternativa más rápida! FLUX.2 Klein 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.

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

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

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

# 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 compatibilidad FLUX integrada:

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

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

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

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

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:

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

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

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

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)

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

# 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

pip install diffusers transformers accelerate peft

Carga de una sola 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 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

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)

# 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

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

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

Entrenando tu propia FLUX LoRA

# 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

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

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

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

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

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

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 - La mejor interfaz para FLUX

• Fooocus - Alternativa sencilla

• ControlNet - Generación guiada

• Entrenamiento Kohya - Entrenar LoRAs de FLUX