# Diffusion latente

Latent Diffusion a été proposé dans [High-Resolution Image Synthesis with Latent Diffusion Models](https://huggingface.co/papers/2112.10752) par Robin Rombach, Andreas Blattmann, Dominik Lorenz, Patrick Esser, Björn Ommer.

L'abstract de l'article est :

*En décomposant le processus de formation d’image en une application séquentielle d’auto-encodeurs de débruitage, les modèles de diffusion (DM) atteignent des résultats de synthèse de pointe sur les données d’image et au-delà. De plus, leur formulation permet un mécanisme de guidage pour contrôler le processus de génération d’image sans réentraînement. Cependant, comme ces modèles opèrent généralement directement dans l’espace des pixels, l’optimisation de DM puissants consomme souvent des centaines de jours GPU et l’inférence est coûteuse en raison des évaluations séquentielles. Pour permettre l’entraînement de DM sur des ressources de calcul limitées tout en conservant leur qualité et leur flexibilité, nous les appliquons dans l’espace latent de puissants auto-encodeurs pré-entraînés. Contrairement aux travaux antérieurs, l’entraînement de modèles de diffusion sur une telle représentation permet, pour la première fois, d’atteindre un point quasi optimal entre la réduction de la complexité et la préservation des détails, améliorant considérablement la fidélité visuelle. En introduisant des couches d’attention croisée dans l’architecture du modèle, nous transformons les modèles de diffusion en générateurs puissants et flexibles pour des entrées de conditionnement générales telles que le texte ou les boîtes englobantes, et la synthèse haute résolution devient possible de manière convolutionnelle. Nos modèles de diffusion latente (LDM) atteignent un nouvel état de l’art pour l’inpainting d’image et des performances très compétitives sur diverses tâches, y compris la génération d’image inconditionnelle, la synthèse de scènes sémantiques et la super-résolution, tout en réduisant considérablement les exigences de calcul par rapport aux DM basés sur les pixels.*

Le code source original peut être trouvé sur [CompVis/latent-diffusion](https://github.com/CompVis/latent-diffusion).

> [!TIP]
> Pensez à consulter le [guide des Schedulers](../../using-diffusers/schedulers) pour apprendre à explorer le compromis entre la vitesse et la qualité du scheduler, et à consulter la section [réutilisation des composants entre les pipelines](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) pour apprendre à charger efficacement les mêmes composants dans plusieurs pipelines.

## LDMTextToImagePipeline[[diffusers.LDMTextToImagePipeline]]

#### diffusers.LDMTextToImagePipeline[[diffusers.LDMTextToImagePipeline]]

```python
diffusers.LDMTextToImagePipeline(vqvae: diffusers.models.autoencoders.vq_model.VQModel | diffusers.models.autoencoders.autoencoder_kl.AutoencoderKL, bert: PreTrainedModel, tokenizer: PythonBackend, unet: diffusers.models.unets.unet_2d.UNet2DModel | diffusers.models.unets.unet_2d_condition.UNet2DConditionModel, scheduler: diffusers.schedulers.scheduling_ddim.DDIMScheduler | diffusers.schedulers.scheduling_pndm.PNDMScheduler | diffusers.utils.dummy_torch_and_scipy_objects.LMSDiscreteScheduler)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/latent_diffusion/pipeline_latent_diffusion.py#L39)

**Paramètres :**

vqvae ([VQModel](/docs/diffusers/v0.43.0/fr/api/models/vq#diffusers.VQModel)) : modèle à quantification vectorielle (VQ) permettant d’encoder et de décoder des images vers et depuis des représentations latentes.

bert (`LDMBertModel`) : Modèle d'encodeur de texte basé sur `BERT`.

tokenizer ([BertTokenizer](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/lxmert#transformers.BertTokenizer)) : Un `BertTokenizer` pour tokeniser le texte.

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

scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/fr/api/schedulers/overview#diffusers.SchedulerMixin)) : Un planificateur à utiliser en combinaison avec `unet` pour débruyer les latents de l'image encodée. Peut être l'un des [DDIMScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) ou [PNDMScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/pndm#diffusers.PNDMScheduler).

Pipeline pour la génération d'images à partir de texte utilisant la diffusion latente.

Ce modèle hérite de [DiffusionPipeline](/docs/diffusers/v0.43.0/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.).

#### __appel__[[diffusers.LDMTextToImagePipeline.__call__]]

```python
__call__(prompt: str | list[str], height: int | None = None, width: int | None = None, num_inference_steps: int | None = 50, guidance_scale: float | None = 1.0, eta: float | None = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, **kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/latent_diffusion/pipeline_latent_diffusion.py#L74)

**Paramètres :**

prompt (`str` ou `list[str]`) : Le prompt ou les prompts pour guider la génération d'image.

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.

guidance_scale (`float`, *facultatif*, valeur par défaut 1.0) : 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`.

eta (`float`, *facultatif*, valeur par défaut 0.0) : Correspond au paramètre eta (η) de l'article [DDIM](https://huggingface.co/papers/2010.02502). S'applique uniquement au [DDIMScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/ddim#diffusers.DDIMScheduler) et est ignoré par les autres planificateurs.

generator (`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.

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

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

**Retourne :** [ImagePipelineOutput](/docs/diffusers/v0.43.0/fr/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) ou `tuple`

Si `return_dict` est `True`, [ImagePipelineOutput](/docs/diffusers/v0.43.0/fr/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) est retourné, sinon un `tuple` est retourné dont le premier élément est une liste contenant les images générées.

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

Exemple :

```py
>>> from diffusers import DiffusionPipeline

>>> # load model and scheduler
>>> ldm = DiffusionPipeline.from_pretrained("CompVis/ldm-text2im-large-256")

>>> # run pipeline in inference (sample random noise and denoise)
>>> prompt = "A painting of a squirrel eating a burger"
>>> images = ldm([prompt], num_inference_steps=50, eta=0.3, guidance_scale=6).images

>>> # save images
>>> for idx, image in enumerate(images):
...     image.save(f"squirrel-{idx}.png")
```

## LDMSuperResolutionPipeline[[diffusers.LDMSuperResolutionPipeline]]

#### diffusers.LDMSuperResolutionPipeline[[diffusers.LDMSuperResolutionPipeline]]

```python
diffusers.LDMSuperResolutionPipeline(vqvae: VQModel, unet: UNet2DModel, scheduler: diffusers.schedulers.scheduling_ddim.DDIMScheduler | diffusers.schedulers.scheduling_pndm.PNDMScheduler | diffusers.utils.dummy_torch_and_scipy_objects.LMSDiscreteScheduler | diffusers.schedulers.scheduling_euler_discrete.EulerDiscreteScheduler | diffusers.schedulers.scheduling_euler_ancestral_discrete.EulerAncestralDiscreteScheduler | diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/latent_diffusion/pipeline_latent_diffusion_superresolution.py#L39)

**Paramètres :**

vqvae ([VQModel](/docs/diffusers/v0.43.0/fr/api/models/vq#diffusers.VQModel)) : modèle à quantification vectorielle (VQ) permettant d’encoder et de décoder des images vers et depuis des représentations latentes.

unet ([UNet2DModel](/docs/diffusers/v0.43.0/fr/api/models/unet2d#diffusers.UNet2DModel)) : Un `UNet2DModel` pour débruyer l'image encodée.

scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/fr/api/schedulers/overview#diffusers.SchedulerMixin)) : Un planificateur à utiliser en combinaison avec `unet` pour débruyer les latents de l'image encodée. Peut être l'un des [DDIMScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler), [EulerDiscreteScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/euler#diffusers.EulerDiscreteScheduler), [EulerAncestralDiscreteScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/euler_ancestral#diffusers.EulerAncestralDiscreteScheduler), [DPMSolverMultistepScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/multistep_dpm_solver#diffusers.DPMSolverMultistepScheduler) ou [PNDMScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/pndm#diffusers.PNDMScheduler).

Un pipeline pour la super-résolution d'images utilisant la diffusion latente.

Ce modèle hérite de [DiffusionPipeline](/docs/diffusers/v0.43.0/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.).

#### __appel__[[diffusers.LDMSuperResolutionPipeline.__call__]]

```python
__call__(image: typing.Union[torch.Tensor, PIL.Image.Image] = None, batch_size: int | None = 1, num_inference_steps: int | None = 100, eta: float | None = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, output_type: str | None = 'pil', return_dict: bool = True)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/latent_diffusion/pipeline_latent_diffusion_superresolution.py#L71)

**Paramètres :**

image (`torch.Tensor` ou `PIL.Image.Image`) : `Image` ou tenseur représentant un lot d'images à utiliser comme point de départ pour le processus.

batch_size (`int`, *facultatif*, valeur par défaut 1) : Nombre d'images à générer.

num_inference_steps (`int`, *facultatif*, valeur par défaut 100) : 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.

eta (`float`, *facultatif*, valeur par défaut 0.0) : Correspond au paramètre eta (η) de l'article [DDIM](https://huggingface.co/papers/2010.02502). S'applique uniquement au [DDIMScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/ddim#diffusers.DDIMScheduler) et est ignoré par les autres planificateurs.

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.

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

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

**Retourne :** [ImagePipelineOutput](/docs/diffusers/v0.43.0/fr/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) ou `tuple`

Si `return_dict` est `True`, [ImagePipelineOutput](/docs/diffusers/v0.43.0/fr/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) est retourné, sinon un `tuple` est retourné dont le premier élément est une liste contenant les images générées

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

Exemple :

```py
>>> import requests
>>> from PIL import Image
>>> from io import BytesIO
>>> from diffusers import LDMSuperResolutionPipeline
>>> import torch

>>> # load model and scheduler
>>> pipeline = LDMSuperResolutionPipeline.from_pretrained("CompVis/ldm-super-resolution-4x-openimages")
>>> pipeline = pipeline.to("cuda")

>>> # let's download an  image
>>> url = (
...     "https://user-images.githubusercontent.com/38061659/199705896-b48e17b8-b231-47cd-a270-4ffa5a93fa3e.png"
... )
>>> response = requests.get(url)
>>> low_res_img = Image.open(BytesIO(response.content)).convert("RGB")
>>> low_res_img = low_res_img.resize((128, 128))

>>> # run pipeline in inference (sample random noise and denoise)
>>> upscaled_image = pipeline(low_res_img, num_inference_steps=100, eta=1).images[0]
>>> # save image
>>> upscaled_image.save("ldm_generated_image.png")
```

## ImagePipelineOutput[[diffusers.ImagePipelineOutput]]

#### diffusers.ImagePipelineOutput[[diffusers.ImagePipelineOutput]]

```python
diffusers.ImagePipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray)
```

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

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

Classe de sortie pour les pipelines d’images.