Buckets:

hf-doc-build
/

doc

Files

xet

hf-doc-build/doc / diffusers /v0.43.0 /fr /api /pipelines /stable_diffusion /upscale.md

mishig

2 days ago

preview code

download

raw

19.6 kB

# Super-résolution

  

Le modèle de diffusion upscaler de Stable Diffusion a été créé par les chercheurs et ingénieurs de [CompVis](https://github.com/CompVis), [Stability AI](https://stability.ai/) et [LAION](https://laion.ai/). Il est utilisé pour améliorer la résolution des images d'entrée par un facteur de 4.

> [!TIP]
> Pensez à consulter la section [Astuces](overview#tips) de Stable Diffusion pour apprendre à explorer le compromis entre la vitesse et la qualité du planificateur, et à réutiliser efficacement les composants du pipeline !
>
> Si vous souhaitez utiliser l'un des points de contrôle officiels pour une tâche, explorez les organisations [CompVis](https://huggingface.co/CompVis) et [Stability AI](https://huggingface.co/stabilityai) sur le Hub !

## StableDiffusionUpscalePipeline[[diffusers.StableDiffusionUpscalePipeline]]

#### diffusers.StableDiffusionUpscalePipeline[[diffusers.StableDiffusionUpscalePipeline]]

```python
diffusers.StableDiffusionUpscalePipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, low_res_scheduler: DDPMScheduler, scheduler: KarrasDiffusionSchedulers, safety_checker: typing.Any | None = None, feature_extractor: transformers.models.clip.image_processing_pil_clip.CLIPImageProcessorPil | None = None, watermarker: typing.Any | None = None, max_noise_level: int = 350)
```

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

**Paramètres :**

vae ([AutoencoderKL](/docs/diffusers/v0.43.0/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/v5.22.2/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/v5.22.2/en/model_doc/clip#transformers.CLIPTokenizer)) : Un `CLIPTokenizer` 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.
low_res_scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/fr/api/schedulers/overview#diffusers.SchedulerMixin)) : Un planificateur utilisé pour ajouter du bruit initial à l'image de conditionnement basse résolution. Il doit être une instance de [DDPMScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/ddpm#diffusers.DDPMScheduler).
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 de super-résolution d’images guidée par le texte utilisant Stable Diffusion 2.
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.).
Le pipeline hérite également des méthodes de chargement suivantes :
- [load_textual_inversion()](/docs/diffusers/v0.43.0/fr/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) pour charger les embeddings d'inversion textuelle
- [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights) pour charger les poids LoRA
- [save_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights) pour enregistrer les poids LoRA
- [from_single_file()](/docs/diffusers/v0.43.0/fr/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file) pour charger des fichiers `.ckpt`
#### __appel__[[diffusers.StableDiffusionUpscalePipeline.__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 = 75, guidance_scale: float = 9.0, noise_level: int = 20, negative_prompt: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = 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, clip_skip: int = None)
```
[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_upscale.py#L535)
**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 à agrandir.
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 7,5) : Une valeur de guidance scale 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. Le guidance scale est activé lorsque `guidance_scale > 1`.
noise_level (`int`, *facultatif*, valeur par défaut 20) : La quantité de bruit à ajouter à l'image d'entrée agrandie. Doit être comprise dans l'intervalle `[0, max_noise_level]` où `max_noise_level` est défini par le planificateur. Une valeur plus élevée de `noise_level` ajoute plus de bruit à l'entrée, augmentant la variation mais réduisant la fidélité à l'image source.
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/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.
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 [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/fr/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) 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).
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 :** [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/fr/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) ou `tuple`
Si `return_dict` est `True`, [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/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
>>> import requests
>>> from PIL import Image
>>> from io import BytesIO
>>> from diffusers import StableDiffusionUpscalePipeline
>>> import torch

>>> # load model and scheduler
>>> model_id = "stabilityai/stable-diffusion-x4-upscaler"
>>> pipeline = StableDiffusionUpscalePipeline.from_pretrained(
...     model_id, variant="fp16", torch_dtype=torch.float16
... )
>>> pipeline = pipeline.to("cuda")

>>> # let's download an  image
>>> url = "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale/low_res_cat.png"
>>> response = requests.get(url)
>>> low_res_img = Image.open(BytesIO(response.content)).convert("RGB")
>>> low_res_img = low_res_img.resize((128, 128))
>>> prompt = "a white cat"

>>> upscaled_image = pipeline(prompt=prompt, image=low_res_img).images[0]
>>> upscaled_image.save("upsampled_cat.png")
```
#### enable_attention_slicing[[diffusers.StableDiffusionUpscalePipeline.enable_attention_slicing]]
```python
enable_attention_slicing(slice_size: str | int = 'auto')
```
[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2030)
**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.StableDiffusionUpscalePipeline.disable_attention_slicing]]
```python
disable_attention_slicing()
```
[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L2067)
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.StableDiffusionUpscalePipeline.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/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1975)
**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.StableDiffusionUpscalePipeline.disable_xformers_memory_efficient_attention]]

```python
disable_xformers_memory_efficient_attention()
```

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

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

