SDXL en 4 pasos con Latent Consistency LoRAs

SDXL en 4 pasos con Latent Consistency LoRAs Un Poder Transformador para tu Cabello

Los Modelos de Consistencia Latente (LCM) son una forma de reducir el número de pasos necesarios para generar una imagen con Stable Diffusion (o SDXL) al destilar el modelo original en otra versión que requiere menos pasos (4 a 8 en lugar de los 25 a 50 originales). La destilación es un tipo de procedimiento de entrenamiento que intenta replicar las salidas de un modelo fuente utilizando uno nuevo. El modelo destilado puede ser diseñado para ser más pequeño (como en el caso de DistilBERT o el recientemente lanzado Distil-Whisper) o, en este caso, requerir menos pasos para ejecutarse. Usualmente es un proceso largo y costoso que requiere grandes cantidades de datos, paciencia y algunas GPUs.

¡Bueno, eso era el estado actual antes de hoy!

¡Nos complace anunciar un nuevo método que puede hacer que Stable Diffusion y SDXL sean más rápidos, como si hubieran sido destilados utilizando el proceso de LCM! ¿Cómo suena poder ejecutar cualquier modelo SDXL en aproximadamente 1 segundo en lugar de 7 en una 3090, o 10 veces más rápido en Mac? ¡Sigue leyendo para obtener más detalles!

Contenido

• Resumen del Método
• ¿Por qué esto es importante?
• Inferencia Rápida con SDXL LCM LoRAs
  • Comparación de calidad
  • Escala de orientación y promociones negativas
  • Calidad vs SDXL base
  • LCM LoRAs con otros modelos
  • Integración completa de diffusers
• Benchmarks
• LCM LoRAs y modelos lanzados hoy
• Bonus: Combinar LCM LoRAs con LCM LoRAs regulares de SDXL
• Cómo entrenar LCM LoRAs
• Recursos
• Créditos

Resumen del Método

Entonces, ¿cuál es el truco? Para la destilación de consistencia latente, cada modelo debe ser destilado por separado. La idea central de LCM LoRA es entrenar solo un pequeño número de adaptadores, conocidos como capas LoRA, en lugar del modelo completo. Los LoRAs resultantes se pueden aplicar a cualquier versión afinada del modelo sin necesidad de destilarlos por separado. Si estás ansioso por ver cómo se ve esto en la práctica, simplemente salta a la siguiente sección para jugar con el código de inferencia. Si quieres entrenar tus propios LoRAs, este es el proceso que usarías:

• Auriculares para monitorear el cerebro y el cuerpo
• Utilizando el lenguaje para dar a los robots una mejor comprensión del mundo abierto
• Algoritmo ayuda en la detección temprana de enfermedades oculares relacionadas con la edad

1. Selecciona un modelo de profesor disponible en el Hub. Por ejemplo, puedes usar SDXL (base), o cualquier versión afinada o mejorada con dreambooth que te guste.
2. Entrena un LCM LoRA en el modelo. LoRA es un tipo de afinación óptima de rendimiento, o PEFT, que es mucho más económico de lograr que una afinación completa del modelo. Para obtener más detalles sobre PEFT, consulta esta publicación en el blog o la documentación de difusores LoRA.
3. Utiliza el LoRA con cualquier modelo de difusión SDXL y el programador LCM; ¡bingo! Obtendrás inferencia de alta calidad en solo unos pocos pasos.

Para obtener más detalles sobre el proceso, descarga nuestro artículo.

¿Por qué esto es importante?

La inferencia rápida de Stable Diffusion y SDXL permite nuevos casos de uso y flujos de trabajo. Algunos ejemplos son:

• Accesibilidad: las herramientas generativas pueden ser utilizadas de manera efectiva por más personas, incluso si no tienen acceso al hardware más reciente.
• Iteración más rápida: ¡obtén más imágenes y múltiples variantes en fracciones de tiempo! Esto es ideal para artistas e investigadores, ya sea para uso personal o comercial.
• Las cargas de trabajo de producción pueden ser posibles en diferentes aceleradores, incluyendo CPUs.
• Servicios de generación de imágenes más económicos.

