# Stable unCLIP

  

Les points de contrôle Stable unCLIP sont affinés à partir des points de contrôle [Stable Diffusion 2.1](./stable_diffusion/stable_diffusion_2) afin de conditionner sur les embeddings d’images CLIP. Stable unCLIP conditionne toujours sur les embeddings de texte. Compte tenu des deux conditionnements distincts, stable unCLIP peut être utilisé pour la variation d’images guidée par le texte. Combiné à un prior unCLIP, il peut également être utilisé pour la génération complète d’images à partir de texte.

L'abstract de l'article est :

*Les modèles contrastifs comme CLIP ont démontré leur capacité à apprendre des représentations robustes d’images qui capturent à la fois la sémantique et le style. Pour exploiter ces représentations pour la génération d’images, nous proposons un modèle en deux étapes : un modèle a priori qui génère un embedding d’image CLIP à partir d’une légende textuelle, et un décodeur qui génère une image conditionnée par l’embedding d’image. Nous montrons que la génération explicite de représentations d’images améliore la diversité des images avec une perte minimale en photoréalisme et en similarité avec la légende. Nos décodeurs conditionnés par des représentations d’images peuvent également produire des variations d’une image qui préservent à la fois sa sémantique et son style, tout en faisant varier les détails non essentiels absents de la représentation d’image. De plus, l’espace d’embedding conjoint de CLIP permet des manipulations d’images guidées par le langage de manière zéro-shot. Nous utilisons des modèles de diffusion pour le décodeur et expérimentons avec des modèles autorégressifs et des modèles de diffusion pour le modèle a priori, constatant que ces derniers sont plus efficaces sur le plan computationnel et produisent des échantillons de meilleure qualité.*

## Astuces

Stable unCLIP prend `noise_level` en entrée lors de l'inférence, ce qui détermine la quantité de bruit ajoutée aux embeddings d'image. Une valeur plus élevée de `noise_level` augmente la variation des images finales débruitées. Par défaut, nous n'ajoutons aucun bruit supplémentaire aux embeddings d'image (`noise_level = 0`).

### Génération d'images à partir de texte
Stable unCLIP peut être utilisé pour la génération d'images à partir de texte en le combinant avec le modèle antérieur de la réplique open source de DALL-E 2 de KakaoBrain, [Karlo](https://huggingface.co/kakaobrain/karlo-v1-alpha) :

