# Latent Consistency Models

  

Les Latent Consistency Models (LCMs) ont été proposés dans [Latent Consistency Models: Synthesizing High-Resolution Images with Few-Step Inference](https://huggingface.co/papers/2310.04378) par Simian Luo, Yiqin Tan, Longbo Huang, Jian Li et Hang Zhao.

L’abstract de l’article est le suivant :

*Les modèles de diffusion latente (LDM) ont obtenu des résultats remarquables dans la synthèse d'images haute résolution. Cependant, le processus d'échantillonnage itératif est intensif en calculs et entraîne une génération lente. Inspirés par les Consistency Models (song et al.), nous proposons les Latent Consistency Models (LCM), permettant une inférence rapide en un minimum d'étapes sur n'importe quel LDM pré-entraîné, y compris Stable Diffusion (rombach et al). En considérant le processus de diffusion inverse guidé comme la résolution d'une ODE de flux de probabilité augmentée (PF-ODE), les LCM sont conçus pour prédire directement la solution de cette ODE dans l'espace latent, réduisant ainsi le besoin de nombreuses itérations et permettant un échantillonnage rapide et haute fidélité. Distillés efficacement à partir de modèles de diffusion guidés par classifier-free pré-entraînés, un LCM de haute qualité 768 x 768 en 2~4 étapes ne nécessite que 32 heures de GPU A100 pour l'entraînement. De plus, nous introduisons le Latent Consistency Fine-tuning (LCF), une méthode novatrice conçue pour l'ajustement fin des LCM sur des jeux de données d'images personnalisés. L'évaluation sur le jeu de données LAION-5B-Aesthetics démontre que les LCM atteignent des performances de pointe en génération d'images à partir de texte avec une inférence en peu d'étapes. Page du projet : [this https URL](https://latent-consistency-models.github.io/).*

Une démonstration du point de contrôle [SimianLuo/LCM_Dreamshaper_v7](https://huggingface.co/SimianLuo/LCM_Dreamshaper_v7) est disponible [ici](https://huggingface.co/spaces/SimianLuo/Latent_Consistency_Model).

Les pipelines ont été contribué par [luosiallen](https://luosiallen.github.io/), [nagolinc](https://github.com/nagolinc) et [dg845](https://github.com/dg845).

> [!TIP]
> Les LCM et les LCM-LoRA sont disponibles pour Stable Diffusion v1.5, Stable Diffusion XL et le modèle SSD-1B. Vous pouvez trouver leurs points de contrôle sur les collections [Latent Consistency](https://hf.co/collections/latent-consistency/latent-consistency-models-weights-654ce61a95edd6dffccef6a8).

## Texte vers image

Pour utiliser les LCM, vous devez charger le checkpoint LCM de votre modèle pris en charge dans [UNet2DConditionModel](/docs/diffusers/main/fr/api/models/unet2d-cond#diffusers.UNet2DConditionModel) et remplacer le planificateur par le [LCMScheduler](/docs/diffusers/main/fr/api/schedulers/lcm#diffusers.LCMScheduler). Vous pouvez ensuite utiliser le pipeline comme d'habitude et passer un prompt texte pour générer une image en seulement 4 étapes.

Quelques points à garder en tête lors de l'utilisation des LCM :

* En général, la taille du lot est doublée dans le pipeline pour le guidage sans classifieur. Cependant, LCM applique le guidage à l'aide d'embeddings de guidage et n'a pas besoin de doubler la taille du lot, ce qui entraîne une inférence plus rapide. L'inconvénient est que les prompts négatifs ne fonctionnent pas avec LCM, car ils n'ont aucun effet sur le processus de débruitage.
* La plage idéale pour `guidance_scale` est [3., 13.] car c'est la plage utilisée pour l'entraînement du UNet. Toutefois, désactiver `guidance_scale` avec une valeur de 1.0 est également efficace dans la plupart des cas.

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

    

Pour utiliser les LCM-LoRAs, vous devez remplacer le planificateur par le [LCMScheduler](/docs/diffusers/main/fr/api/schedulers/lcm#diffusers.LCMScheduler) et charger les poids LCM-LoRA avec la méthode [load_lora_weights()](/docs/diffusers/main/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights). Vous pouvez ensuite utiliser le pipeline comme d'habitude et passer un prompt texte pour générer une image en seulement 4 étapes.

Quelques points à garder en tête lors de l'utilisation des LCM-LoRAs :

* En général, la taille du lot est doublée dans le pipeline pour le guidage sans classifieur. Cependant, LCM applique le guidage à l'aide d'embeddings de guidage et n'a pas besoin de doubler la taille du lot, ce qui entraîne une inférence plus rapide. L'inconvénient est que les prompts négatifs ne fonctionnent pas avec LCM, car ils n'ont aucun effet sur le processus de débruitage.
* Vous pouvez utiliser le guidance avec les LCM-LoRAs, mais il est très sensible aux valeurs élevées de `guidance_scale` et peut entraîner des artefacts dans l'image générée. Les meilleures valeurs que nous avons trouvées se situent entre [1.0, 2.0].
* Remplacez [stabilityai/stable-diffusion-xl-base-1.0](https://hf.co/stabilityai/stable-diffusion-xl-base-1.0) par n’importe quel modèle affiné. Par exemple, essayez d’utiliser le point de contrôle [animagine-xl](https://huggingface.co/Linaqruf/animagine-xl) pour générer des images d’anime avec 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
```

    

## Image vers image

Pour utiliser les LCM pour l'image-à-image, vous devez charger le point de contrôle LCM de votre modèle pris en charge dans [UNet2DConditionModel](/docs/diffusers/main/fr/api/models/unet2d-cond#diffusers.UNet2DConditionModel) et remplacer le planificateur par le [LCMScheduler](/docs/diffusers/main/fr/api/schedulers/lcm#diffusers.LCMScheduler). Vous pouvez ensuite utiliser le pipeline comme d'habitude, en passant un prompt texte et une image initiale pour générer une image en seulement 4 étapes.

> [!TIP]
> Expérimentez avec différentes valeurs pour `num_inference_steps`, `strength` et `guidance_scale` afin d'obtenir les meilleurs résultats.

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

  
    
    image initiale
  
  
    
    image générée
  

Pour utiliser les LCM-LoRAs pour l'image-à-image, vous devez remplacer le planificateur par le [LCMScheduler](/docs/diffusers/main/fr/api/schedulers/lcm#diffusers.LCMScheduler) et charger les poids du LCM-LoRA avec la méthode [load_lora_weights()](/docs/diffusers/main/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights). Vous pouvez ensuite utiliser le pipeline comme d'habitude, en passant un prompt texte et une image initiale pour générer une image en seulement 4 étapes.

> [!TIP]
> Expérimentez avec différentes valeurs pour `num_inference_steps`, `strength` et `guidance_scale` afin d'obtenir les meilleurs résultats.

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

  
    
    image initiale
  
  
    
    image générée
  

## Inpainting

Pour utiliser les LCM-LoRAs pour l'inpainting, vous devez remplacer le planificateur par le [LCMScheduler](/docs/diffusers/main/fr/api/schedulers/lcm#diffusers.LCMScheduler) et charger les poids du LCM-LoRA avec la méthode [load_lora_weights()](/docs/diffusers/main/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights). Vous pouvez ensuite utiliser le pipeline comme d'habitude, en passant un prompt texte, une image initiale et une image de masque pour générer une image en seulement 4 étapes.

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

  
    
    image initiale
  
  
    
    image générée
  

## Adaptateurs

Les LCM sont compatibles avec des adaptateurs tels que LoRA, ControlNet, T2I-Adapter et AnimateDiff. Vous pouvez apporter la rapidité des LCM à ces adaptateurs pour générer des images dans un style particulier ou conditionner le modèle sur une autre entrée, comme une image canny.

### LoRA

Les adaptateurs [LoRA](../../tutorials/using_peft_for_inference) peuvent être affinés rapidement pour apprendre un nouveau style à partir de quelques images seulement, puis intégrés à un modèle pré-entraîné afin de générer des images dans ce style.

Chargez le checkpoint LCM de votre modèle pris en charge dans [UNet2DConditionModel](/docs/diffusers/main/fr/api/models/unet2d-cond#diffusers.UNet2DConditionModel) et remplacez le scheduler par le [LCMScheduler](/docs/diffusers/main/fr/api/schedulers/lcm#diffusers.LCMScheduler). Vous pouvez ensuite utiliser la méthode [load_lora_weights()](/docs/diffusers/main/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour charger les poids LoRA dans le LCM et générer une image stylisée en quelques étapes.

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

    

Remplacez le planificateur par le [LCMScheduler](/docs/diffusers/main/fr/api/schedulers/lcm#diffusers.LCMScheduler). Vous pouvez ensuite utiliser la méthode [load_lora_weights()](/docs/diffusers/main/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour charger les poids LCM-LoRA et le LoRA de style que vous souhaitez utiliser. Combinez les deux adaptateurs LoRA avec la méthode `~loaders.UNet2DConditionLoadersMixin.set_adapters` et générez une image stylisée en quelques étapes.

```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) sont des adaptateurs qui peuvent être entraînés sur une variété d’entrées telles que les contours canny, l’estimation de pose ou la profondeur. Le ControlNet peut être inséré dans le pipeline pour fournir un conditionnement et un contrôle supplémentaires au modèle, afin d’obtenir une génération plus précise.

Vous pouvez trouver d'autres modèles ControlNet entraînés sur d'autres entrées dans le dépôt de [lllyasviel](https://hf.co/lllyasviel).

Chargez un modèle ControlNet entraîné sur des images canny et transmettez-le à [ControlNetModel](/docs/diffusers/main/fr/api/models/controlnet#diffusers.ControlNetModel). Vous pouvez ensuite charger un modèle LCM dans [StableDiffusionControlNetPipeline](/docs/diffusers/main/fr/api/pipelines/controlnet#diffusers.StableDiffusionControlNetPipeline) et remplacer le planificateur par [LCMScheduler](/docs/diffusers/main/fr/api/schedulers/lcm#diffusers.LCMScheduler). Transmettez maintenant l'image canny au pipeline et générez une image.

> [!TIP]
> Expérimentez avec différentes valeurs pour `num_inference_steps`, `controlnet_conditioning_scale`, `cross_attention_kwargs` et `guidance_scale` afin d’obtenir les meilleurs résultats.

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

    

Chargez un modèle ControlNet entraîné sur des images canny et transmettez-le à [ControlNetModel](/docs/diffusers/main/fr/api/models/controlnet#diffusers.ControlNetModel). Vous pouvez ensuite charger un modèle Stable Diffusion v1.5 dans [StableDiffusionControlNetPipeline](/docs/diffusers/main/fr/api/pipelines/controlnet#diffusers.StableDiffusionControlNetPipeline) et remplacer le planificateur par [LCMScheduler](/docs/diffusers/main/fr/api/schedulers/lcm#diffusers.LCMScheduler). Utilisez la méthode [load_lora_weights()](/docs/diffusers/main/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour charger les poids LCM-LoRA, puis transmettez l’image canny au pipeline et générez une image.

> [!TIP]
> Expérimentez avec différentes valeurs pour `num_inference_steps`, `controlnet_conditioning_scale`, `cross_attention_kwargs` et `guidance_scale` afin d’obtenir les meilleurs résultats.

```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) est un adaptateur encore plus léger que ControlNet, qui fournit une entrée supplémentaire pour conditionner un modèle pré-entraîné. Il est plus rapide que ControlNet, mais les résultats peuvent être légèrement moins bons.

Vous pouvez trouver d'autres points de contrôle T2I-Adapter entraînés sur d'autres entrées dans le dépôt de [TencentArc](https://hf.co/TencentARC).

Chargez un T2IAdapter entraîné sur des images canny et transmettez-le au [StableDiffusionXLAdapterPipeline](/docs/diffusers/main/fr/api/pipelines/stable_diffusion/adapter#diffusers.StableDiffusionXLAdapterPipeline). Chargez ensuite un point de contrôle LCM dans [UNet2DConditionModel](/docs/diffusers/main/fr/api/models/unet2d-cond#diffusers.UNet2DConditionModel) et remplacez le planificateur par le [LCMScheduler](/docs/diffusers/main/fr/api/schedulers/lcm#diffusers.LCMScheduler). Transmettez maintenant l'image canny au pipeline et générez une image.

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

    

Chargez un T2IAdapter entraîné sur des images canny et transmettez-le au [StableDiffusionXLAdapterPipeline](/docs/diffusers/main/fr/api/pipelines/stable_diffusion/adapter#diffusers.StableDiffusionXLAdapterPipeline). Remplacez le planificateur par le [LCMScheduler](/docs/diffusers/main/fr/api/schedulers/lcm#diffusers.LCMScheduler) et utilisez la méthode [load_lora_weights()](/docs/diffusers/main/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour charger les poids LCM-LoRA. Transmettez l’image canny au pipeline et générez une image.

```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) est un adaptateur qui ajoute du mouvement à une image. Il peut être utilisé avec la plupart des modèles Stable Diffusion, les transformant ainsi en modèles de « génération de vidéo ». La génération de bons résultats avec un modèle vidéo nécessite généralement de générer plusieurs images (16-24), ce qui peut être très lent avec un modèle Stable Diffusion classique. LCM-LoRA peut accélérer ce processus en ne nécessitant que 4 à 8 étapes pour chaque image.

Chargez un [AnimateDiffPipeline](/docs/diffusers/main/fr/api/pipelines/animatediff#diffusers.AnimateDiffPipeline) et passez-lui un `MotionAdapter`. Remplacez ensuite le planificateur par le [LCMScheduler](/docs/diffusers/main/fr/api/schedulers/lcm#diffusers.LCMScheduler), puis combinez les deux adaptateurs LoRA à l'aide de la méthode `~loaders.UNet2DConditionLoadersMixin.set_adapters`. Vous pouvez maintenant passer un prompt au pipeline et générer une image animée.

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

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

**Paramètres :**

vae ([AutoencoderKL](/docs/diffusers/main/fr/api/models/autoencoderkl#diffusers.AutoencoderKL)) : modèle Variational Auto-Encoder (VAE) permettant d’encoder et de décoder des images vers et depuis des représentations latentes.

text_encoder ([CLIPTextModel](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTextModel)) : encodeur de texte figé ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)).

tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTokenizer)) : Un `CLIPTokenizer` pour tokeniser le texte.

unet ([UNet2DConditionModel](/docs/diffusers/main/fr/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : un `UNet2DConditionModel` pour débruyer les latents d'image encodés.

scheduler ([SchedulerMixin](/docs/diffusers/main/fr/api/schedulers/overview#diffusers.SchedulerMixin)) : Un planificateur à utiliser en combinaison avec `unet` pour débruyer les latents de l'image encodée. Actuellement, seul [LCMScheduler](/docs/diffusers/main/fr/api/schedulers/lcm#diffusers.LCMScheduler) est pris en charge.

safety_checker (`StableDiffusionSafetyChecker`) : module de classification qui estime si les images générées pourraient être considérées comme offensives ou nuisibles. Veuillez consulter la [fiche modèle](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5) pour plus de détails sur les préjudices potentiels d'un modèle.

feature_extractor ([CLIPImageProcessor](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPImageProcessor)) : un `CLIPImageProcessor` pour extraire des caractéristiques des images générées ; utilisé comme entrées pour le `safety_checker`.

requires_safety_checker (`bool`, *facultatif*, par défaut `True`) : Indique si le pipeline nécessite un composant de vérification de sécurité.

Pipeline pour la génération d'images à partir de texte utilisant un modèle de cohérence latente.

Ce modèle hérite de [DiffusionPipeline](/docs/diffusers/main/fr/api/pipelines/overview#diffusers.DiffusionPipeline). Consultez la documentation de la classe parente pour les méthodes génériques implémentées pour tous les pipelines (téléchargement, sauvegarde, exécution sur un appareil particulier, etc.).

Le pipeline hérite également des méthodes de chargement suivantes :
- [load_textual_inversion()](/docs/diffusers/main/fr/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) pour charger les embeddings d'inversion textuelle
- [load_lora_weights()](/docs/diffusers/main/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour charger les poids LoRA
- [save_lora_weights()](/docs/diffusers/main/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour enregistrer les poids LoRA
- [from_single_file()](/docs/diffusers/main/fr/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file) pour charger des fichiers `.ckpt`
- [load_ip_adapter()](/docs/diffusers/main/fr/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) pour charger des IP Adapters

#### __appel__[[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)
```

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

**Paramètres :**

prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts pour guider la génération d’images. S’il n’est pas défini, vous devez passer `prompt_embeds`.

height (`int`, *facultatif*, par défaut `self.unet.config.sample_size * self.vae_scale_factor`) : La hauteur en pixels de l'image générée.

width (`int`, *facultatif*, par défaut `self.unet.config.sample_size * self.vae_scale_factor`) : La largeur en pixels de l'image générée.

num_inference_steps (`int`, *facultatif*, valeur par défaut 50) : Le nombre d'étapes de débruitage. Un plus grand nombre d'étapes de débruitage conduit généralement à une image de meilleure qualité, au prix d'une inférence plus lente.

original_inference_steps (`int`, *facultatif*) : Le nombre original d'étapes d'inférence utilisé pour générer un calendrier de timesteps linéairement espacés, à partir duquel nous extrairons `num_inference_steps` timesteps uniformément espacés comme calendrier final, conformément à la méthode Skipping-Step du papier (voir la section 4.3). S'il n'est pas défini, la valeur par défaut sera l'attribut `original_inference_steps` du planificateur.

timesteps (`list[int]`, *facultatif*) : Timesteps personnalisés à utiliser pour le processus de débruitage. S'ils ne sont pas définis, des timesteps `num_inference_steps` équidistants sur l'agenda de timesteps d'entraînement/distillation LCM d'origine sont utilisés. Ils doivent être dans l'ordre décroissant.

guidance_scale (`float`, *facultatif*, valeur par défaut 7,5) : Une valeur plus élevée de l'échelle de guidage encourage le modèle à générer des images étroitement liées au `prompt` texte, au détriment de la qualité de l'image. L'échelle de guidage est activée lorsque `guidance_scale > 1`. Notez que l'article original sur les modèles de cohérence latente utilise une formulation CFG différente où les échelles de guidage sont diminuées de 1 (ainsi, dans la formulation de l'article, le CFG est activé lorsque `guidance_scale > 0`).

num_images_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre d'images à générer par invite.

generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) pour rendre la génération déterministe.

latents (`torch.Tensor`, *facultatif*) : Latents bruités pré-générés, échantillonnés à partir d'une distribution gaussienne, à utiliser comme entrées pour la génération d'images. Peut être utilisé pour ajuster la même génération avec des prompts différents. S'il n'est pas fourni, un tenseur de latents est généré par échantillonnage à l'aide du `generator` aléatoire fourni.

prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). Si non fourni, les incrustations de texte sont générées à partir de l'argument d'entrée `prompt`.

ip_adapter_image : (`PipelineImageInput`, *facultatif*) : Entrée d'image facultative pour travailler avec les IP Adapters.

ip_adapter_image_embeds (`list[torch.Tensor]`, *facultatif*) : Incrustations d’images pré-générées pour IP-Adapter. Il doit s’agir d’une liste dont la longueur est égale au nombre d’IP-adapters. Chaque élément doit être un tenseur de forme `(batch_size, num_images, emb_dim)`. Il doit contenir l’incrustation d’image négative si `do_classifier_free_guidance` est défini sur `True`. S’il n’est pas fourni, les incrustations sont calculées à partir de l’argument d’entrée `ip_adapter_image`.

output_type (`str`, *facultatif*, par défaut `"pil"`) : Le format de sortie de l'image générée. Choisissez entre `PIL.Image` ou `np.array`.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un [StableDiffusionPipelineOutput](/docs/diffusers/main/fr/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) plutôt qu'un simple tuple.

cross_attention_kwargs (`dict`, *facultatif*) : Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'`AttentionProcessor` tel que défini dans [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

clip_skip (`int`, *facultatif*) : Nombre de couches à ignorer dans CLIP lors du calcul des embeddings de prompt. Une valeur de 1 signifie que la sortie de la couche pré-finale sera utilisée pour calculer les embeddings de prompt.

callback_on_step_end (`Callable`, *facultatif*) : une fonction appelée à la fin de chaque étape de débruitage pendant l’inférence. La fonction est appelée avec les arguments suivants : `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` contiendra une liste de tous les tenseurs, tels que spécifiés par `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *facultatif*) : La liste des entrées tensorielles pour la fonction `callback_on_step_end`. Les tenseurs spécifiés dans la liste seront passés en tant qu'argument `callback_kwargs`. Vous ne pourrez inclure que les variables listées dans l'attribut `._callback_tensor_inputs` de votre classe de pipeline.

**Retourne :** [StableDiffusionPipelineOutput](/docs/diffusers/main/fr/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) ou `tuple`

Si `return_dict` est `True`, [StableDiffusionPipelineOutput](/docs/diffusers/main/fr/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) est renvoyé, sinon un `tuple` est renvoyé dont le premier élément est une liste des images générées et le deuxième élément est une liste de `bool` indiquant si l'image générée correspondante contient du contenu « not-safe-for-work » (nsfw).

La fonction d'appel du pipeline pour la génération.

Exemples :
```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)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2267)

**Paramètres :**

s1 (`float`) : Facteur d'échelle pour l'étape 1 afin d'atténuer les contributions des caractéristiques de saut. Cela permet d'atténuer l'« effet de lissage excessif » dans le processus de débruitage amélioré.

s2 (`float`) : Facteur d'échelle pour l'étape 2 afin d'atténuer les contributions des caractéristiques de saut. Cela permet de réduire l'« effet de lissage excessif » dans le processus de débruitage amélioré.

b1 (`float`) : Facteur d'échelle pour l'étape 1 afin d'amplifier les contributions des fonctionnalités du backbone.

b2 (`float`) : Facteur d'échelle pour l'étape 2 afin d'amplifier les contributions des fonctionnalités du backbone.

Active le mécanisme FreeU tel que décrit dans https://huggingface.co/papers/2309.11497.

Les suffixes qui suivent les facteurs d'échelle représentent les étapes où ils sont appliqués.

Veuillez consulter le [dépôt officiel](https://github.com/ChenyangSi/FreeU) pour les combinaisons de valeurs connues pour fonctionner correctement avec différents pipelines tels que Stable Diffusion v1, v2 et Stable Diffusion XL.

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

```python
disable_freeu()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2289)

Désactive le mécanisme FreeU s'il est activé.

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

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

**Paramètres :**

prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder

device : (`torch.device`) : appareil torch

num_images_per_prompt (`int`) : nombre d'images à générer par invite

do_classifier_free_guidance (`bool`) : indique s'il faut utiliser le guidage sans classifieur ou non

negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passer `negative_prompt_embeds` à la place. Ignoré lorsque le guidage n’est pas utilisé (c’est-à-dire ignoré si `guidance_scale` est inférieur à `1`).

prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* pondération des prompts. Si non fourni, les incrustations de texte seront générées à partir de l'argument d'entrée `prompt`.

negative_prompt_embeds (`torch.Tensor`, *facultatif*) : Embeddings de texte négatif pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, *par exemple* le pondération des prompts. S'il n'est pas fourni, negative_prompt_embeds sera généré à partir de l'argument d'entrée `negative_prompt`.

lora_scale (`float`, *facultatif*) : une échelle LoRA qui sera appliquée à toutes les couches LoRA de l'encodeur de texte si des couches LoRA sont chargées.

clip_skip (`int`, *facultatif*) : Nombre de couches à ignorer dans CLIP lors du calcul des embeddings de prompt. Une valeur de 1 signifie que la sortie de la couche pré-finale sera utilisée pour calculer les embeddings de prompt.

Encode le prompt dans les états cachés de l'encodeur de texte.

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

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

**Paramètres :**

w (`torch.Tensor`) : Génère des vecteurs d'incorporation avec une échelle de guidage spécifiée afin d'enrichir par la suite les incorporations de pas de temps.

embedding_dim (`int`, *facultatif*, par défaut 512) : Dimension des embeddings à générer.

dtype (`torch.dtype`, *facultatif*, par défaut `torch.float32`) : Type de données des embeddings générés.

**Retourne :** `torch.Tensor`

Vecteurs d'embedding de forme `(len(w), embedding_dim)`.

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

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

**Paramètres :**

vae ([AutoencoderKL](/docs/diffusers/main/fr/api/models/autoencoderkl#diffusers.AutoencoderKL)) : modèle Variational Auto-Encoder (VAE) permettant d’encoder et de décoder des images vers et depuis des représentations latentes.

text_encoder ([CLIPTextModel](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTextModel)) : encodeur de texte figé ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)).

tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTokenizer)) : Un `CLIPTokenizer` pour tokeniser le texte.

unet ([UNet2DConditionModel](/docs/diffusers/main/fr/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : un `UNet2DConditionModel` pour débruyer les latents d'image encodés.

scheduler ([SchedulerMixin](/docs/diffusers/main/fr/api/schedulers/overview#diffusers.SchedulerMixin)) : Un planificateur à utiliser en combinaison avec `unet` pour débruyer les latents de l'image encodée. Actuellement, seul [LCMScheduler](/docs/diffusers/main/fr/api/schedulers/lcm#diffusers.LCMScheduler) est pris en charge.

safety_checker (`StableDiffusionSafetyChecker`) : module de classification qui estime si les images générées pourraient être considérées comme offensives ou nuisibles. Veuillez consulter la [fiche modèle](https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5) pour plus de détails sur les préjudices potentiels d'un modèle.

feature_extractor ([CLIPImageProcessor](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPImageProcessor)) : un `CLIPImageProcessor` pour extraire des caractéristiques des images générées ; utilisé comme entrées pour le `safety_checker`.

requires_safety_checker (`bool`, *facultatif*, par défaut `True`) : Indique si le pipeline nécessite un composant de vérification de sécurité.

Pipeline pour la génération d'image à partir d'image à l'aide d'un modèle de cohérence latente.

Ce modèle hérite de [DiffusionPipeline](/docs/diffusers/main/fr/api/pipelines/overview#diffusers.DiffusionPipeline). Consultez la documentation de la classe parente pour les méthodes génériques implémentées pour tous les pipelines (téléchargement, sauvegarde, exécution sur un appareil particulier, etc.).

Le pipeline hérite également des méthodes de chargement suivantes :
- [load_textual_inversion()](/docs/diffusers/main/fr/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) pour charger les embeddings d'inversion textuelle
- [load_lora_weights()](/docs/diffusers/main/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour charger les poids LoRA
- [save_lora_weights()](/docs/diffusers/main/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour enregistrer les poids LoRA
- [from_single_file()](/docs/diffusers/main/fr/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file) pour charger des fichiers `.ckpt`
- [load_ip_adapter()](/docs/diffusers/main/fr/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) pour charger des IP Adapters

#### __appel__[[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)
```

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

**Paramètres :**

prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts pour guider la génération d’images. S’il n’est pas défini, vous devez passer `prompt_embeds`.

image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` ou `list[np.ndarray]`) : `Image` ou tenseur représentant un lot d'images à utiliser comme point de départ. Peut également accepter des latents d'image en tant que `image`, mais si des latents sont transmis directement, ils ne sont pas réencodés.

num_inference_steps (`int`, *facultatif*, valeur par défaut 50) : Le nombre d'étapes de débruitage. Un plus grand nombre d'étapes de débruitage conduit généralement à une image de meilleure qualité, au prix d'une inférence plus lente.

strength (`float`, *facultatif*, valeur par défaut 0.8) : Indique dans quelle mesure transformer l'`image` de référence. Doit être compris entre 0 et 1. `image` est utilisé comme point de départ et plus le `strength` est élevé, plus du bruit est ajouté. Le nombre d'étapes de débruitage dépend de la quantité de bruit initialement ajoutée. Lorsque `strength` vaut 1, le bruit ajouté est maximal et le processus de débruitage s'exécute pendant le nombre complet d'itérations spécifié dans `num_inference_steps`. Une valeur de 1 ignore essentiellement `image`.

original_inference_steps (`int`, *facultatif*) : Le nombre original d'étapes d'inférence utilisé pour générer un calendrier de timesteps linéairement espacés, à partir duquel nous extrairons `num_inference_steps` timesteps uniformément espacés comme calendrier final, conformément à la méthode Skipping-Step du papier (voir la section 4.3). S'il n'est pas défini, la valeur par défaut sera l'attribut `original_inference_steps` du planificateur.

timesteps (`list[int]`, *facultatif*) : Timesteps personnalisés à utiliser pour le processus de débruitage. S'ils ne sont pas définis, des timesteps `num_inference_steps` équidistants sur l'agenda de timesteps d'entraînement/distillation LCM d'origine sont utilisés. Ils doivent être dans l'ordre décroissant.

guidance_scale (`float`, *facultatif*, valeur par défaut 7,5) : Une valeur plus élevée de l'échelle de guidage encourage le modèle à générer des images étroitement liées au `prompt` texte, au détriment de la qualité de l'image. L'échelle de guidage est activée lorsque `guidance_scale > 1`. Notez que l'article original sur les modèles de cohérence latente utilise une formulation CFG différente où les échelles de guidage sont diminuées de 1 (ainsi, dans la formulation de l'article, le CFG est activé lorsque `guidance_scale > 0`).

num_images_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre d'images à générer par invite.

generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) pour rendre la génération déterministe.

latents (`torch.Tensor`, *facultatif*) : Latents bruités pré-générés, échantillonnés à partir d'une distribution gaussienne, à utiliser comme entrées pour la génération d'images. Peut être utilisé pour ajuster la même génération avec des prompts différents. S'il n'est pas fourni, un tenseur de latents est généré par échantillonnage à l'aide du `generator` aléatoire fourni.

prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). Si non fourni, les incrustations de texte sont générées à partir de l'argument d'entrée `prompt`.

ip_adapter_image : (`PipelineImageInput`, *facultatif*) : Entrée d'image facultative pour travailler avec les IP Adapters.

ip_adapter_image_embeds (`list[torch.Tensor]`, *facultatif*) : Incrustations d’images pré-générées pour IP-Adapter. Il doit s’agir d’une liste dont la longueur est égale au nombre d’IP-adapters. Chaque élément doit être un tenseur de forme `(batch_size, num_images, emb_dim)`. Il doit contenir l’incrustation d’image négative si `do_classifier_free_guidance` est défini sur `True`. S’il n’est pas fourni, les incrustations sont calculées à partir de l’argument d’entrée `ip_adapter_image`.

output_type (`str`, *facultatif*, par défaut `"pil"`) : Le format de sortie de l'image générée. Choisissez entre `PIL.Image` ou `np.array`.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un [StableDiffusionPipelineOutput](/docs/diffusers/main/fr/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) plutôt qu'un simple tuple.

cross_attention_kwargs (`dict`, *facultatif*) : Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'`AttentionProcessor` tel que défini dans [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

clip_skip (`int`, *facultatif*) : Nombre de couches à ignorer dans CLIP lors du calcul des embeddings de prompt. Une valeur de 1 signifie que la sortie de la couche pré-finale sera utilisée pour calculer les embeddings de prompt.

callback_on_step_end (`Callable`, *facultatif*) : une fonction appelée à la fin de chaque étape de débruitage pendant l’inférence. La fonction est appelée avec les arguments suivants : `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` contiendra une liste de tous les tenseurs, tels que spécifiés par `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *facultatif*) : La liste des entrées tensorielles pour la fonction `callback_on_step_end`. Les tenseurs spécifiés dans la liste seront passés en tant qu'argument `callback_kwargs`. Vous ne pourrez inclure que les variables listées dans l'attribut `._callback_tensor_inputs` de votre classe de pipeline.

**Retourne :** [StableDiffusionPipelineOutput](/docs/diffusers/main/fr/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) ou `tuple`

Si `return_dict` est `True`, [StableDiffusionPipelineOutput](/docs/diffusers/main/fr/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) est renvoyé, sinon un `tuple` est renvoyé dont le premier élément est une liste des images générées et le deuxième élément est une liste de `bool` indiquant si l'image générée correspondante contient du contenu « not-safe-for-work » (nsfw).

La fonction d'appel du pipeline pour la génération.

Exemples :
```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)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2267)

**Paramètres :**

s1 (`float`) : Facteur d'échelle pour l'étape 1 afin d'atténuer les contributions des caractéristiques de saut. Cela permet d'atténuer l'« effet de lissage excessif » dans le processus de débruitage amélioré.

s2 (`float`) : Facteur d'échelle pour l'étape 2 afin d'atténuer les contributions des caractéristiques de saut. Cela permet de réduire l'« effet de lissage excessif » dans le processus de débruitage amélioré.

b1 (`float`) : Facteur d'échelle pour l'étape 1 afin d'amplifier les contributions des fonctionnalités du backbone.

b2 (`float`) : Facteur d'échelle pour l'étape 2 afin d'amplifier les contributions des fonctionnalités du backbone.

Active le mécanisme FreeU tel que décrit dans https://huggingface.co/papers/2309.11497.

Les suffixes qui suivent les facteurs d'échelle représentent les étapes où ils sont appliqués.

Veuillez consulter le [dépôt officiel](https://github.com/ChenyangSi/FreeU) pour les combinaisons de valeurs connues pour fonctionner correctement avec différents pipelines tels que Stable Diffusion v1, v2 et Stable Diffusion XL.

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

```python
disable_freeu()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2289)

Désactive le mécanisme FreeU s'il est activé.

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

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

**Paramètres :**

prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder

device : (`torch.device`) : appareil torch

num_images_per_prompt (`int`) : nombre d'images à générer par invite

do_classifier_free_guidance (`bool`) : indique s'il faut utiliser le guidage sans classifieur ou non

negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passer `negative_prompt_embeds` à la place. Ignoré lorsque le guidage n’est pas utilisé (c’est-à-dire ignoré si `guidance_scale` est inférieur à `1`).

prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* pondération des prompts. Si non fourni, les incrustations de texte seront générées à partir de l'argument d'entrée `prompt`.

negative_prompt_embeds (`torch.Tensor`, *facultatif*) : Embeddings de texte négatif pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, *par exemple* le pondération des prompts. S'il n'est pas fourni, negative_prompt_embeds sera généré à partir de l'argument d'entrée `negative_prompt`.

lora_scale (`float`, *facultatif*) : une échelle LoRA qui sera appliquée à toutes les couches LoRA de l'encodeur de texte si des couches LoRA sont chargées.

clip_skip (`int`, *facultatif*) : Nombre de couches à ignorer dans CLIP lors du calcul des embeddings de prompt. Une valeur de 1 signifie que la sortie de la couche pré-finale sera utilisée pour calculer les embeddings de prompt.

Encode le prompt dans les états cachés de l'encodeur de texte.

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

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

**Paramètres :**

w (`torch.Tensor`) : Génère des vecteurs d'incorporation avec une échelle de guidage spécifiée afin d'enrichir par la suite les incorporations de pas de temps.

embedding_dim (`int`, *facultatif*, par défaut 512) : Dimension des embeddings à générer.

dtype (`torch.dtype`, *facultatif*, par défaut `torch.float32`) : Type de données des embeddings générés.

**Retourne :** `torch.Tensor`

Vecteurs d'embedding de forme `(len(w), embedding_dim)`.

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

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

**Paramètres :**

images (`list[PIL.Image.Image]` ou `np.ndarray`) : liste d'images PIL débruitées de longueur `batch_size` ou tableau NumPy de forme `(batch_size, height, width, num_channels)`.

nsfw_content_detected (`list[bool]`) : liste indiquant si l'image générée correspondante contient du contenu « not-safe-for-work » (nsfw) ou `None` si la vérification de sécurité n'a pas pu être effectuée.

Classe de sortie pour les pipelines Stable Diffusion.