diffusers/main/fr/api/pipelines/stable_diffusion/latent_upscale.md

Upscaler latent

Le modèle de super-résolution latente Stable Diffusion a été créé par Katherine Crowson en collaboration avec Stability AI. Il est utilisé pour améliorer la résolution de l'image de sortie par un facteur de 2 (voir ce notebook de démonstration pour une illustration de l'implémentation originale).

Pensez à consulter la section Astuces 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 et Stability AI sur le Hub !

StableDiffusionLatentUpscalePipeline[[diffusers.StableDiffusionLatentUpscalePipeline]]

diffusers.StableDiffusionLatentUpscalePipeline[[diffusers.StableDiffusionLatentUpscalePipeline]]

diffusers.StableDiffusionLatentUpscalePipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: EulerDiscreteScheduler)

Source

Paramètres :

vae (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) : encodeur de texte figé (clip-vit-large-patch14).

tokenizer (CLIPTokenizer) : Un CLIPTokenizer pour tokeniser le texte.

unet (UNet2DConditionModel) : un UNet2DConditionModel pour débruyer les latents d'image encodés.

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

Pipeline pour augmenter la résolution des images de sortie de Stable Diffusion par un facteur de 2.

Ce modèle hérite de 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 :

• from_single_file() pour charger des fichiers .ckpt

appel[[diffusers.StableDiffusionLatentUpscalePipeline.call]]

__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, negative_prompt: str | list[str] | None = None, 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, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_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)

Source

Paramètres :

prompt (str ou list[str]) : Le prompt ou les prompts pour guider le redimensionnement de l'image.

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. S'il s'agit d'un tenseur, il peut s'agir soit d'une sortie latente d'un modèle Stable Diffusion, soit d'un tenseur d'image dans l'intervalle [-1, 1]. Il est considéré comme latent si image.shape[1] est 4 ; sinon, il est considéré comme une représentation d'image et encodé à l'aide de l'encodeur vae de ce pipeline.

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.

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

generator (torch.Generator ou list[torch.Generator], facultatif) : Un torch.Generator 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.

pooled_prompt_embeds (torch.Tensor, facultatif) : Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). S'il n'est pas fourni, les embeddings de texte sont générés à partir de l'argument d'entrée prompt.

negative_pooled_prompt_embeds (torch.Tensor, facultatif) : Embeddings de texte négatifs pré-générés et agrégés. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). S'ils ne sont pas fournis, les negative_prompt_embeds agrégés 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 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.

Retourne : StableDiffusionPipelineOutput ou tuple

Si return_dict est True, StableDiffusionPipelineOutput 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.

Exemples :

>>> from diffusers import StableDiffusionLatentUpscalePipeline, StableDiffusionPipeline
>>> import torch

>>> pipeline = StableDiffusionPipeline.from_pretrained(
...     "CompVis/stable-diffusion-v1-4", torch_dtype=torch.float16
... )
>>> pipeline.to("cuda")

>>> model_id = "stabilityai/sd-x2-latent-upscaler"
>>> upscaler = StableDiffusionLatentUpscalePipeline.from_pretrained(model_id, torch_dtype=torch.float16)
>>> upscaler.to("cuda")

>>> prompt = "a photo of an astronaut high resolution, unreal engine, ultra realistic"
>>> generator = torch.manual_seed(33)

>>> low_res_latents = pipeline(prompt, generator=generator, output_type="latent").images

>>> with torch.no_grad():
...     image = pipeline.decode_latents(low_res_latents)
>>> image = pipeline.numpy_to_pil(image)[0]

>>> image.save("../images/a1.png")

>>> upscaled_image = upscaler(
...     prompt=prompt,
...     image=low_res_latents,
...     num_inference_steps=20,
...     guidance_scale=0,
...     generator=generator,
... ).images[0]

>>> upscaled_image.save("../images/a2.png")

enable_sequential_cpu_offload[[diffusers.StableDiffusionLatentUpscalePipeline.enable_sequential_cpu_offload]]

enable_sequential_cpu_offload(gpu_id: int | None = None, device: typing.Union[torch.device, str] = None)

Source

Paramètres :

gpu_id (int, facultatif) : L'identifiant de l'accélérateur à utiliser pour l'inférence. S'il n'est pas spécifié, la valeur par défaut est 0.

device (torch.Device ou str, facultatif, par défaut None) : Le type d'appareil PyTorch de l'accélérateur à utiliser pour l'inférence. S'il n'est pas spécifié, l'accélérateur disponible sera détecté et utilisé automatiquement.

Décharge tous les modèles sur le CPU à l’aide de 🤗 Accelerate, réduisant ainsi considérablement l’utilisation de la mémoire. Lors de l’appel, les state dicts de tous les composants torch.nn.Module (à l’exception de ceux dans self._exclude_from_cpu_offload) sont enregistrés sur le CPU, puis déplacés vers torch.device('meta') et chargés sur l’accélérateur uniquement lorsque la méthode forward de leur sous-module spécifique est appelée. La décharge s’effectue au niveau des sous-modules. Les économies de mémoire sont supérieures à celles de enable_model_cpu_offload, mais les performances sont inférieures.

enable_attention_slicing[[diffusers.StableDiffusionLatentUpscalePipeline.enable_attention_slicing]]

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

Source

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.

> ⚠️ 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 :

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

disable_attention_slicing()

Source

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.StableDiffusionLatentUpscalePipeline.enable_xformers_memory_efficient_attention]]

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

Source

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() de xFormers.

Activer l’attention efficace en mémoire de 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.

> ⚠️ 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 :

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

disable_xformers_memory_efficient_attention()

Source

Désactiver l'attention efficace en mémoire de xFormers.

encode_prompt[[diffusers.StableDiffusionLatentUpscalePipeline.encode_prompt]]

encode_prompt(prompt, device, do_classifier_free_guidance, negative_prompt = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None)

Source

Paramètres :

prompt (str ou list(int)) : invite à encoder

device : (torch.device) : appareil torch

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

negative_prompt (str ou list[str]) : Le prompt ou les prompts à ne pas utiliser pour guider la génération de l'image. Ignoré lorsque la guidance n'est pas utilisée (c'est-à-dire ignoré si guidance_scale est inférieur à 1).

prompt_embeds (torch.FloatTensor, 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.FloatTensor, facultatif) : Incrustations de texte négatif pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, par ex. le pondération des prompts. Si non fourni, negative_prompt_embeds sera généré à partir de l'argument d'entrée negative_prompt.

pooled_prompt_embeds (torch.Tensor, facultatif) : Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, par ex. le pondération des prompts. S'il n'est pas fourni, les embeddings de texte seront générés à partir de l'argument d'entrée prompt.

negative_pooled_prompt_embeds (torch.Tensor, facultatif) : Embeddings de texte négatifs pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, par ex. le pondération des prompts. S'il n'est pas fourni, pooled negative_prompt_embeds sera généré à partir de l'argument d'entrée negative_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]]

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

Source

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.