```python
import torch
from diffusers import UnCLIPScheduler, DDPMScheduler, StableUnCLIPPipeline
from diffusers.models import PriorTransformer
from transformers import CLIPTokenizer, CLIPTextModelWithProjection

prior_model_id = "kakaobrain/karlo-v1-alpha"
data_type = torch.float16
prior = PriorTransformer.from_pretrained(prior_model_id, subfolder="prior", dtype=data_type)

prior_text_model_id = "openai/clip-vit-large-patch14"
prior_tokenizer = CLIPTokenizer.from_pretrained(prior_text_model_id)
prior_text_model = CLIPTextModelWithProjection.from_pretrained(prior_text_model_id, dtype=data_type)
prior_scheduler = UnCLIPScheduler.from_pretrained(prior_model_id, subfolder="prior_scheduler")
prior_scheduler = DDPMScheduler.from_config(prior_scheduler.config)

stable_unclip_model_id = "stabilityai/stable-diffusion-2-1-unclip-small"

pipe = StableUnCLIPPipeline.from_pretrained(
    stable_unclip_model_id,
    dtype=data_type,
    variant="fp16",
    prior_tokenizer=prior_tokenizer,
    prior_text_encoder=prior_text_model,
    prior=prior,
    prior_scheduler=prior_scheduler,
)

pipe = pipe.to("cuda")  # or "mps", "xpu", "cpu"
wave_prompt = "dramatic wave, the Oceans roar, Strong wave spiral across the oceans as the waves unfurl into roaring crests; perfect wave form; perfect wave shape; dramatic wave shape; wave shape unbelievable; wave; wave shape spectacular"

image = pipe(prompt=wave_prompt).images[0]
image
```
> [!WARNING]
> Pour la génération d’images à partir de texte, nous utilisons `stabilityai/stable-diffusion-2-1-unclip-small` car il a été entraîné sur les embeddings CLIP ViT-L/14, identiques à ceux du modèle prior de Karlo. [stabilityai/stable-diffusion-2-1-unclip](https://hf.co/stabilityai/stable-diffusion-2-1-unclip) a été entraîné sur OpenCLIP ViT-H, nous ne recommandons donc pas son utilisation.

### Variation d'image en image guidée par le texte

```python
from diffusers import StableUnCLIPImg2ImgPipeline
from diffusers.utils import load_image
import torch

pipe = StableUnCLIPImg2ImgPipeline.from_pretrained(
    "stabilityai/stable-diffusion-2-1-unclip", dtype=torch.float16, variation="fp16"
)
pipe = pipe.to("cuda")  # or "mps", "xpu", "cpu"

url = "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/tarsila_do_amaral.png"
init_image = load_image(url)

images = pipe(init_image).images
images[0].save("variation_image.png")
```

Facultativement, vous pouvez également passer un prompt à `pipe`, par exemple :

```python
prompt = "A fantasy landscape, trending on artstation"

image = pipe(init_image, prompt=prompt).images[0]
image
```

> [!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.

## StableUnCLIPPipeline[[diffusers.StableUnCLIPPipeline]]

#### diffusers.StableUnCLIPPipeline[[diffusers.StableUnCLIPPipeline]]

```python
diffusers.StableUnCLIPPipeline(prior_tokenizer: CLIPTokenizer, prior_text_encoder: CLIPTextModelWithProjection, prior: PriorTransformer, prior_scheduler: KarrasDiffusionSchedulers, image_normalizer: StableUnCLIPImageNormalizer, image_noising_scheduler: KarrasDiffusionSchedulers, tokenizer: CLIPTokenizer, text_encoder: CLIPTextModel, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, vae: AutoencoderKL)
```

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

**Paramètres :**

prior_tokenizer (`CLIPTokenizer`) : A `CLIPTokenizer`.

prior_text_encoder (`CLIPTextModelWithProjection`) : encodeur de texte `CLIPTextModelWithProjection` figé.

prior ([PriorTransformer](/docs/diffusers/main/fr/api/models/prior_transformer#diffusers.PriorTransformer)) : le prior unCLIP canonique pour approximer l’embedding d’image à partir de l’embedding de texte.

prior_scheduler (`KarrasDiffusionSchedulers`) : Planificateur utilisé dans le processus de débruitage préalable.

image_normalizer (`StableUnCLIPImageNormalizer`) : Sert à normaliser les embeddings d’image prédits avant l’application du bruit et à dénormaliser les embeddings d’image après l’application du bruit.

image_noising_scheduler (`KarrasDiffusionSchedulers`) : Planification du bruit pour ajouter du bruit aux embeddings d'image prédits. La quantité de bruit à ajouter est déterminée par le `noise_level`.

tokenizer (`CLIPTokenizer`) : A `CLIPTokenizer`.

text_encoder (`CLIPTextModel`) : encodeur de texte `CLIPTextModel` figé.

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

scheduler (`KarrasDiffusionSchedulers`) : un planificateur à utiliser en combinaison avec `unet` pour débruyer les latents de l'image encodée.

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

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

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

#### __appel__[[diffusers.StableUnCLIPPipeline.__call__]]

```python
__call__(prompt: str | list[str] | None = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 20, guidance_scale: float = 10.0, negative_prompt: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Optional[torch.Generator] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int = 1, cross_attention_kwargs: dict[str, typing.Any] | None = None, noise_level: int = 0, prior_num_inference_steps: int = 25, prior_guidance_scale: float = 4.0, prior_latents: typing.Optional[torch.Tensor] = None, clip_skip: int | None = None)
```

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

**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 20) : 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 10.0) : Une valeur d'échelle de guidage plus élevée 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`.

negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts pour guider ce qu'il ne faut pas inclure dans la génération d'image. S'il n'est pas défini, vous devez passer `negative_prompt_embeds` à la place. Ignoré lorsque la guidance n'est pas utilisée (`guidance_scale < 1`).

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

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/main/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.

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

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

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 [ImagePipelineOutput](/docs/diffusers/main/fr/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) plutôt qu'un simple tuple.

callback (`Callable`, *facultatif*) : une fonction appelée toutes les `callback_steps` étapes pendant l'inférence. La fonction est appelée avec les arguments suivants : `callback(step: int, timestep: int, latents: torch.Tensor)`.

callback_steps (`int`, *facultatif*, valeur par défaut 1) : La fréquence à laquelle la fonction `callback` est appelée. Si non spécifié, le callback est appelé à chaque étape.

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

noise_level (`int`, *facultatif*, valeur par défaut `0`) : La quantité de bruit à ajouter aux embeddings d'image. Une valeur plus élevée de `noise_level` augmente la variance des images finales débruitées. Consultez [StableUnCLIPPipeline.noise_image_embeddings()](/docs/diffusers/main/fr/api/pipelines/stable_unclip#diffusers.StableUnCLIPPipeline.noise_image_embeddings) pour plus de détails.

prior_num_inference_steps (`int`, *facultatif*, valeur par défaut 25) : Le nombre d'étapes de débruitage dans le processus de débruitage du modèle prioritaire. 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.

prior_guidance_scale (`float`, *facultatif*, valeur par défaut 4.0) : Une valeur d'échelle de guidage plus élevée 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`.

prior_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'embeddings d'image dans le processus de débruitage préalable. 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.

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.

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

`~ pipeline_utils.ImagePipelineOutput` si `return_dict` est True, sinon un `tuple`. En cas de retour d'un tuple, 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.

Exemples :
```py
>>> import torch
>>> from diffusers import StableUnCLIPPipeline

>>> pipe = StableUnCLIPPipeline.from_pretrained(
...     "fusing/stable-unclip-2-1-l", torch_dtype=torch.float16
... )  # TODO update model path
>>> pipe = pipe.to("cuda")

>>> prompt = "a photo of an astronaut riding a horse on mars"
>>> images = pipe(prompt).images
>>> images[0].save("astronaut_horse.png")
```

#### enable_attention_slicing[[diffusers.StableUnCLIPPipeline.enable_attention_slicing]]

```python
enable_attention_slicing(slice_size: str | int = 'auto')
```

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

**Paramètres :**

slice_size (`str` ou `int`, *facultatif*, par défaut `"auto"`) : lorsque la valeur est `"auto"`, l’entrée des têtes d’attention est divisée par deux, de sorte que l’attention est calculée en deux étapes. Si la valeur est `"max"`, la quantité maximale de mémoire est économisée en n’exécutant qu’une seule tranche à la fois. Si un nombre est fourni, autant de tranches sont utilisées que `attention_head_dim // slice_size`. Dans ce cas, `attention_head_dim` doit être un multiple de `slice_size`.

Active le calcul de l'attention par tranches. Lorsque cette option est activée, le module d'attention divise le tenseur d'entrée en tranches pour calculer l'attention en plusieurs étapes. Pour plus d'une tête d'attention, le calcul est effectué séquentiellement sur chaque tête. Cela est utile pour économiser de la mémoire au prix d'une légère diminution de la vitesse.

> [!WARNING] > ⚠️ N'activez pas le tranchage de l'attention si vous utilisez déjà `scaled_dot_product_attention` (SDPA)
de PyTorch > 2.0 ou xFormers. Ces calculs d'attention sont déjà très économes en mémoire, vous n'aurez donc pas besoin d'activer > cette fonction. Si vous activez le tranchage de l'attention avec SDPA ou xFormers, cela peut entraîner des ralentissements importants !

Exemples :

```py
>>> import torch
>>> from diffusers import StableDiffusionPipeline

>>> pipe = StableDiffusionPipeline.from_pretrained(
...     "stable-diffusion-v1-5/stable-diffusion-v1-5",
...     dtype=torch.float16,
...     use_safetensors=True,
... )

>>> prompt = "a photo of an astronaut riding a horse on mars"
>>> pipe.enable_attention_slicing()
>>> image = pipe(prompt).images[0]
```

#### disable_attention_slicing[[diffusers.StableUnCLIPPipeline.disable_attention_slicing]]

```python
disable_attention_slicing()
```

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

Désactive le calcul de l'attention par tranches. Si `enable_attention_slicing` a été appelé précédemment, l'attention est calculée en une seule étape.

#### enable_xformers_memory_efficient_attention[[diffusers.StableUnCLIPPipeline.enable_xformers_memory_efficient_attention]]

```python
enable_xformers_memory_efficient_attention(attention_op: typing.Optional[typing.Callable] = None)
```

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

**Paramètres :**

attention_op (`Callable`, *facultatif*) : Remplace l'opérateur par défaut `None` pour être utilisé comme argument `op` de la fonction [`memory_efficient_attention()`](https://facebookresearch.github.io/xformers/components/ops.html#xformers.ops.memory_efficient_attention) de xFormers.

Activer l’attention efficace en mémoire de [xFormers](https://facebookresearch.github.io/xformers/). Lorsque cette option est activée, vous devriez observer une réduction de l’utilisation de la mémoire GPU et une accélération potentielle lors de l’inférence. L’accélération lors de l’entraînement n’est pas garantie.

> [!WARNING] > ⚠️ Lorsque l'attention efficace en mémoire et l'attention par tranches sont toutes deux activées, l'attention efficace
attention prend > précédent.

Exemples :

```py
>>> import torch
>>> from diffusers import DiffusionPipeline
>>> from xformers.ops import MemoryEfficientAttentionFlashAttentionOp

>>> pipe = DiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-2-1", dtype=torch.float16)
>>> pipe = pipe.to("cuda")
>>> pipe.enable_xformers_memory_efficient_attention(attention_op=MemoryEfficientAttentionFlashAttentionOp)
>>> # Workaround for not accepting attention shape using VAE for Flash Attention
>>> pipe.vae.enable_xformers_memory_efficient_attention(attention_op=None)
```

#### disable_xformers_memory_efficient_attention[[diffusers.StableUnCLIPPipeline.disable_xformers_memory_efficient_attention]]

```python
disable_xformers_memory_efficient_attention()
```

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

Désactiver l'attention efficace en mémoire de [xFormers](https://facebookresearch.github.io/xformers/).

#### encode_prompt[[diffusers.StableUnCLIPPipeline.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/stable_diffusion/pipeline_stable_unclip.py#L297)

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

#### noise_image_embeddings[[diffusers.StableUnCLIPPipeline.noise_image_embeddings]]

```python
noise_image_embeddings(image_embeds: Tensor, noise_level: int, noise: typing.Optional[torch.Tensor] = None, generator: typing.Optional[torch.Generator] = None)
```

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

Ajoutez du bruit aux embeddings d’images. La quantité de bruit est contrôlée par l’entrée `noise_level`. Une valeur plus élevée de `noise_level` augmente la variance des images finales après débruitage.

Le bruit est appliqué de deux manières :
1. Un calendrier de bruit est appliqué directement aux embeddings.
2. Un vecteur d'embeddings temporels sinusoïdaux est ajouté à la sortie.

Dans les deux cas, la quantité de bruit est contrôlée par le même `noise_level`.

Les embeddings sont normalisés avant l'application du bruit et dénormalisés après l'application du bruit.

## StableUnCLIPImg2ImgPipeline[[diffusers.StableUnCLIPImg2ImgPipeline]]

#### diffusers.StableUnCLIPImg2ImgPipeline[[diffusers.StableUnCLIPImg2ImgPipeline]]

```python
diffusers.StableUnCLIPImg2ImgPipeline(feature_extractor: CLIPImageProcessorPil, image_encoder: CLIPVisionModelWithProjection, image_normalizer: StableUnCLIPImageNormalizer, image_noising_scheduler: KarrasDiffusionSchedulers, tokenizer: CLIPTokenizer, text_encoder: CLIPTextModel, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, vae: AutoencoderKL)
```

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

**Paramètres :**

feature_extractor (`CLIPImageProcessor`) : Extracteur de caractéristiques pour la prétraitement des images avant encodage.

image_encoder (`CLIPVisionModelWithProjection`) : modèle de vision CLIP pour l'encodage d'images.

image_normalizer (`StableUnCLIPImageNormalizer`) : Sert à normaliser les embeddings d’image prédits avant l’application du bruit et à dénormaliser les embeddings d’image après l’application du bruit.

image_noising_scheduler (`KarrasDiffusionSchedulers`) : Planification du bruit pour ajouter du bruit aux embeddings d'image prédits. La quantité de bruit à ajouter est déterminée par le `noise_level`.

tokenizer (`~transformers.CLIPTokenizer`) : A [`~transformers.CLIPTokenizer`)].

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

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

scheduler (`KarrasDiffusionSchedulers`) : un planificateur à utiliser en combinaison avec `unet` pour débruyer les latents de l'image encodée.

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

Pipeline pour la génération d'image à partir d'image guidée par du texte en utilisant stable unCLIP.

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

#### __appel__[[diffusers.StableUnCLIPImg2ImgPipeline.__call__]]

```python
__call__(image: typing.Union[torch.Tensor, PIL.Image.Image] = None, prompt: str | list[str] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 20, guidance_scale: float = 10, negative_prompt: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Optional[torch.Generator] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int = 1, cross_attention_kwargs: dict[str, typing.Any] | None = None, noise_level: int = 0, image_embeds: typing.Optional[torch.Tensor] = None, clip_skip: int | None = None)
```

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

**Paramètres :**

prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts pour guider la génération d’image. S’il n’est pas défini, soit `prompt_embeds` est utilisé, soit prompt est initialisé à `""`.

image (`torch.Tensor` ou `PIL.Image.Image`) : `Image` ou tenseur représentant un lot d'images. L'image est encodée dans son embedding CLIP sur lequel le `unet` est conditionné. L'image n'est _pas_ encodée par le `vae` puis utilisée comme latents dans le processus de débruitage, contrairement au processus standard de variation d'image guidée par le texte de Stable Diffusion.

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 20) : 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 10.0) : Une valeur d'échelle de guidage plus élevée 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`.

negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts pour guider ce qu'il ne faut pas inclure dans la génération d'image. S'il n'est pas défini, vous devez passer `negative_prompt_embeds` à la place. Ignoré lorsque la guidance n'est pas utilisée (`guidance_scale < 1`).

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

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/main/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.

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

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

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 [ImagePipelineOutput](/docs/diffusers/main/fr/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) plutôt qu'un simple tuple.

callback (`Callable`, *facultatif*) : une fonction appelée toutes les `callback_steps` étapes pendant l'inférence. La fonction est appelée avec les arguments suivants : `callback(step: int, timestep: int, latents: torch.Tensor)`.

callback_steps (`int`, *facultatif*, valeur par défaut 1) : La fréquence à laquelle la fonction `callback` est appelée. Si non spécifié, le callback est appelé à chaque étape.

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

noise_level (`int`, *facultatif*, valeur par défaut `0`) : La quantité de bruit à ajouter aux embeddings d'image. Une valeur plus élevée de `noise_level` augmente la variance des images finales débruitées. Consultez [StableUnCLIPPipeline.noise_image_embeddings()](/docs/diffusers/main/fr/api/pipelines/stable_unclip#diffusers.StableUnCLIPPipeline.noise_image_embeddings) pour plus de détails.

image_embeds (`torch.Tensor`, *facultatif*) : Embeddings CLIP pré-générés pour conditionner le `unet`. Ces latents ne sont pas utilisés dans le processus de débruitage. Si vous souhaitez fournir des latents pré-générés, passez-les à `__call__` en tant que `latents`.

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.

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