Para tener una idea de la velocidad de diferencia de la que estamos hablando, generar una sola imagen de 1024×1024 en una Mac M1 con SDXL (base) tarda aproximadamente un minuto. Usando el LCM LoRA, obtenemos resultados excelentes en solo ~6s (4 pasos). Esto es una mejora de un orden de magnitud en cuanto a velocidad, y el no tener que esperar por los resultados marca una gran diferencia. Usando un 4090, obtenemos una respuesta casi instantánea (menos de 1s). Esto permite utilizar SDXL en aplicaciones donde se requieren eventos en tiempo real.

Inferencia Rápida con SDXL LCM LoRAs

La versión de diffusers lanzada hoy hace que sea muy fácil usar LCM LoRAs:

from diffusers import DiffusionPipeline, LCMSchedulerimport torchmodel_id = "stabilityai/stable-diffusion-xl-base-1.0"lcm_lora_id = "latent-consistency/lcm-lora-sdxl"pipe = DiffusionPipeline.from_pretrained(model_id, variant="fp16")pipe.load_lora_weights(lcm_lora_id)pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)pipe.to(device="cuda", dtype=torch.float16)prompt = "fotografía de primer plano de un anciano parado bajo la lluvia en la noche, en una calle iluminada por lámparas, leica 35mm summilux"images = pipe(    prompt=prompt,    num_inference_steps=4,    guidance_scale=1,).images[0]

Observa cómo el código:

• Instancia un pipeline de difusión estándar con el modelo base SDXL 1.0.
• Aplica el LCM LoRA.
• Cambia el programador al LCMScheduler, que es el que se utiliza en los modelos de consistencia latente.
• ¡Y eso es todo!

Esto resultará en la siguiente imagen en resolución completa:

Imagen generada con SDXL en 4 pasos utilizando un LCM LoRA.

Comparación de Calidad

Veamos cómo el número de pasos afecta la calidad de generación. El siguiente código generará imágenes con 1 a 8 pasos de inferencia en total:

imágenes = []
for steps in range(8):
    generador = torch.Generator(device=pipe.device).manual_seed(1337)
    imagen = pipe(
        prompt=prompt,
        num_inference_steps=steps+1,
        guidance_scale=1,
        generator=generador,
    ).images[0]
    imágenes.append(imagen)

Estas son las 8 imágenes mostradas en una cuadrícula:

Generaciones de LCM LoRA con 1 a 8 pasos.

Como se esperaba, utilizando solo 1 paso se produce una forma aproximada sin características discernibles y sin textura. Sin embargo, los resultados mejoran rápidamente y generalmente son muy satisfactorios en solo 4 a 6 pasos. Personalmente, encuentro que la imagen de 8 pasos en la prueba anterior está un poco demasiado saturada y “caricaturesca” para mi gusto, así que probablemente elegiría entre las que tienen 5 y 6 pasos en este ejemplo. La generación es tan rápida que puedes crear un montón de variantes diferentes usando solo 4 pasos, y luego seleccionar las que te gusten e iterar utilizando un par de pasos más y promps refinados según sea necesario.

Escala de Guía y Prompts Negativos

Es importante tener en cuenta que en los ejemplos anteriores utilizamos una escala_de_guia de 1, lo cual la deshabilita efectivamente. Esto funciona bien para la mayoría de los prompts y es más rápido, pero ignora los prompts negativos. También puedes explorar el uso de prompts negativos proporcionando una escala de guía entre 1 y 2 – encontramos que los valores más grandes no funcionan.

Calidad vs SDXL base

¿Cómo se compara esto con el pipeline SDXL estándar en términos de calidad? ¡Veamos un ejemplo!

Podemos rápidamente revertir nuestro pipeline a un pipeline SDXL estándar descargando los pesos de LoRA y cambiando al planificador por defecto:

