# Modelos de consistencia latente

  

Los Latent Consistency Models (LCMs) fueron propuestos en [Latent Consistency Models: Synthesizing High-Resolution Images with Few-Step Inference](https://huggingface.co/papers/2310.04378) por Simian Luo, Yiqin Tan, Longbo Huang, Jian Li y Hang Zhao.

El resumen del artículo es el siguiente:

*Los modelos de difusión latente (LDM) han logrado resultados notables en la síntesis de imágenes de alta resolución. Sin embargo, el proceso de muestreo iterativo es computacionalmente intensivo y provoca una generación lenta. Inspirados en los Consistency Models (song et al.), proponemos los Latent Consistency Models (LCM), que permiten una inferencia rápida con un mínimo de pasos en cualquier LDM preentrenado, incluido Stable Diffusion (rombach et al). Al considerar el proceso de difusión inversa guiado como la resolución de una EDO de flujo de probabilidad aumentada (PF-ODE), los LCM están diseñados para predecir directamente la solución de dicha EDO en el espacio latente, lo que mitiga la necesidad de numerosas iteraciones y permite un muestreo rápido y de alta fidelidad. Destilados de manera eficiente a partir de modelos de difusión preentrenados con guía libre de clasificador, un LCM de alta calidad de 768 x 768 con 2~4 pasos requiere solo 32 horas de GPU A100 para su entrenamiento. Además, introducimos el Latent Consistency Fine-tuning (LCF), un método novedoso diseñado específicamente para el ajuste fino de LCM en conjuntos de datos de imágenes personalizados. La evaluación en el conjunto de datos LAION-5B-Aesthetics demuestra que los LCM alcanzan un rendimiento de generación de texto a imagen de última generación con inferencia de pocos pasos. Página del proyecto: [this https URL](https://latent-consistency-models.github.io/).*

Puede encontrarse una demostración del punto de control [SimianLuo/LCM_Dreamshaper_v7](https://huggingface.co/SimianLuo/LCM_Dreamshaper_v7) [aquí](https://huggingface.co/spaces/SimianLuo/Latent_Consistency_Model).

Los pipelines fueron contribuidos por [luosiallen](https://luosiallen.github.io/), [nagolinc](https://github.com/nagolinc) y [dg845](https://github.com/dg845).

> [!TIP]
> Los LCM y LCM-LoRA están disponibles para Stable Diffusion v1.5, Stable Diffusion XL y el modelo SSD-1B. Puedes encontrar sus puntos de control en las colecciones de [Latent Consistency](https://hf.co/collections/latent-consistency/latent-consistency-models-weights-654ce61a95edd6dffccef6a8).

## Texto a imagen

Para usar LCM, debes cargar el checkpoint de LCM para tu modelo compatible en [UNet2DConditionModel](/docs/diffusers/v0.43.0/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel) y reemplazar el scheduler con [LCMScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/lcm#diffusers.LCMScheduler). Luego puedes usar el pipeline como de costumbre y pasar un prompt de texto para generar una imagen en solo 4 pasos.

Hay algunas notas que conviene tener en cuenta al usar LCMs:

* Por lo general, el tamaño del lote se duplica dentro del pipeline para la guía sin clasificador. Sin embargo, LCM aplica la guía mediante embeddings de guía y no necesita duplicar el tamaño del lote, lo que conduce a una inferencia más rápida. La desventaja es que los prompts negativos no funcionan con LCM porque no tienen ningún efecto en el proceso de desruido.
* El rango ideal para `guidance_scale` es [3., 13.] porque es con lo que se entrenó el UNet. Sin embargo, desactivar `guidance_scale` con un valor de 1.0 también es efectivo en la mayoría de los casos.

```python
from diffusers import StableDiffusionXLPipeline, UNet2DConditionModel, LCMScheduler
import torch

unet = UNet2DConditionModel.from_pretrained(
    "latent-consistency/lcm-sdxl",
    dtype=torch.float16,
    variant="fp16",
)
pipe = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", unet=unet, dtype=torch.float16, variant="fp16",
).to("cuda")  # or "mps", "xpu", "cpu"
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)

prompt = "Self-portrait oil painting, a beautiful cyborg with golden hair, 8k"
generator = torch.manual_seed(0)
image = pipe(
    prompt=prompt, num_inference_steps=4, generator=generator, guidance_scale=8.0
).images[0]
image
```

    

Para usar LCM-LoRAs, debes reemplazar el scheduler con [LCMScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/lcm#diffusers.LCMScheduler) y cargar los pesos de LCM-LoRA con el método [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights). Luego puedes usar el pipeline como de costumbre y pasar un prompt de texto para generar una imagen en solo 4 pasos.

Hay algunas notas que conviene tener en cuenta al usar LCM-LoRAs:

* Por lo general, el tamaño del lote se duplica dentro del pipeline para la guía sin clasificador. Sin embargo, LCM aplica la guía mediante embeddings de guía y no necesita duplicar el tamaño del lote, lo que conduce a una inferencia más rápida. La desventaja es que los prompts negativos no funcionan con LCM porque no tienen ningún efecto en el proceso de desruido.
* Puedes usar guidance con LCM-LoRAs, pero es muy sensible a valores altos de `guidance_scale` y puede provocar artefactos en la imagen generada. Los mejores valores que hemos encontrado están entre [1.0, 2.0].
* Reemplace [stabilityai/stable-diffusion-xl-base-1.0](https://hf.co/stabilityai/stable-diffusion-xl-base-1.0) por cualquier modelo afinado. Por ejemplo, pruebe usar el checkpoint [animagine-xl](https://huggingface.co/Linaqruf/animagine-xl) para generar imágenes de anime con SDXL.

```py
import torch
from diffusers import DiffusionPipeline, LCMScheduler

pipe = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    variant="fp16",
    dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
pipe.load_lora_weights("latent-consistency/lcm-lora-sdxl")

prompt = "Self-portrait oil painting, a beautiful cyborg with golden hair, 8k"
generator = torch.manual_seed(42)
image = pipe(
    prompt=prompt, num_inference_steps=4, generator=generator, guidance_scale=1.0
).images[0]
image
```

    

## Imagen a imagen

Para usar LCMs para image-to-image, debes cargar el checkpoint de LCM para tu modelo compatible en [UNet2DConditionModel](/docs/diffusers/v0.43.0/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel) y reemplazar el scheduler con [LCMScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/lcm#diffusers.LCMScheduler). Luego puedes usar el pipeline como de costumbre, pasando un prompt de texto y una imagen inicial para generar una imagen en solo 4 pasos.

> [!TIP]
> Experimenta con diferentes valores para `num_inference_steps`, `strength` y `guidance_scale` para obtener los mejores resultados.

```python
import torch
from diffusers import AutoPipelineForImage2Image, UNet2DConditionModel, LCMScheduler
from diffusers.utils import load_image

unet = UNet2DConditionModel.from_pretrained(
    "SimianLuo/LCM_Dreamshaper_v7",
    subfolder="unet",
    dtype=torch.float16,
)

pipe = AutoPipelineForImage2Image.from_pretrained(
    "Lykon/dreamshaper-7",
    unet=unet,
    dtype=torch.float16,
    variant="fp16",
).to("cuda")  # or "mps", "xpu", "cpu"
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)

init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png")
prompt = "Astronauts in a jungle, cold color palette, muted colors, detailed, 8k"
generator = torch.manual_seed(0)
image = pipe(
    prompt,
    image=init_image,
    num_inference_steps=4,
    guidance_scale=7.5,
    strength=0.5,
    generator=generator
).images[0]
image
```

  
    
    imagen inicial
  
  
    
    imagen generada
  

Para usar LCM-LoRAs para image-to-image, debes reemplazar el scheduler con [LCMScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/lcm#diffusers.LCMScheduler) y cargar los pesos de LCM-LoRA con el método [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights). Luego puedes usar el pipeline como de costumbre, pasando un prompt de texto y una imagen inicial para generar una imagen en solo 4 pasos.

> [!TIP]
> Experimenta con diferentes valores para `num_inference_steps`, `strength` y `guidance_scale` para obtener los mejores resultados.

```py
import torch
from diffusers import AutoPipelineForImage2Image, LCMScheduler
from diffusers.utils import make_image_grid, load_image

pipe = AutoPipelineForImage2Image.from_pretrained(
    "Lykon/dreamshaper-7",
    dtype=torch.float16,
    variant="fp16",
).to("cuda")  # or "mps", "xpu", "cpu"

pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)

pipe.load_lora_weights("latent-consistency/lcm-lora-sdv1-5")

init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png")
prompt = "Astronauts in a jungle, cold color palette, muted colors, detailed, 8k"

generator = torch.manual_seed(0)
image = pipe(
    prompt,
    image=init_image,
    num_inference_steps=4,
    guidance_scale=1,
    strength=0.6,
    generator=generator
).images[0]
image
```

  
    
    imagen inicial
  
  
    
    imagen generada
  

## Inpainting

Para usar LCM-LoRAs para inpainting, debes reemplazar el scheduler con [LCMScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/lcm#diffusers.LCMScheduler) y cargar los pesos de LCM-LoRA con el método [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights). Luego puedes usar el pipeline como de costumbre, pasando un prompt de texto, una imagen inicial y una imagen de máscara para generar una imagen en solo 4 pasos.

```py
import torch
from diffusers import AutoPipelineForInpainting, LCMScheduler
from diffusers.utils import load_image, make_image_grid

pipe = AutoPipelineForInpainting.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-inpainting",
    dtype=torch.float16,
    variant="fp16",
).to("cuda")  # or "mps", "xpu", "cpu"

pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)

pipe.load_lora_weights("latent-consistency/lcm-lora-sdv1-5")

init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint.png")
mask_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint_mask.png")

prompt = "concept art digital painting of an elven castle, inspired by lord of the rings, highly detailed, 8k"
generator = torch.manual_seed(0)
image = pipe(
    prompt=prompt,
    image=init_image,
    mask_image=mask_image,
    generator=generator,
    num_inference_steps=4,
    guidance_scale=4,
).images[0]
image
```

  
    
    imagen inicial
  
  
    
    imagen generada
  

## Adaptadores

Los LCM son compatibles con adaptadores como LoRA, ControlNet, T2I-Adapter y AnimateDiff. Puedes llevar la velocidad de los LCM a estos adaptadores para generar imágenes en un estilo determinado o condicionar el modelo con otra entrada, como una imagen canny.

### LoRA

Los adaptadores [LoRA](../../tutorials/using_peft_for_inference) pueden afinarse rápidamente para aprender un nuevo estilo a partir de solo unas pocas imágenes e integrarse en un modelo preentrenado para generar imágenes en ese estilo.

Carga el checkpoint de LCM para tu modelo compatible en [UNet2DConditionModel](/docs/diffusers/v0.43.0/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel) y reemplaza el scheduler con [LCMScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/lcm#diffusers.LCMScheduler). Luego, puedes usar el método [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para cargar los pesos de LoRA en el LCM y generar una imagen estilizada en pocos pasos.

```python
from diffusers import StableDiffusionXLPipeline, UNet2DConditionModel, LCMScheduler
import torch

unet = UNet2DConditionModel.from_pretrained(
    "latent-consistency/lcm-sdxl",
    dtype=torch.float16,
    variant="fp16",
)
pipe = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", unet=unet, dtype=torch.float16, variant="fp16",
).to("cuda")  # or "mps", "xpu", "cpu"
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
pipe.load_lora_weights("TheLastBen/Papercut_SDXL", weight_name="papercut.safetensors", adapter_name="papercut")

prompt = "papercut, a cute fox"
generator = torch.manual_seed(0)
image = pipe(
    prompt=prompt, num_inference_steps=4, generator=generator, guidance_scale=8.0
).images[0]
image
```

    

Sustituye el programador por el [LCMScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/lcm#diffusers.LCMScheduler). A continuación, puedes usar el método [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para cargar los pesos de LCM-LoRA y el LoRA de estilo que desees utilizar. Combina ambos adaptadores LoRA con el método `~loaders.UNet2DConditionLoadersMixin.set_adapters` y genera una imagen con estilo en pocos pasos.

```py
import torch
from diffusers import DiffusionPipeline, LCMScheduler

pipe = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    variant="fp16",
    dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"

pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)

pipe.load_lora_weights("latent-consistency/lcm-lora-sdxl", adapter_name="lcm")
pipe.load_lora_weights("TheLastBen/Papercut_SDXL", weight_name="papercut.safetensors", adapter_name="papercut")

pipe.set_adapters(["lcm", "papercut"], adapter_weights=[1.0, 0.8])

prompt = "papercut, a cute fox"
generator = torch.manual_seed(0)
image = pipe(prompt, num_inference_steps=4, guidance_scale=1, generator=generator).images[0]
image
```

    

### ControlNet

[ControlNet](./controlnet) son adaptadores que pueden entrenarse con una variedad de entradas, como bordes canny, estimación de pose o profundidad. El ControlNet puede insertarse en el pipeline para proporcionar condicionamiento y control adicionales al modelo, logrando una generación más precisa.

Puedes encontrar modelos adicionales de ControlNet entrenados con otras entradas en el repositorio de [lllyasviel](https://hf.co/lllyasviel).

Carga un modelo de ControlNet entrenado con imágenes canny y pásalo a [ControlNetModel](/docs/diffusers/v0.43.0/es/api/models/controlnet#diffusers.ControlNetModel). Luego puedes cargar un modelo LCM en [StableDiffusionControlNetPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/controlnet#diffusers.StableDiffusionControlNetPipeline) y reemplazar el programador con [LCMScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/lcm#diffusers.LCMScheduler). Ahora pasa la imagen canny a la tubería y genera una imagen.

> [!TIP]
> Experimenta con diferentes valores para `num_inference_steps`, `controlnet_conditioning_scale`, `cross_attention_kwargs` y `guidance_scale` para obtener los mejores resultados.

```python
import torch
import cv2
import numpy as np
from PIL import Image

from diffusers import StableDiffusionControlNetPipeline, ControlNetModel, LCMScheduler
from diffusers.utils import load_image, make_image_grid

image = load_image(
    "https://hf.co/datasets/huggingface/documentation-images/resolve/main/diffusers/input_image_vermeer.png"
).resize((512, 512))

image = np.array(image)

low_threshold = 100
high_threshold = 200

image = cv2.Canny(image, low_threshold, high_threshold)
image = image[:, :, None]
image = np.concatenate([image, image, image], axis=2)
canny_image = Image.fromarray(image)

controlnet = ControlNetModel.from_pretrained("lllyasviel/sd-controlnet-canny", dtype=torch.float16)
pipe = StableDiffusionControlNetPipeline.from_pretrained(
    "SimianLuo/LCM_Dreamshaper_v7",
    controlnet=controlnet,
    dtype=torch.float16,
    safety_checker=None,
).to("cuda")  # or "mps", "xpu", "cpu"
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)

generator = torch.manual_seed(0)
image = pipe(
    "the mona lisa",
    image=canny_image,
    num_inference_steps=4,
    generator=generator,
).images[0]
make_image_grid([canny_image, image], rows=1, cols=2)
```

    

Carga un modelo de ControlNet entrenado con imágenes canny y pásalo a [ControlNetModel](/docs/diffusers/v0.43.0/es/api/models/controlnet#diffusers.ControlNetModel). Luego puedes cargar un modelo de Stable Diffusion v1.5 en [StableDiffusionControlNetPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/controlnet#diffusers.StableDiffusionControlNetPipeline) y reemplazar el scheduler con [LCMScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/lcm#diffusers.LCMScheduler). Usa el método [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para cargar los pesos de LCM-LoRA, y pasa la imagen canny a la pipeline para generar una imagen.

> [!TIP]
> Experimenta con diferentes valores para `num_inference_steps`, `controlnet_conditioning_scale`, `cross_attention_kwargs` y `guidance_scale` para obtener los mejores resultados.

```py
import torch
import cv2
import numpy as np
from PIL import Image

from diffusers import StableDiffusionControlNetPipeline, ControlNetModel, LCMScheduler
from diffusers.utils import load_image

image = load_image(
    "https://hf.co/datasets/huggingface/documentation-images/resolve/main/diffusers/input_image_vermeer.png"
).resize((512, 512))

image = np.array(image)

low_threshold = 100
high_threshold = 200

image = cv2.Canny(image, low_threshold, high_threshold)
image = image[:, :, None]
image = np.concatenate([image, image, image], axis=2)
canny_image = Image.fromarray(image)

controlnet = ControlNetModel.from_pretrained("lllyasviel/sd-controlnet-canny", dtype=torch.float16)
pipe = StableDiffusionControlNetPipeline.from_pretrained(
    "stable-diffusion-v1-5/stable-diffusion-v1-5",
    controlnet=controlnet,
    dtype=torch.float16,
    safety_checker=None,
    variant="fp16"
).to("cuda")  # or "mps", "xpu", "cpu"

pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)

pipe.load_lora_weights("latent-consistency/lcm-lora-sdv1-5")

generator = torch.manual_seed(0)
image = pipe(
    "the mona lisa",
    image=canny_image,
    num_inference_steps=4,
    guidance_scale=1.5,
    controlnet_conditioning_scale=0.8,
    cross_attention_kwargs={"scale": 1},
    generator=generator,
).images[0]
image
```

    

### T2I-Adapter

[T2I-Adapter](../../using-diffusers/legacy_adapters#t2i-adapter) es un adaptador aún más ligero que ControlNet, que proporciona una entrada adicional para condicionar un modelo preentrenado. Es más rápido que ControlNet, pero los resultados pueden ser ligeramente peores.

Puedes encontrar puntos de control adicionales de T2I-Adapter entrenados con otras entradas en el repositorio de [TencentArc](https://hf.co/TencentARC).

Carga un T2IAdapter entrenado con imágenes canny y pásalo a [StableDiffusionXLAdapterPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/stable_diffusion/adapter#diffusers.StableDiffusionXLAdapterPipeline). Luego, carga un checkpoint de LCM en [UNet2DConditionModel](/docs/diffusers/v0.43.0/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel) y reemplaza el scheduler con [LCMScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/lcm#diffusers.LCMScheduler). Ahora, pasa la imagen canny a la pipeline y genera una imagen.

```python
import torch
import cv2
import numpy as np
from PIL import Image

from diffusers import StableDiffusionXLAdapterPipeline, UNet2DConditionModel, T2IAdapter, LCMScheduler
from diffusers.utils import load_image, make_image_grid

# detect the canny map in low resolution to avoid high-frequency details
image = load_image(
    "https://hf.co/datasets/huggingface/documentation-images/resolve/main/diffusers/input_image_vermeer.png"
).resize((384, 384))

image = np.array(image)

low_threshold = 100
high_threshold = 200

image = cv2.Canny(image, low_threshold, high_threshold)
image = image[:, :, None]
image = np.concatenate([image, image, image], axis=2)
canny_image = Image.fromarray(image).resize((1024, 1216))

adapter = T2IAdapter.from_pretrained("TencentARC/t2i-adapter-canny-sdxl-1.0", dtype=torch.float16, variant="fp16").to("cuda")  # or "mps", "xpu", "cpu"

unet = UNet2DConditionModel.from_pretrained(
    "latent-consistency/lcm-sdxl",
    dtype=torch.float16,
    variant="fp16",
)
pipe = StableDiffusionXLAdapterPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    unet=unet,
    adapter=adapter,
    dtype=torch.float16,
    variant="fp16",
).to("cuda")

pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)

prompt = "the mona lisa, 4k picture, high quality"
negative_prompt = "extra digit, fewer digits, cropped, worst quality, low quality, glitch, deformed, mutated, ugly, disfigured"

generator = torch.manual_seed(0)
image = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    image=canny_image,
    num_inference_steps=4,
    guidance_scale=5,
    adapter_conditioning_scale=0.8,
    adapter_conditioning_factor=1,
    generator=generator,
).images[0]
```

    

Carga un T2IAdapter entrenado con imágenes canny y pásalo a [StableDiffusionXLAdapterPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/stable_diffusion/adapter#diffusers.StableDiffusionXLAdapterPipeline). Reemplaza el scheduler con [LCMScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/lcm#diffusers.LCMScheduler) y usa el método [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para cargar los pesos de LCM-LoRA. Pasa la imagen canny a la pipeline y genera una imagen.

```py
import torch
import cv2
import numpy as np
from PIL import Image

from diffusers import StableDiffusionXLAdapterPipeline, UNet2DConditionModel, T2IAdapter, LCMScheduler
from diffusers.utils import load_image, make_image_grid

# detect the canny map in low resolution to avoid high-frequency details
image = load_image(
    "https://hf.co/datasets/huggingface/documentation-images/resolve/main/diffusers/input_image_vermeer.png"
).resize((384, 384))

image = np.array(image)

low_threshold = 100
high_threshold = 200

image = cv2.Canny(image, low_threshold, high_threshold)
image = image[:, :, None]
image = np.concatenate([image, image, image], axis=2)
canny_image = Image.fromarray(image).resize((1024, 1024))

adapter = T2IAdapter.from_pretrained("TencentARC/t2i-adapter-canny-sdxl-1.0", dtype=torch.float16, variant="fp16").to("cuda")  # or "mps", "xpu", "cpu"

pipe = StableDiffusionXLAdapterPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    adapter=adapter,
    dtype=torch.float16,
    variant="fp16",
).to("cuda")

pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)

pipe.load_lora_weights("latent-consistency/lcm-lora-sdxl")

prompt = "the mona lisa, 4k picture, high quality"
negative_prompt = "extra digit, fewer digits, cropped, worst quality, low quality, glitch, deformed, mutated, ugly, disfigured"

generator = torch.manual_seed(0)
image = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    image=canny_image,
    num_inference_steps=4,
    guidance_scale=1.5,
    adapter_conditioning_scale=0.8,
    adapter_conditioning_factor=1,
    generator=generator,
).images[0]
```

    

### AnimateDiff

[AnimateDiff](./animatediff) es un adaptador que añade movimiento a una imagen. Puede usarse con la mayoría de los modelos de Stable Diffusion, convirtiéndolos efectivamente en modelos de “generación de video”. Generar buenos resultados con un modelo de video suele requerir generar múltiples fotogramas (16-24), lo cual puede ser muy lento con un modelo regular de Stable Diffusion. LCM-LoRA puede acelerar este proceso al requerir solo 4-8 pasos por cada fotograma.

Carga un [AnimateDiffPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/animatediff#diffusers.AnimateDiffPipeline) y pásale un `MotionAdapter`. Luego, reemplaza el scheduler con el [LCMScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/lcm#diffusers.LCMScheduler) y combina ambos adaptadores LoRA con el método `~loaders.UNet2DConditionLoadersMixin.set_adapters`. Ahora puedes pasar un prompt al pipeline y generar una imagen animada.

```py
import torch
from diffusers import MotionAdapter, AnimateDiffPipeline, DDIMScheduler, LCMScheduler
from diffusers.utils import export_to_gif

adapter = MotionAdapter.from_pretrained("guoyww/animatediff-motion-adapter-v1-5")
pipe = AnimateDiffPipeline.from_pretrained(
    "frankjoshua/toonyou_beta6",
    motion_adapter=adapter,
).to("cuda")  # or "mps", "xpu", "cpu"

# set scheduler
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)

# load LCM-LoRA
pipe.load_lora_weights("latent-consistency/lcm-lora-sdv1-5", adapter_name="lcm")
pipe.load_lora_weights("guoyww/animatediff-motion-lora-zoom-in", weight_name="diffusion_pytorch_model.safetensors", adapter_name="motion-lora")

pipe.set_adapters(["lcm", "motion-lora"], adapter_weights=[0.55, 1.2])

prompt = "best quality, masterpiece, 1girl, looking at viewer, blurry background, upper body, contemporary, dress"
generator = torch.manual_seed(0)
frames = pipe(
    prompt=prompt,
    num_inference_steps=5,
    guidance_scale=1.25,
    cross_attention_kwargs={"scale": 1},
    num_frames=24,
    generator=generator
).frames[0]
export_to_gif(frames, "animation.gif")
```

    

## LatentConsistencyModelPipeline[[diffusers.LatentConsistencyModelPipeline]]

#### diffusers.LatentConsistencyModelPipeline[[diffusers.LatentConsistencyModelPipeline]]

```python
diffusers.LatentConsistencyModelPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: LCMScheduler, safety_checker: StableDiffusionSafetyChecker, feature_extractor: CLIPImageProcessorPil, image_encoder: transformers.models.clip.modeling_clip.CLIPVisionModelWithProjection | None = None, requires_safety_checker: bool = True)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/latent_consistency_models/pipeline_latent_consistency_text2img.py#L133)

**Parámetros:**

vae ([AutoencoderKL](/docs/diffusers/v0.43.0/es/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.

text_encoder ([CLIPTextModel](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPTextModel)) : Codificador de texto congelado ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)).

tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPTokenizer)) : Un `CLIPTokenizer` para tokenizar texto.

unet ([UNet2DConditionModel](/docs/diffusers/v0.43.0/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Un `UNet2DConditionModel` para desruidar los latentes de imagen codificados.

scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/es/api/schedulers/overview#diffusers.SchedulerMixin)) : Un programador para usar en combinación con `unet` para desruidar los latentes de la imagen codificada. Actualmente solo admite [LCMScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/lcm#diffusers.LCMScheduler).

safety_checker (`StableDiffusionSafetyChecker`) : Módulo de clasificación que estima si las imágenes generadas podrían considerarse ofensivas o dañinas. Consulte la [ficha del modelo](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5) para obtener más detalles sobre los posibles daños de un modelo.

feature_extractor ([CLIPImageProcessor](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPImageProcessor)) : Un `CLIPImageProcessor` para extraer características de las imágenes generadas; se utiliza como entrada para el `safety_checker`.

requires_safety_checker (`bool`, *opcional*, valor predeterminado `True`) : Si el pipeline requiere un componente de verificación de seguridad.

Pipeline para la generación de imágenes a partir de texto utilizando un modelo de consistencia latente.

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.).

El pipeline también hereda los siguientes métodos de carga:
- [load_textual_inversion()](/docs/diffusers/v0.43.0/es/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) para cargar incrustaciones de inversión textual
- [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para cargar los pesos de LoRA
- [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para guardar los pesos de LoRA
- [from_single_file()](/docs/diffusers/v0.43.0/es/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file) para la carga de archivos `.ckpt`
- [load_ip_adapter()](/docs/diffusers/v0.43.0/es/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) para cargar IP Adapters

#### __call__[[diffusers.LatentConsistencyModelPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 4, original_inference_steps: int = None, timesteps: list[int] = None, guidance_scale: float = 8.5, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, output_type: str | None = 'pil', return_dict: bool = True, cross_attention_kwargs: dict[str, typing.Any] | None = None, clip_skip: int | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/latent_consistency_models/pipeline_latent_consistency_text2img.py#L640)

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de imágenes. Si no se define, debe pasar `prompt_embeds`.

height (`int`, *opcional*, valor predeterminado `self.unet.config.sample_size * self.vae_scale_factor`) : La altura en píxeles de la imagen generada.

width (`int`, *opcional*, valor predeterminado `self.unet.config.sample_size * self.vae_scale_factor`) : El ancho en píxeles de la imagen generada.

num_inference_steps (`int`, *opcional*, valor predeterminado 50) : El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta.

original_inference_steps (`int`, *opcional*) : El número original de pasos de inferencia utilizado para generar un calendario de pasos de tiempo espaciados linealmente, del cual extraeremos `num_inference_steps` pasos de tiempo equiespaciados como nuestro calendario final de pasos de tiempo, siguiendo el método Skipping-Step del artículo (ver la sección 4.3). Si no se establece, este valor será por defecto el atributo `original_inference_steps` del programador.

timesteps (`list[int]`, *opcional*) : Pasos de tiempo personalizados para usar en el proceso de desruido. Si no se definen, se utilizan `num_inference_steps` pasos de tiempo equiespaciados en la programación original de pasos de tiempo de entrenamiento/destilación de LCM. Deben estar en orden descendente.

guidance_scale (`float`, *opcional*, valor predeterminado 7.5) : Un valor más alto de la escala de guía anima al modelo a generar imágenes estrechamente vinculadas al `prompt` de texto a costa de una menor calidad de imagen. La escala de guía se habilita cuando `guidance_scale > 1`. Tenga en cuenta que el artículo original de los modelos de consistencia latente utiliza una formulación de CFG diferente en la que las escalas de guía se reducen en 1 (por lo que, en la formulación del artículo, CFG se habilita cuando `guidance_scale > 0`).

num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación.

generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista.

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporciona, se genera un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado.

prompt_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada `prompt`.

ip_adapter_image : (`PipelineImageInput`, *opcional*): Entrada de imagen opcional para trabajar con IP Adapters.

ip_adapter_image_embeds (`list[torch.Tensor]`, *opcional*) : Incrustaciones de imagen pregeneradas para IP-Adapter. Debe ser una lista de la misma longitud que el número de IP-adapters. Cada elemento debe ser un tensor de forma `(batch_size, num_images, emb_dim)`. Debe contener la incrustación de imagen negativa si `do_classifier_free_guidance` está establecido en `True`. Si no se proporciona, las incrustaciones se calculan a partir del argumento de entrada `ip_adapter_image`.

output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida de la imagen generada. Elija entre `PIL.Image` o `np.array`.

return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) en lugar de una tupla simple.

cross_attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define en [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

clip_skip (`int`, *opcional*) : Número de capas que se omitirán de CLIP al calcular los embeddings del prompt. Un valor de 1 significa que se utilizará la salida de la capa previa a la final para calcular los embeddings del prompt.

callback_on_step_end (`Callable`, *opcional*) : Una función que se llama al final de cada paso de desruido durante la inferencia. La función se llama con los siguientes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline.

**Devuelve:** [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) o `tuple`

Si `return_dict` es `True`, se devuelve [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput); en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con las imágenes generadas y cuyo segundo elemento es una lista de `bool` que indica si la imagen generada correspondiente contiene contenido "not-safe-for-work" (nsfw).

La función de llamada para el pipeline de generación.

Ejemplos:
```py
>>> from diffusers import DiffusionPipeline
>>> import torch

>>> pipe = DiffusionPipeline.from_pretrained("SimianLuo/LCM_Dreamshaper_v7")
>>> # To save GPU memory, torch.float16 can be used, but it may compromise image quality.
>>> pipe.to(torch_device="cuda", torch_dtype=torch.float32)

>>> prompt = "Self-portrait oil painting, a beautiful cyborg with golden hair, 8k"

>>> # Can be set to 1~50 steps. LCM support fast inference even <= 4 steps. Recommend: 1~8 steps.
>>> num_inference_steps = 4
>>> images = pipe(prompt=prompt, num_inference_steps=num_inference_steps, guidance_scale=8.0).images
>>> images[0].save("image.png")
```

#### enable_freeu[[diffusers.LatentConsistencyModelPipeline.enable_freeu]]

```python
enable_freeu(s1: float, s2: float, b1: float, b2: float)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2267)

**Parámetros:**

s1 (`float`) : Factor de escala para la etapa 1 para atenuar las contribuciones de las características de salto. Esto se hace para mitigar el "efecto de sobre-almohadillado" en el proceso de desruido mejorado.

s2 (`float`) : Factor de escala para la etapa 2 para atenuar las contribuciones de las características de salto. Esto se hace para mitigar el "efecto de sobre-almohadillado" en el proceso de desruido mejorado.

b1 (`float`) : Factor de escala para la etapa 1 para amplificar las contribuciones de las características del backbone.

b2 (`float`) : Factor de escala para la etapa 2 para amplificar las contribuciones de las características del backbone.

Activa el mecanismo FreeU tal como se describe en https://huggingface.co/papers/2309.11497.

Los sufijos después de los factores de escalado representan las etapas en las que se están aplicando.

Consulte el [repositorio oficial](https://github.com/ChenyangSi/FreeU) para conocer las combinaciones de valores que funcionan bien en diferentes pipelines, como Stable Diffusion v1, v2 y Stable Diffusion XL.

#### disable_freeu[[diffusers.LatentConsistencyModelPipeline.disable_freeu]]

```python
disable_freeu()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2289)

Desactiva el mecanismo FreeU si está habilitado.

#### encode_prompt[[diffusers.LatentConsistencyModelPipeline.encode_prompt]]

```python
encode_prompt(prompt, device, num_images_per_prompt, do_classifier_free_guidance, negative_prompt = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, lora_scale: float | None = None, clip_skip: int | None = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/latent_consistency_models/pipeline_latent_consistency_text2img.py#L226)

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : prompt a codificar

device : (`torch.device`): dispositivo de torch

num_images_per_prompt (`int`) : número de imágenes que deben generarse por prompt

do_classifier_free_guidance (`bool`) : si se debe usar o no la guía libre de clasificador

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`).

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`.

lora_scale (`float`, *opcional*) : Una escala LoRA que se aplicará a todas las capas LoRA del codificador de texto si se cargan capas LoRA.

clip_skip (`int`, *opcional*) : Número de capas que se omitirán de CLIP al calcular los embeddings del prompt. Un valor de 1 significa que se utilizará la salida de la capa previa a la final para calcular los embeddings del prompt.

Codifica el prompt en estados ocultos del codificador de texto.

#### get_guidance_scale_embedding[[diffusers.LatentConsistencyModelPipeline.get_guidance_scale_embedding]]

```python
get_guidance_scale_embedding(w: Tensor, embedding_dim: int = 512, dtype: dtype = torch.float32)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/latent_consistency_models/pipeline_latent_consistency_text2img.py#L517)

**Parámetros:**

w (`torch.Tensor`) : Genera vectores de incrustación con una escala de guía especificada para enriquecer posteriormente las incrustaciones de paso temporal.

embedding_dim (`int`, *opcional*, valor predeterminado 512) : Dimensión de las incrustaciones a generar.

dtype (`torch.dtype`, *opcional*, valor predeterminado `torch.float32`) : Tipo de datos de los embeddings generados.

**Devuelve:** `torch.Tensor`

Vectores de incrustación con forma `(len(w), embedding_dim)`.

Ver https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298

## LatentConsistencyModelImg2ImgPipeline[[diffusers.LatentConsistencyModelImg2ImgPipeline]]

#### diffusers.LatentConsistencyModelImg2ImgPipeline[[diffusers.LatentConsistencyModelImg2ImgPipeline]]

```python
diffusers.LatentConsistencyModelImg2ImgPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: LCMScheduler, safety_checker: StableDiffusionSafetyChecker, feature_extractor: CLIPImageProcessorPil, image_encoder: transformers.models.clip.modeling_clip.CLIPVisionModelWithProjection | None = None, requires_safety_checker: bool = True)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/latent_consistency_models/pipeline_latent_consistency_img2img.py#L154)

**Parámetros:**

vae ([AutoencoderKL](/docs/diffusers/v0.43.0/es/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.

text_encoder ([CLIPTextModel](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPTextModel)) : Codificador de texto congelado ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)).

tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPTokenizer)) : Un `CLIPTokenizer` para tokenizar texto.

unet ([UNet2DConditionModel](/docs/diffusers/v0.43.0/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Un `UNet2DConditionModel` para desruidar los latentes de imagen codificados.

scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/es/api/schedulers/overview#diffusers.SchedulerMixin)) : Un programador para usar en combinación con `unet` para desruidar los latentes de la imagen codificada. Actualmente solo admite [LCMScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/lcm#diffusers.LCMScheduler).

safety_checker (`StableDiffusionSafetyChecker`) : Módulo de clasificación que estima si las imágenes generadas podrían considerarse ofensivas o dañinas. Consulte la [ficha del modelo](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5) para obtener más detalles sobre los posibles daños de un modelo.

feature_extractor ([CLIPImageProcessor](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/clip#transformers.CLIPImageProcessor)) : Un `CLIPImageProcessor` para extraer características de las imágenes generadas; se utiliza como entrada para el `safety_checker`.

requires_safety_checker (`bool`, *opcional*, valor predeterminado `True`) : Si el pipeline requiere un componente de verificación de seguridad.

Pipeline para la generación de imagen a imagen utilizando un modelo de consistencia latente.

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.).

El pipeline también hereda los siguientes métodos de carga:
- [load_textual_inversion()](/docs/diffusers/v0.43.0/es/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) para cargar incrustaciones de inversión textual
- [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) para cargar los pesos de LoRA
- [save_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) para guardar los pesos de LoRA
- [from_single_file()](/docs/diffusers/v0.43.0/es/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file) para la carga de archivos `.ckpt`
- [load_ip_adapter()](/docs/diffusers/v0.43.0/es/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) para cargar IP Adapters

#### __call__[[diffusers.LatentConsistencyModelImg2ImgPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, num_inference_steps: int = 4, strength: float = 0.8, original_inference_steps: int = None, timesteps: list[int] = None, guidance_scale: float = 8.5, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, output_type: str | None = 'pil', return_dict: bool = True, cross_attention_kwargs: dict[str, typing.Any] | None = None, clip_skip: int | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/latent_consistency_models/pipeline_latent_consistency_img2img.py#L709)

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de imágenes. Si no se define, debe pasar `prompt_embeds`.

image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` o `list[np.ndarray]`) : `Image` o tensor que representa un lote de imágenes para usarse como punto de partida. También puede aceptar latentes de imagen como `image`, pero si se pasan latentes directamente, no se vuelven a codificar.

num_inference_steps (`int`, *opcional*, valor predeterminado 50) : El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta.

strength (`float`, *opcional*, valor predeterminado 0.8) : Indica el grado en que se transforma la `image` de referencia. Debe estar entre 0 y 1. `image` se utiliza como punto de partida y se añade más ruido a medida que aumenta el `strength`. El número de pasos de desruido depende de la cantidad de ruido añadido inicialmente. Cuando `strength` es 1, el ruido añadido es máximo y el proceso de desruido se ejecuta durante el número completo de iteraciones especificado en `num_inference_steps`. Un valor de 1 ignora esencialmente `image`.

original_inference_steps (`int`, *opcional*) : El número original de pasos de inferencia utilizado para generar un calendario de pasos de tiempo espaciados linealmente, del cual extraeremos `num_inference_steps` pasos de tiempo equiespaciados como nuestro calendario final de pasos de tiempo, siguiendo el método Skipping-Step del artículo (ver la sección 4.3). Si no se establece, este valor será por defecto el atributo `original_inference_steps` del programador.

timesteps (`list[int]`, *opcional*) : Pasos de tiempo personalizados para usar en el proceso de desruido. Si no se definen, se utilizan `num_inference_steps` pasos de tiempo equiespaciados en la programación original de pasos de tiempo de entrenamiento/destilación de LCM. Deben estar en orden descendente.

guidance_scale (`float`, *opcional*, valor predeterminado 7.5) : Un valor más alto de la escala de guía anima al modelo a generar imágenes estrechamente vinculadas al `prompt` de texto a costa de una menor calidad de imagen. La escala de guía se habilita cuando `guidance_scale > 1`. Tenga en cuenta que el artículo original de los modelos de consistencia latente utiliza una formulación de CFG diferente en la que las escalas de guía se reducen en 1 (por lo que, en la formulación del artículo, CFG se habilita cuando `guidance_scale > 0`).

num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación.

generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista.

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporciona, se genera un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado.

prompt_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada `prompt`.

ip_adapter_image : (`PipelineImageInput`, *opcional*): Entrada de imagen opcional para trabajar con IP Adapters.

ip_adapter_image_embeds (`list[torch.Tensor]`, *opcional*) : Incrustaciones de imagen pregeneradas para IP-Adapter. Debe ser una lista de la misma longitud que el número de IP-adapters. Cada elemento debe ser un tensor de forma `(batch_size, num_images, emb_dim)`. Debe contener la incrustación de imagen negativa si `do_classifier_free_guidance` está establecido en `True`. Si no se proporciona, las incrustaciones se calculan a partir del argumento de entrada `ip_adapter_image`.

output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida de la imagen generada. Elija entre `PIL.Image` o `np.array`.

return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) en lugar de una tupla simple.

cross_attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define en [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

clip_skip (`int`, *opcional*) : Número de capas que se omitirán de CLIP al calcular los embeddings del prompt. Un valor de 1 significa que se utilizará la salida de la capa previa a la final para calcular los embeddings del prompt.

callback_on_step_end (`Callable`, *opcional*) : Una función que se llama al final de cada paso de desruido durante la inferencia. La función se llama con los siguientes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline.

**Devuelve:** [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) o `tuple`

Si `return_dict` es `True`, se devuelve [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/es/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput); en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con las imágenes generadas y cuyo segundo elemento es una lista de `bool` que indica si la imagen generada correspondiente contiene contenido "not-safe-for-work" (nsfw).

La función de llamada para el pipeline de generación.

Ejemplos:
```py
>>> from diffusers import AutoPipelineForImage2Image
>>> import torch
>>> import PIL

>>> pipe = AutoPipelineForImage2Image.from_pretrained("SimianLuo/LCM_Dreamshaper_v7")
>>> # To save GPU memory, torch.float16 can be used, but it may compromise image quality.
>>> pipe.to(torch_device="cuda", torch_dtype=torch.float32)

>>> prompt = "High altitude snowy mountains"
>>> image = PIL.Image.open("./snowy_mountains.png")

>>> # Can be set to 1~50 steps. LCM support fast inference even <= 4 steps. Recommend: 1~8 steps.
>>> num_inference_steps = 4
>>> images = pipe(
...     prompt=prompt, image=image, num_inference_steps=num_inference_steps, guidance_scale=8.0
... ).images

>>> images[0].save("image.png")
```

#### enable_freeu[[diffusers.LatentConsistencyModelImg2ImgPipeline.enable_freeu]]

```python
enable_freeu(s1: float, s2: float, b1: float, b2: float)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2267)

**Parámetros:**

s1 (`float`) : Factor de escala para la etapa 1 para atenuar las contribuciones de las características de salto. Esto se hace para mitigar el "efecto de sobre-almohadillado" en el proceso de desruido mejorado.

s2 (`float`) : Factor de escala para la etapa 2 para atenuar las contribuciones de las características de salto. Esto se hace para mitigar el "efecto de sobre-almohadillado" en el proceso de desruido mejorado.

b1 (`float`) : Factor de escala para la etapa 1 para amplificar las contribuciones de las características del backbone.

b2 (`float`) : Factor de escala para la etapa 2 para amplificar las contribuciones de las características del backbone.

Activa el mecanismo FreeU tal como se describe en https://huggingface.co/papers/2309.11497.

Los sufijos después de los factores de escalado representan las etapas en las que se están aplicando.

Consulte el [repositorio oficial](https://github.com/ChenyangSi/FreeU) para conocer las combinaciones de valores que funcionan bien en diferentes pipelines, como Stable Diffusion v1, v2 y Stable Diffusion XL.

#### disable_freeu[[diffusers.LatentConsistencyModelImg2ImgPipeline.disable_freeu]]

```python
disable_freeu()
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2289)

Desactiva el mecanismo FreeU si está habilitado.

#### encode_prompt[[diffusers.LatentConsistencyModelImg2ImgPipeline.encode_prompt]]

```python
encode_prompt(prompt, device, num_images_per_prompt, do_classifier_free_guidance, negative_prompt = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, lora_scale: float | None = None, clip_skip: int | None = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/latent_consistency_models/pipeline_latent_consistency_img2img.py#L241)

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : prompt a codificar

device : (`torch.device`): dispositivo de torch

num_images_per_prompt (`int`) : número de imágenes que deben generarse por prompt

do_classifier_free_guidance (`bool`) : si se debe usar o no la guía libre de clasificador

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`).

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`.

lora_scale (`float`, *opcional*) : Una escala LoRA que se aplicará a todas las capas LoRA del codificador de texto si se cargan capas LoRA.

clip_skip (`int`, *opcional*) : Número de capas que se omitirán de CLIP al calcular los embeddings del prompt. Un valor de 1 significa que se utilizará la salida de la capa previa a la final para calcular los embeddings del prompt.

Codifica el prompt en estados ocultos del codificador de texto.

#### get_guidance_scale_embedding[[diffusers.LatentConsistencyModelImg2ImgPipeline.get_guidance_scale_embedding]]

```python
get_guidance_scale_embedding(w: Tensor, embedding_dim: int = 512, dtype: dtype = torch.float32)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/latent_consistency_models/pipeline_latent_consistency_img2img.py#L576)

**Parámetros:**

w (`torch.Tensor`) : Genera vectores de incrustación con una escala de guía especificada para enriquecer posteriormente las incrustaciones de paso temporal.

embedding_dim (`int`, *opcional*, valor predeterminado 512) : Dimensión de las incrustaciones a generar.

dtype (`torch.dtype`, *opcional*, valor predeterminado `torch.float32`) : Tipo de datos de los embeddings generados.

**Devuelve:** `torch.Tensor`

Vectores de incrustación con forma `(len(w), embedding_dim)`.

Ver https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298

## StableDiffusionPipelineOutput[[diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput]]

#### diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput[[diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput]]

```python
diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray, nsfw_content_detected: list[bool] | None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion/pipeline_output.py#L10)

**Parámetros:**

images (`list[PIL.Image.Image]` o `np.ndarray`) : lista de imágenes PIL desruidas de longitud `batch_size` o matriz NumPy de forma `(batch_size, height, width, num_channels)`.

nsfw_content_detected (`list[bool]`) : lista que indica si la imagen generada correspondiente contiene contenido "no apto para el trabajo" (nsfw) o `None` si no se pudo realizar la verificación de seguridad.

Clase de salida para las tuberías de Stable Diffusion.