`~ pipeline_utils.ImagePipelineOutput` si `return_dict` est True, sinon un `tuple`. En cas de retour d'un tuple, 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.

Exemples :
```py
>>> import requests
>>> import torch
>>> from PIL import Image
>>> from io import BytesIO

>>> from diffusers import StableUnCLIPImg2ImgPipeline

>>> pipe = StableUnCLIPImg2ImgPipeline.from_pretrained(
...     "stabilityai/stable-diffusion-2-1-unclip-small", torch_dtype=torch.float16
... )
>>> pipe = pipe.to("cuda")

>>> url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg"

>>> response = requests.get(url)
>>> init_image = Image.open(BytesIO(response.content)).convert("RGB")
>>> init_image = init_image.resize((768, 512))

>>> prompt = "A fantasy landscape, trending on artstation"

>>> images = pipe(init_image, prompt).images
>>> images[0].save("fantasy_landscape.png")
```

#### enable_attention_slicing[[diffusers.StableUnCLIPImg2ImgPipeline.enable_attention_slicing]]

```python
enable_attention_slicing(slice_size: str | int = 'auto')
```

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

**Paramètres :**

slice_size (`str` ou `int`, *facultatif*, par défaut `"auto"`) : lorsque la valeur est `"auto"`, l’entrée des têtes d’attention est divisée par deux, de sorte que l’attention est calculée en deux étapes. Si la valeur est `"max"`, la quantité maximale de mémoire est économisée en n’exécutant qu’une seule tranche à la fois. Si un nombre est fourni, autant de tranches sont utilisées que `attention_head_dim // slice_size`. Dans ce cas, `attention_head_dim` doit être un multiple de `slice_size`.