from diffusers import EulerDiscreteSchedulerpipe.unload_lora_weights()pipe.scheduler = EulerDiscreteScheduler.from_config(pipe.scheduler.config)

Luego podemos ejecutar la inferencia como de costumbre para SDXL. Recopilaremos los resultados utilizando un número variable de pasos:

imágenes = []
for steps in (1, 4, 8, 15, 20, 25, 30, 50):
    generador = torch.Generator(device=pipe.device).manual_seed(1337)
    imagen = pipe(
        prompt=prompt,
        num_inference_steps=steps,
        generator=generador,
    ).images[0]
    imágenes.append(imagen)

Resultados del pipeline SDXL (mismo prompt y semilla aleatoria), utilizando 1, 4, 8, 15, 20, 25, 30 y 50 pasos.

Como puedes ver, las imágenes en este ejemplo son casi inútiles hasta ~20 pasos (segunda fila), y la calidad aún aumenta notablemente con más pasos. Los detalles en la imagen final son sorprendentes, pero tomó 50 pasos llegar allí.

LCM LoRAs con otros modelos

Esta técnica también funciona para cualquier otro modelo SDXL o modelo de Difusión Estable finoajustado. Para demostrarlo, veamos cómo ejecutar inferencia en collage-diffusion, un modelo finoajustado de la Difusión Estable v1.5 utilizando Dreambooth.

El código es similar al que vimos en los ejemplos anteriores. Cargamos el modelo finoajustado y luego el LCM LoRA adecuado para la Difusión Estable v1.5.

from diffusers import DiffusionPipeline, LCMSchedulerimport torchmodel_id = "wavymulder/collage-diffusion"lcm_lora_id = "latent-consistency/lcm-lora-sdv1-5"pipe = DiffusionPipeline.from_pretrained(model_id, variant="fp16")pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)pipe.load_lora_weights(lcm_lora_id)pipe.to(device="cuda", dtype=torch.float16)prompt = "un niño con estilo collage mira el cielo nocturno, lleno de estrellas"generador = torch.Generator(device=pipe.device).manual_seed(1337)imágenes = pipe(
    prompt=prompt,
    generador=generador,
    negative_prompt=negative_prompt,
    num_inference_steps=4,
    escala_de_guia=1,
).images[0]
imágenes

Técnica LCM LoRA con un modelo Dreambooth Stable Diffusion v1.5, permitiendo inferencia de 4 pasos.

Integración completa de Difusores

La integración de LCM en difusores permite aprovechar muchas características y flujos de trabajo que forman parte de la caja de herramientas de difusores. Por ejemplo:

• Soporte mps listo para usar para Macs con Apple Silicon.
• Optimizaciones de memoria y rendimiento como atención flash o torch.compile().
• Estrategias adicionales de ahorro de memoria para entornos de baja RAM, incluida la descarga del modelo.
• Flujos de trabajo como ControlNet o de imagen a imagen.
• Scripts de entrenamiento y ajuste fino.

Marcadores de desempeño

Esta sección no pretende ser exhaustiva, sino ilustrativa de la velocidad de generación que logramos en varias computadoras. Permítanos enfatizar nuevamente lo liberador que es explorar la generación de imágenes de manera tan fácil.

Estas pruebas se realizaron con un tamaño de lote de 1 en todos los casos, utilizando este script de Sayak Paul.

Para tarjetas con mucha capacidad, como A100, el rendimiento aumenta significativamente al generar varias imágenes a la vez, lo cual suele ser el caso de las cargas de trabajo de producción.

LCM LoRAs y Modelos Lanzados Hoy

• Colección de Modelos de Consistencia Latente LoRAs

  • latent-consistency/lcm-lora-sdxl. LCM LoRA para SDXL 1.0 base, como se muestra en los ejemplos anteriores.
  • latent-consistency/lcm-lora-sdv1-5. LCM LoRA para Stable Diffusion 1.5.
  • latent-consistency/lcm-lora-ssd-1b. LCM LoRA para segmind/SSD-1B, un modelo SDXL destilado que es un 50% más pequeño y un 60% más rápido que el SDXL original.