#### encode_prompt[[diffusers.StableDiffusionUpscalePipeline.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/v0.43.0/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_upscale.py#L217)

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

## 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/v0.43.0/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.

Xet Storage Details

Size:: 19.6 kB
Xet hash:: b966973f8c6a923c10e3ca7141458059bea7bc1f2b96e0796a7b554a3901d052

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.

	# Super-résolution



	Le modèle de diffusion upscaler de Stable Diffusion a été créé par les chercheurs et ingénieurs de [CompVis](https://github.com/CompVis), [Stability AI](https://stability.ai/) et [LAION](https://laion.ai/). Il est utilisé pour améliorer la résolution des images d'entrée par un facteur de 4.

	> [!TIP]
	> Pensez à consulter la section [Astuces](overview#tips) de Stable Diffusion pour apprendre à explorer le compromis entre la vitesse et la qualité du planificateur, et à réutiliser efficacement les composants du pipeline !
	>
	> Si vous souhaitez utiliser l'un des points de contrôle officiels pour une tâche, explorez les organisations [CompVis](https://huggingface.co/CompVis) et [Stability AI](https://huggingface.co/stabilityai) sur le Hub !

	## StableDiffusionUpscalePipeline[[diffusers.StableDiffusionUpscalePipeline]]

	#### diffusers.StableDiffusionUpscalePipeline[[diffusers.StableDiffusionUpscalePipeline]]

	```python
	diffusers.StableDiffusionUpscalePipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, low_res_scheduler: DDPMScheduler, scheduler: KarrasDiffusionSchedulers, safety_checker: typing.Any \| None = None, feature_extractor: transformers.models.clip.image_processing_pil_clip.CLIPImageProcessorPil \| None = None, watermarker: typing.Any \| None = None, max_noise_level: int = 350)
	```

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

	Paramètres :

	vae ([AutoencoderKL](/docs/diffusers/v0.43.0/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/v5.22.2/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/v5.22.2/en/model_doc/clip#transformers.CLIPTokenizer)) : Un `CLIPTokenizer` 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.

	low_res_scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/fr/api/schedulers/overview#diffusers.SchedulerMixin)) : Un planificateur utilisé pour ajouter du bruit initial à l'image de conditionnement basse résolution. Il doit être une instance de [DDPMScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/ddpm#diffusers.DDPMScheduler).

	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 de super-résolution d’images guidée par le texte utilisant Stable Diffusion 2.

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

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

	#### __appel__[[diffusers.StableDiffusionUpscalePipeline.__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 = 75, guidance_scale: float = 9.0, noise_level: int = 20, negative_prompt: str \| list[str] \| None = None, num_images_per_prompt: int \| None = 1, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = 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, clip_skip: int = None)
	```

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

	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 à agrandir.

	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 7,5) : Une valeur de guidance scale 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. Le guidance scale est activé lorsque `guidance_scale > 1`.

	noise_level (`int`, facultatif, valeur par défaut 20) : La quantité de bruit à ajouter à l'image d'entrée agrandie. Doit être comprise dans l'intervalle `[0, max_noise_level]` où `max_noise_level` est défini par le planificateur. Une valeur plus élevée de `noise_level` ajoute plus de bruit à l'entrée, augmentant la variation mais réduisant la fidélité à l'image source.

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

	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 [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/fr/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) 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).

	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 : [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/fr/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) ou `tuple`

	Si `return_dict` est `True`, [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/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
	>>> import requests
	>>> from PIL import Image
	>>> from io import BytesIO
	>>> from diffusers import StableDiffusionUpscalePipeline
	>>> import torch

	>>> # load model and scheduler
	>>> model_id = "stabilityai/stable-diffusion-x4-upscaler"
	>>> pipeline = StableDiffusionUpscalePipeline.from_pretrained(
	... model_id, variant="fp16", torch_dtype=torch.float16
	... )
	>>> pipeline = pipeline.to("cuda")

	>>> # let's download an image
	>>> url = "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale/low_res_cat.png"
	>>> response = requests.get(url)
	>>> low_res_img = Image.open(BytesIO(response.content)).convert("RGB")
	>>> low_res_img = low_res_img.resize((128, 128))
	>>> prompt = "a white cat"

	>>> upscaled_image = pipeline(prompt=prompt, image=low_res_img).images[0]
	>>> upscaled_image.save("upsampled_cat.png")
	```

	#### enable_attention_slicing[[diffusers.StableDiffusionUpscalePipeline.enable_attention_slicing]]

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

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

	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.StableDiffusionUpscalePipeline.disable_attention_slicing]]

	```python
	disable_attention_slicing()
	```

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

	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.StableDiffusionUpscalePipeline.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/v0.43.0/src/diffusers/pipelines/pipeline_utils.py#L1975)

	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.StableDiffusionUpscalePipeline.disable_xformers_memory_efficient_attention]]

	```python
	disable_xformers_memory_efficient_attention()
	```

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

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

	#### encode_prompt[[diffusers.StableDiffusionUpscalePipeline.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/v0.43.0/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_upscale.py#L217)

	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.

	## 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/v0.43.0/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.