Active le calcul de l'attention par tranches. Lorsque cette option est activée, le module d'attention divise le tenseur d'entrée en tranches pour calculer l'attention en plusieurs étapes. Pour plus d'une tête d'attention, le calcul est effectué séquentiellement sur chaque tête. Cela est utile pour économiser de la mémoire au prix d'une légère diminution de la vitesse.

> [!WARNING] > ⚠️ N'activez pas le tranchage de l'attention si vous utilisez déjà `scaled_dot_product_attention` (SDPA)
de PyTorch > 2.0 ou xFormers. Ces calculs d'attention sont déjà très économes en mémoire, vous n'aurez donc pas besoin d'activer > cette fonction. Si vous activez le tranchage de l'attention avec SDPA ou xFormers, cela peut entraîner des ralentissements importants !

Exemples :

```py
>>> import torch
>>> from diffusers import StableDiffusionPipeline

>>> pipe = StableDiffusionPipeline.from_pretrained(
...     "stable-diffusion-v1-5/stable-diffusion-v1-5",
...     dtype=torch.float16,
...     use_safetensors=True,
... )

>>> prompt = "a photo of an astronaut riding a horse on mars"
>>> pipe.enable_attention_slicing()
>>> image = pipe(prompt).images[0]
```

#### disable_attention_slicing[[diffusers.StableUnCLIPImg2ImgPipeline.disable_attention_slicing]]