• latent-consistency/lcm-sdxl. Modelo de consistencia finamente ajustado derivado de SDXL 1.0 base.

• latent-consistency/lcm-ssd-1b. Modelo de consistencia finamente ajustado derivado de segmind/SSD-1B.

Bonus: Combina LCM LoRAs con SDXL LoRAs regulares

Usando la integración de difusores + PEFT, puedes combinar LCM LoRAs con SDXL LoRAs regulares, dándoles el superpoder de ejecutar inferencias LCM en solo 4 pasos.

Aquí vamos a combinar el LoRA CiroN2022/toy_face con el LCM LoRA:

from diffusers import DiffusionPipeline, LCMScheduler
import torch

model_id = "stabilityai/stable-diffusion-xl-base-1.0"
lcm_lora_id = "latent-consistency/lcm-lora-sdxl"

pipe = DiffusionPipeline.from_pretrained(model_id, variant="fp16")
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
pipe.load_lora_weights(lcm_lora_id)
pipe.load_lora_weights("CiroN2022/toy-face", weight_name="toy_face_sdxl.safetensors", adapter_name="toy")
pipe.set_adapters(["lora", "toy"], adapter_weights=[1.0, 0.8])
pipe.to(device="cuda", dtype=torch.float16)

prompt = "un hombre con una cara de juguete"
negative_prompt = "borroso, baja calidad, renderizado, 3D, sobreexpuesto"

images = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    num_inference_steps=4,
    guidance_scale=0.5,
).images[0]
images

LoRAs estándar y LCM combinados para una inferencia rápida (4 pasos).

¿Necesitas ideas para explorar algunos LoRAs? ¡Echa un vistazo a nuestro espacio experimental LoRA the Explorer (versión LCM) para probar increíbles creaciones de la comunidad e inspirarte!

Cómo entrenar modelos y LoRAs LCM

Como parte del lanzamiento de diffusers hoy, proporcionamos scripts de entrenamiento y ajuste fino desarrollados en colaboración con los autores del equipo LCM. Esto permite a los usuarios:

• Realizar destilación de modelos completos de Stable Diffusion o SDXL en conjuntos de datos grandes como Laion.
• Entrenar LCM LoRAs, lo cual es un proceso mucho más fácil. Como mostramos en esta publicación, también permite realizar una inferencia rápida con Stable Diffusion, sin necesidad de pasar por un entrenamiento de destilación.

Para obtener más detalles, consulta las instrucciones para SDXL o Stable Diffusion en el repositorio.

Esperamos que estos scripts inspiren a la comunidad a probar sus propios ajustes finos. ¡Por favor, avísanos si los utilizas en tus proyectos!

Recursos

• Página del proyecto de Modelos de Consistencia Latente aquí, artículo.

• LCM LoRAs

  • Para SDXL.
  • Para Stable Diffusion v1.5.
  • Para SSD-1B de Segming.
  • Informe técnico.

• Demos

  • SDXL en 4 pasos con LoRAs de Consistencia Latente
  • Transmisión de video en tiempo real

• LoRA the Explorer (versión experimental de LCM)

• PEFT: Introducción, repo

• Scripts de entrenamiento

  • Para Stable Diffusion 1.5
  • Para SDXL

Créditos

El increíble trabajo en Modelos de Consistencia Latente fue realizado por el Equipo de LCM, asegúrate de revisar su código, informe y paper. Este proyecto es una colaboración entre el equipo de diffusers, el equipo de LCM y el contribuyente de la comunidad Daniel Gu. Creemos que es un testimonio del poder habilitador de la inteligencia artificial de código abierto, el pilar que permite a los investigadores, profesionales y aficionados explorar nuevas ideas y colaborar. También nos gustaría agradecer a @madebyollin por sus continuas contribuciones a la comunidad, incluido el autoencoder float16 que utilizamos en nuestros scripts de entrenamiento.

We will continue to update Zepes; if you have any questions or suggestions, please contact us!