```python
disable_attention_slicing()
```

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

Désactive le calcul de l'attention par tranches. Si `enable_attention_slicing` a été appelé précédemment, l'attention est calculée en une seule étape.

#### enable_xformers_memory_efficient_attention[[diffusers.StableUnCLIPImg2ImgPipeline.enable_xformers_memory_efficient_attention]]

```python
enable_xformers_memory_efficient_attention(attention_op: typing.Optional[typing.Callable] = None)
```

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

**Paramètres :**

attention_op (`Callable`, *facultatif*) : Remplace l'opérateur par défaut `None` pour être utilisé comme argument `op` de la fonction [`memory_efficient_attention()`](https://facebookresearch.github.io/xformers/components/ops.html#xformers.ops.memory_efficient_attention) de xFormers.

Activer l’attention efficace en mémoire de [xFormers](https://facebookresearch.github.io/xformers/). Lorsque cette option est activée, vous devriez observer une réduction de l’utilisation de la mémoire GPU et une accélération potentielle lors de l’inférence. L’accélération lors de l’entraînement n’est pas garantie.

> [!WARNING] > ⚠️ Lorsque l'attention efficace en mémoire et l'attention par tranches sont toutes deux activées, l'attention efficace
attention prend > précédent.

Exemples :

```py
>>> import torch
>>> from diffusers import DiffusionPipeline
>>> from xformers.ops import MemoryEfficientAttentionFlashAttentionOp

>>> pipe = DiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-2-1", dtype=torch.float16)
>>> pipe = pipe.to("cuda")
>>> pipe.enable_xformers_memory_efficient_attention(attention_op=MemoryEfficientAttentionFlashAttentionOp)
>>> # Workaround for not accepting attention shape using VAE for Flash Attention
>>> pipe.vae.enable_xformers_memory_efficient_attention(attention_op=None)
```

#### disable_xformers_memory_efficient_attention[[diffusers.StableUnCLIPImg2ImgPipeline.disable_xformers_memory_efficient_attention]]

```python
disable_xformers_memory_efficient_attention()
```

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

Désactiver l'attention efficace en mémoire de [xFormers](https://facebookresearch.github.io/xformers/).

#### encode_prompt[[diffusers.StableUnCLIPImg2ImgPipeline.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/stable_diffusion/pipeline_stable_unclip_img2img.py#L259)

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

#### noise_image_embeddings[[diffusers.StableUnCLIPImg2ImgPipeline.noise_image_embeddings]]

```python
noise_image_embeddings(image_embeds: Tensor, noise_level: int, noise: typing.Optional[torch.Tensor] = None, generator: typing.Optional[torch.Generator] = None)
```

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

Ajoutez du bruit aux embeddings d’images. La quantité de bruit est contrôlée par l’entrée `noise_level`. Une valeur plus élevée de `noise_level` augmente la variance des images finales après débruitage.

Le bruit est appliqué de deux manières :
1. Un calendrier de bruit est appliqué directement aux embeddings.
2. Un vecteur d'embeddings temporels sinusoïdaux est ajouté à la sortie.

Dans les deux cas, la quantité de bruit est contrôlée par le même `noise_level`.

Les embeddings sont normalisés avant l'application du bruit et dénormalisés après l'application du bruit.

## ImagePipelineOutput[[diffusers.ImagePipelineOutput]]

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

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

[Source](https://github.com/huggingface/diffusers/blob/main/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.