Buckets:
# DeepFloyd IF
## Aperçu
DeepFloyd IF est un nouveau modèle open source de pointe de génération d'images à partir de texte, doté d'un haut degré de photoréalisme et de compréhension du langage. Le modèle est modulaire et se compose d'un encodeur de texte figé et de trois modules de diffusion de pixels en cascade :
- Étape 1 : un modèle de base qui génère une image de 64x64 px à partir d'un prompt texte,
- Étape 2 : un modèle de super-résolution 64x64 px => 256x256 px, et
- Étape 3 : un modèle de super-résolution 256x256 px => 1024x1024 px
Les étapes 1 et 2 utilisent un encodeur de texte figé basé sur le transformeur T5 pour extraire des embeddings de texte, qui sont ensuite injectés dans une architecture UNet enrichie d'attention croisée et de pooling d'attention. L'étape 3 est le [modèle de suréchantillonnage x4 de Stability AI](https://huggingface.co/stabilityai/stable-diffusion-x4-upscaler). Le résultat est un modèle très efficace qui surpasse les modèles de l'état de l'art actuels, atteignant un score FID zero-shot de 6,66 sur le jeu de données COCO. Notre travail souligne le potentiel des architectures UNet plus grandes dans la première étape des modèles de diffusion en cascade et esquisse un avenir prometteur pour la synthèse d'images à partir de texte.
## Utilisation
Avant de pouvoir utiliser IF, vous devez accepter ses conditions d’utilisation. Pour ce faire :
1. Assurez-vous de disposer d'un [compte Hugging Face](https://huggingface.co/join) et d'être connecté.
2. Acceptez la licence sur la carte du modèle de [DeepFloyd/IF-I-XL-v1.0](https://huggingface.co/DeepFloyd/IF-I-XL-v1.0). L’acceptation de la licence sur la carte du modèle de l’étape I entraîne l’acceptation automatique pour les autres modèles IF.
3. Assurez-vous de vous connecter localement. Installez `huggingface_hub` :
```sh
pip install huggingface_hub --upgrade
```
exécuter la fonction de connexion dans un shell Python :
```py
from huggingface_hub import login
login()
```
et saisissez votre [jeton d'accès Hugging Face Hub](https://huggingface.co/docs/hub/security-tokens#what-are-user-access-tokens).
Nous installons ensuite `diffusers` et les dépendances :
```sh
pip install -q diffusers accelerate transformers
```
Les sections suivantes présentent des exemples plus détaillés de l'utilisation de IF. Plus précisément :
- [Génération d'images à partir de texte](#text-to-image-generation)
- [Génération d'image à partir d'image](#text-guided-image-to-image-generation)
- [Inpainting](#text-guided-inpainting-generation)
- [Réutilisation des poids du modèle](#converting-between-different-pipelines)
- [Optimisation de la vitesse](#optimizing-for-speed)
- [Optimisation de la mémoire](#optimizing-for-memory)
**Points de contrôle disponibles**
- *Étape 1*
- [DeepFloyd/IF-I-XL-v1.0](https://huggingface.co/DeepFloyd/IF-I-XL-v1.0)
- [DeepFloyd/IF-I-L-v1.0](https://huggingface.co/DeepFloyd/IF-I-L-v1.0)
- [DeepFloyd/IF-I-M-v1.0](https://huggingface.co/DeepFloyd/IF-I-M-v1.0)
- *Étape 2*
- [DeepFloyd/IF-II-L-v1.0](https://huggingface.co/DeepFloyd/IF-II-L-v1.0)
- [DeepFloyd/IF-II-M-v1.0](https://huggingface.co/DeepFloyd/IF-II-M-v1.0)
- *Étape 3*
- [stabilityai/stable-diffusion-x4-upscaler](https://huggingface.co/stabilityai/stable-diffusion-x4-upscaler)
**Google Colab** [](https://colab.research.google.com/github/huggingface/notebooks/blob/main/diffusers/deepfloyd_if_free_tier_google_colab.ipynb)
### Génération d'images à partir de texte
Par défaut, diffusers utilise le [model cpu offloading](../../optimization/memory#model-offloading) pour exécuter l'ensemble du pipeline IF avec seulement 14 Go de VRAM.
```python
from diffusers import DiffusionPipeline
from diffusers.utils import pt_to_pil, make_image_grid
import torch
# stage 1
stage_1 = DiffusionPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0", variant="fp16", dtype=torch.float16)
stage_1.enable_model_cpu_offload()
# stage 2
stage_2 = DiffusionPipeline.from_pretrained(
"DeepFloyd/IF-II-L-v1.0", text_encoder=None, variant="fp16", dtype=torch.float16
)
stage_2.enable_model_cpu_offload()
# stage 3
safety_modules = {
"feature_extractor": stage_1.feature_extractor,
"safety_checker": stage_1.safety_checker,
"watermarker": stage_1.watermarker,
}
stage_3 = DiffusionPipeline.from_pretrained(
"stabilityai/stable-diffusion-x4-upscaler", **safety_modules, dtype=torch.float16
)
stage_3.enable_model_cpu_offload()
prompt = 'a photo of a kangaroo wearing an orange hoodie and blue sunglasses standing in front of the eiffel tower holding a sign that says "very deep learning"'
generator = torch.manual_seed(1)
# text embeds
prompt_embeds, negative_embeds = stage_1.encode_prompt(prompt)
# stage 1
stage_1_output = stage_1(
prompt_embeds=prompt_embeds, negative_prompt_embeds=negative_embeds, generator=generator, output_type="pt"
).images
#pt_to_pil(stage_1_output)[0].save("./if_stage_I.png")
# stage 2
stage_2_output = stage_2(
image=stage_1_output,
prompt_embeds=prompt_embeds,
negative_prompt_embeds=negative_embeds,
generator=generator,
output_type="pt",
).images
#pt_to_pil(stage_2_output)[0].save("./if_stage_II.png")
# stage 3
stage_3_output = stage_3(prompt=prompt, image=stage_2_output, noise_level=100, generator=generator).images
#stage_3_output[0].save("./if_stage_III.png")
make_image_grid([pt_to_pil(stage_1_output)[0], pt_to_pil(stage_2_output)[0], stage_3_output[0]], rows=1, rows=3)
```
### Génération d'image à partir d'image guidée par le texte
Les mêmes poids de modèle IF peuvent être utilisés pour la traduction d'image en image guidée par du texte ou pour la variation d'image. Dans ce cas, assurez-vous simplement de charger les poids en utilisant les pipelines [IFImg2ImgPipeline](/docs/diffusers/main/fr/api/pipelines/deepfloyd_if#diffusers.IFImg2ImgPipeline) et [IFImg2ImgSuperResolutionPipeline](/docs/diffusers/main/fr/api/pipelines/deepfloyd_if#diffusers.IFImg2ImgSuperResolutionPipeline).
**Note** : vous pouvez également déplacer directement les poids des pipelines texte-vers-image vers les pipelines image-vers-image sans les charger deux fois en utilisant l'argument [components](/docs/diffusers/main/fr/api/pipelines/overview#diffusers.DiffusionPipeline.components), comme expliqué [ici](#converting-between-different-pipelines).
```python
from diffusers import IFImg2ImgPipeline, IFImg2ImgSuperResolutionPipeline, DiffusionPipeline
from diffusers.utils import pt_to_pil, load_image, make_image_grid
import torch
# download image
url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg"
original_image = load_image(url)
original_image = original_image.resize((768, 512))
# stage 1
stage_1 = IFImg2ImgPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0", variant="fp16", dtype=torch.float16)
stage_1.enable_model_cpu_offload()
# stage 2
stage_2 = IFImg2ImgSuperResolutionPipeline.from_pretrained(
"DeepFloyd/IF-II-L-v1.0", text_encoder=None, variant="fp16", dtype=torch.float16
)
stage_2.enable_model_cpu_offload()
# stage 3
safety_modules = {
"feature_extractor": stage_1.feature_extractor,
"safety_checker": stage_1.safety_checker,
"watermarker": stage_1.watermarker,
}
stage_3 = DiffusionPipeline.from_pretrained(
"stabilityai/stable-diffusion-x4-upscaler", **safety_modules, dtype=torch.float16
)
stage_3.enable_model_cpu_offload()
prompt = "A fantasy landscape in style minecraft"
generator = torch.manual_seed(1)
# text embeds
prompt_embeds, negative_embeds = stage_1.encode_prompt(prompt)
# stage 1
stage_1_output = stage_1(
image=original_image,
prompt_embeds=prompt_embeds,
negative_prompt_embeds=negative_embeds,
generator=generator,
output_type="pt",
).images
#pt_to_pil(stage_1_output)[0].save("./if_stage_I.png")
# stage 2
stage_2_output = stage_2(
image=stage_1_output,
original_image=original_image,
prompt_embeds=prompt_embeds,
negative_prompt_embeds=negative_embeds,
generator=generator,
output_type="pt",
).images
#pt_to_pil(stage_2_output)[0].save("./if_stage_II.png")
# stage 3
stage_3_output = stage_3(prompt=prompt, image=stage_2_output, generator=generator, noise_level=100).images
#stage_3_output[0].save("./if_stage_III.png")
make_image_grid([original_image, pt_to_pil(stage_1_output)[0], pt_to_pil(stage_2_output)[0], stage_3_output[0]], rows=1, rows=4)
```
### Génération d'inpainting guidée par le texte
Les mêmes poids de modèle IF peuvent être utilisés pour la traduction image-à-image guidée par du texte ou la variation d’image. Dans ce cas, assurez-vous simplement de charger les poids à l’aide des pipelines [IFInpaintingPipeline](/docs/diffusers/main/fr/api/pipelines/deepfloyd_if#diffusers.IFInpaintingPipeline) et [IFInpaintingSuperResolutionPipeline](/docs/diffusers/main/fr/api/pipelines/deepfloyd_if#diffusers.IFInpaintingSuperResolutionPipeline).
**Note** : vous pouvez également déplacer directement les poids des pipelines texte-vers-image vers les pipelines image-vers-image sans les charger deux fois en utilisant la fonction `~DiffusionPipeline.components()`, comme expliqué [ici](#converting-between-different-pipelines).
```python
from diffusers import IFInpaintingPipeline, IFInpaintingSuperResolutionPipeline, DiffusionPipeline
from diffusers.utils import pt_to_pil, load_image, make_image_grid
import torch
# download image
url = "https://huggingface.co/datasets/diffusers/docs-images/resolve/main/if/person.png"
original_image = load_image(url)
# download mask
url = "https://huggingface.co/datasets/diffusers/docs-images/resolve/main/if/glasses_mask.png"
mask_image = load_image(url)
# stage 1
stage_1 = IFInpaintingPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0", variant="fp16", dtype=torch.float16)
stage_1.enable_model_cpu_offload()
# stage 2
stage_2 = IFInpaintingSuperResolutionPipeline.from_pretrained(
"DeepFloyd/IF-II-L-v1.0", text_encoder=None, variant="fp16", dtype=torch.float16
)
stage_2.enable_model_cpu_offload()
# stage 3
safety_modules = {
"feature_extractor": stage_1.feature_extractor,
"safety_checker": stage_1.safety_checker,
"watermarker": stage_1.watermarker,
}
stage_3 = DiffusionPipeline.from_pretrained(
"stabilityai/stable-diffusion-x4-upscaler", **safety_modules, dtype=torch.float16
)
stage_3.enable_model_cpu_offload()
prompt = "blue sunglasses"
generator = torch.manual_seed(1)
# text embeds
prompt_embeds, negative_embeds = stage_1.encode_prompt(prompt)
# stage 1
stage_1_output = stage_1(
image=original_image,
mask_image=mask_image,
prompt_embeds=prompt_embeds,
negative_prompt_embeds=negative_embeds,
generator=generator,
output_type="pt",
).images
#pt_to_pil(stage_1_output)[0].save("./if_stage_I.png")
# stage 2
stage_2_output = stage_2(
image=stage_1_output,
original_image=original_image,
mask_image=mask_image,
prompt_embeds=prompt_embeds,
negative_prompt_embeds=negative_embeds,
generator=generator,
output_type="pt",
).images
#pt_to_pil(stage_1_output)[0].save("./if_stage_II.png")
# stage 3
stage_3_output = stage_3(prompt=prompt, image=stage_2_output, generator=generator, noise_level=100).images
#stage_3_output[0].save("./if_stage_III.png")
make_image_grid([original_image, mask_image, pt_to_pil(stage_1_output)[0], pt_to_pil(stage_2_output)[0], stage_3_output[0]], rows=1, rows=5)
```
### Conversion entre différents pipelines
En plus d’être chargées avec `from_pretrained`, les Pipelines peuvent également être chargées directement les unes à partir des autres.
```python
from diffusers import IFPipeline, IFSuperResolutionPipeline
pipe_1 = IFPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0")
pipe_2 = IFSuperResolutionPipeline.from_pretrained("DeepFloyd/IF-II-L-v1.0")
from diffusers import IFImg2ImgPipeline, IFImg2ImgSuperResolutionPipeline
pipe_1 = IFImg2ImgPipeline(**pipe_1.components)
pipe_2 = IFImg2ImgSuperResolutionPipeline(**pipe_2.components)
from diffusers import IFInpaintingPipeline, IFInpaintingSuperResolutionPipeline
pipe_1 = IFInpaintingPipeline(**pipe_1.components)
pipe_2 = IFInpaintingSuperResolutionPipeline(**pipe_2.components)
```
### Optimisation pour la vitesse
L'optimisation la plus simple pour exécuter IF plus rapidement consiste à déplacer tous les composants du modèle sur le GPU.
```py
pipe = DiffusionPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0", variant="fp16", dtype=torch.float16)
pipe.to("cuda") # or "mps", "xpu", "cpu"
```
Vous pouvez également exécuter le processus de diffusion sur un nombre réduit d'étapes.
Cela peut être fait avec l'argument `num_inference_steps` :
```py
pipe("<prompt>", num_inference_steps=30)
```
En revanche, avec l'argument `timesteps` :
```py
from diffusers.pipelines.deepfloyd_if import fast27_timesteps
pipe("<prompt>", timesteps=fast27_timesteps)
```
Lors de la variation d'image ou de l'inpainting, vous pouvez également réduire le nombre de timesteps à l'aide de l'argument strength. L'argument strength correspond à la quantité de bruit à ajouter à l'image d'entrée, ce qui détermine également le nombre d'étapes à exécuter dans le processus de débruitage. Une valeur plus faible modifie moins l'image, mais s'exécute plus rapidement.
```py
pipe = IFImg2ImgPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0", variant="fp16", dtype=torch.float16)
pipe.to("cuda") # or "mps", "xpu", "cpu"
image = pipe(image=image, prompt="<prompt>", strength=0.3).images
```
Vous pouvez également utiliser [`torch.compile`](../../optimization/fp16#torchcompile). Notez que nous n'avons pas testé `torch.compile` de manière exhaustive avec IF et qu'il est possible qu'il ne donne pas les résultats attendus.
```py
from diffusers import DiffusionPipeline
import torch
pipe = DiffusionPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0", variant="fp16", dtype=torch.float16)
pipe.to("cuda") # or "mps", "xpu", "cpu"
pipe.text_encoder = torch.compile(pipe.text_encoder, mode="reduce-overhead", fullgraph=True)
pipe.unet = torch.compile(pipe.unet, mode="reduce-overhead", fullgraph=True)
```
### Optimisation de la mémoire
Lors de l’optimisation de la mémoire GPU, nous pouvons utiliser les API standard de déchargement sur CPU de diffusers.
Soit le déchargement sur CPU basé sur le modèle,
```py
pipe = DiffusionPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0", variant="fp16", dtype=torch.float16)
pipe.enable_model_cpu_offload()
```
ou le déchargement sur CPU par couche plus agressif.
```py
pipe = DiffusionPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0", variant="fp16", dtype=torch.float16)
pipe.enable_sequential_cpu_offload()
```
De plus, T5 peut être chargé en précision 8 bits
```py
from transformers import T5EncoderModel
text_encoder = T5EncoderModel.from_pretrained(
"DeepFloyd/IF-I-XL-v1.0", subfolder="text_encoder", device_map="auto", load_in_8bit=True, variant="8bit"
)
from diffusers import DiffusionPipeline
pipe = DiffusionPipeline.from_pretrained(
"DeepFloyd/IF-I-XL-v1.0",
text_encoder=text_encoder, # pass the previously instantiated 8bit text encoder
unet=None,
device_map="auto",
)
prompt_embeds, negative_embeds = pipe.encode_prompt("<prompt>")
```
Pour les machines à mémoire RAM CPU limitée, comme le niveau gratuit de Google Colab, où il est impossible de charger tous les composants du modèle sur le CPU en une seule fois, nous pouvons charger manuellement le pipeline uniquement avec l’encodeur de texte ou le UNet lorsque les composants de modèle respectifs sont nécessaires.
```py
from diffusers import IFPipeline, IFSuperResolutionPipeline
import torch
import gc
from transformers import T5EncoderModel
from diffusers.utils import pt_to_pil, make_image_grid
text_encoder = T5EncoderModel.from_pretrained(
"DeepFloyd/IF-I-XL-v1.0", subfolder="text_encoder", device_map="auto", load_in_8bit=True, variant="8bit"
)
# text to image
pipe = DiffusionPipeline.from_pretrained(
"DeepFloyd/IF-I-XL-v1.0",
text_encoder=text_encoder, # pass the previously instantiated 8bit text encoder
unet=None,
device_map="auto",
)
prompt = 'a photo of a kangaroo wearing an orange hoodie and blue sunglasses standing in front of the eiffel tower holding a sign that says "very deep learning"'
prompt_embeds, negative_embeds = pipe.encode_prompt(prompt)
# Remove the pipeline so we can re-load the pipeline with the unet
del text_encoder
del pipe
gc.collect()
torch.cuda.empty_cache()
pipe = IFPipeline.from_pretrained(
"DeepFloyd/IF-I-XL-v1.0", text_encoder=None, variant="fp16", dtype=torch.float16, device_map="auto"
)
generator = torch.Generator().manual_seed(0)
stage_1_output = pipe(
prompt_embeds=prompt_embeds,
negative_prompt_embeds=negative_embeds,
output_type="pt",
generator=generator,
).images
#pt_to_pil(stage_1_output)[0].save("./if_stage_I.png")
# Remove the pipeline so we can load the super-resolution pipeline
del pipe
gc.collect()
torch.cuda.empty_cache()
# First super resolution
pipe = IFSuperResolutionPipeline.from_pretrained(
"DeepFloyd/IF-II-L-v1.0", text_encoder=None, variant="fp16", dtype=torch.float16, device_map="auto"
)
generator = torch.Generator().manual_seed(0)
stage_2_output = pipe(
image=stage_1_output,
prompt_embeds=prompt_embeds,
negative_prompt_embeds=negative_embeds,
output_type="pt",
generator=generator,
).images
#pt_to_pil(stage_2_output)[0].save("./if_stage_II.png")
make_image_grid([pt_to_pil(stage_1_output)[0], pt_to_pil(stage_2_output)[0]], rows=1, rows=2)
```
## Pipelines disponibles :
| Pipeline | Tâches | Colab
|---|---|:---:|
| [pipeline_if.py](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/deepfloyd_if/pipeline_if.py) | *Génération d'images à partir de texte* | - |
| [pipeline_if_superresolution.py](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/deepfloyd_if/pipeline_if_superresolution.py) | *Génération d'images à partir de texte* | - |
| [pipeline_if_img2img.py](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/deepfloyd_if/pipeline_if_img2img.py) | *Génération d'image à partir d'image* | - |
| [pipeline_if_img2img_superresolution.py](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/deepfloyd_if/pipeline_if_img2img_superresolution.py) | *Génération d'image à partir d'image* | - |
| [pipeline_if_inpainting.py](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/deepfloyd_if/pipeline_if_inpainting.py) | *Génération d'image à partir d'image* | - |
| [pipeline_if_inpainting_superresolution.py](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/deepfloyd_if/pipeline_if_inpainting_superresolution.py) | *Génération d'image à partir d'image* | - |
## IFPipeline[[diffusers.IFPipeline]]
#### diffusers.IFPipeline[[diffusers.IFPipeline]]
```python
diffusers.IFPipeline(tokenizer: T5Tokenizer, text_encoder: T5EncoderModel, unet: UNet2DConditionModel, scheduler: DDPMScheduler, safety_checker: diffusers.pipelines.deepfloyd_if.safety_checker.IFSafetyChecker | None, feature_extractor: transformers.models.clip.image_processing_pil_clip.CLIPImageProcessorPil | None, watermarker: diffusers.pipelines.deepfloyd_if.watermark.IFWatermarker | None, requires_safety_checker: bool = True)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/deepfloyd_if/pipeline_if.py#L96)
#### __appel__[[diffusers.IFPipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, num_inference_steps: int = 100, timesteps: list[int] = None, guidance_scale: float = 7.0, negative_prompt: str | list[str] | None = None, num_images_per_prompt: int | None = 1, height: int | None = None, width: int | None = None, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = 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, clean_caption: bool = True, cross_attention_kwargs: dict[str, typing.Any] | None = None)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/deepfloyd_if/pipeline_if.py#L547)
**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, il faut passer `prompt_embeds` à la place.
num_inference_steps (`int`, *facultatif*, valeur par défaut 100) : Le nombre d'étapes de débruitage. Un plus grand nombre d'étapes de débruitage conduit généralement à une image de meilleure qualité, au prix d'une inférence plus lente.
timesteps (`list[int]`, *facultatif*) : Étapes de temps personnalisées à utiliser pour le processus de débruitage. Si non définies, des étapes de temps `num_inference_steps` équidistantes sont utilisées. Doivent être dans l'ordre décroissant.
guidance_scale (`float`, *facultatif*, valeur par défaut 7.0) : Échelle de guidage telle que définie dans [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` est défini comme `w` de l'équation 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). L'échelle de guidage est activée en définissant `guidance_scale > 1`. Une échelle de guidage plus élevée encourage la génération d'images étroitement liées au `prompt` texte, généralement au détriment de la qualité de l'image.
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`).
num_images_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre d'images à générer par invite.
height (`int`, *facultatif*, par défaut self.unet.config.sample_size) : La hauteur en pixels de l'image générée.
width (`int`, *facultatif*, par défaut self.unet.config.sample_size) : La largeur en pixels de l'image générée.
eta (`float`, *facultatif*, valeur par défaut 0.0) : Correspond au paramètre eta (η) du papier DDIM : https://huggingface.co/papers/2010.02502. S'applique uniquement à [schedulers.DDIMScheduler](/docs/diffusers/main/fr/api/schedulers/ddim#diffusers.DDIMScheduler), sera ignoré pour les autres.
generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Un ou une liste de [générateurs torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) pour rendre la génération déterministe.
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`.
output_type (`str`, *facultatif*, par défaut `"pil"`) : Le format de sortie de l'image générée. Choisissez entre [PIL](https://pillow.readthedocs.io/en/stable/) : `PIL.Image.Image` ou `np.array`.
return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `~pipelines.stable_diffusion.IFPipelineOutput` plutôt qu'un simple tuple.
callback (`Callable`, *facultatif*) : une fonction qui sera appelée toutes les `callback_steps` étapes pendant l'inférence. La fonction sera 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` sera appelée. Si non spécifié, le callback sera appelé à chaque étape.
clean_caption (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut nettoyer la légende avant de créer les embeddings. Nécessite l'installation de `beautifulsoup4` et `ftfy`. Si les dépendances ne sont pas installées, les embeddings seront créés à partir du prompt brut.
cross_attention_kwargs (`dict`, *facultatif*) : Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'`AttentionProcessor` tel que défini sous `self.processor` dans [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
**Retourne :** `~pipelines.stable_diffusion.IFPipelineOutput` ou `tuple`
`~pipelines.stable_diffusion.IFPipelineOutput` if `return_dict` is True, otherwise a `tuple. When returning a tuple, the first element is a list with the generated images, and the second element is a list of `bool`s denoting whether the corresponding generated image likely represents "not-safe-for-work" (nsfw) or watermarked content, according to the `safety_checker`.
Fonction appelée lors de l'appel du pipeline pour la génération.
Exemples :
```py
>>> from diffusers import IFPipeline, IFSuperResolutionPipeline, DiffusionPipeline
>>> from diffusers.utils import pt_to_pil
>>> import torch
>>> pipe = IFPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0", variant="fp16", torch_dtype=torch.float16)
>>> pipe.enable_model_cpu_offload()
>>> prompt = 'a photo of a kangaroo wearing an orange hoodie and blue sunglasses standing in front of the eiffel tower holding a sign that says "very deep learning"'
>>> prompt_embeds, negative_embeds = pipe.encode_prompt(prompt)
>>> image = pipe(prompt_embeds=prompt_embeds, negative_prompt_embeds=negative_embeds, output_type="pt").images
>>> # save intermediate image
>>> pil_image = pt_to_pil(image)
>>> pil_image[0].save("./if_stage_I.png")
>>> super_res_1_pipe = IFSuperResolutionPipeline.from_pretrained(
... "DeepFloyd/IF-II-L-v1.0", text_encoder=None, variant="fp16", torch_dtype=torch.float16
... )
>>> super_res_1_pipe.enable_model_cpu_offload()
>>> image = super_res_1_pipe(
... image=image, prompt_embeds=prompt_embeds, negative_prompt_embeds=negative_embeds, output_type="pt"
... ).images
>>> # save intermediate image
>>> pil_image = pt_to_pil(image)
>>> pil_image[0].save("./if_stage_I.png")
>>> safety_modules = {
... "feature_extractor": pipe.feature_extractor,
... "safety_checker": pipe.safety_checker,
... "watermarker": pipe.watermarker,
... }
>>> super_res_2_pipe = DiffusionPipeline.from_pretrained(
... "stabilityai/stable-diffusion-x4-upscaler", **safety_modules, torch_dtype=torch.float16
... )
>>> super_res_2_pipe.enable_model_cpu_offload()
>>> image = super_res_2_pipe(
... prompt=prompt,
... image=image,
... ).images
>>> image[0].save("./if_stage_II.png")
```
#### encode_prompt[[diffusers.IFPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], do_classifier_free_guidance: bool = True, num_images_per_prompt: int = 1, device: typing.Optional[torch.device] = None, negative_prompt: str | list[str] | None = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, clean_caption: bool = False)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/deepfloyd_if/pipeline_if.py#L168)
**Paramètres :**
prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder
do_classifier_free_guidance (`bool`, *facultatif*, par défaut `True`) : indique s'il faut utiliser le guidage sans classifieur ou non
num_images_per_prompt (`int`, *facultatif*, valeur par défaut 1) : nombre d'images à générer par invite
device : (`torch.device`, *facultatif*) : le torch device sur lequel placer les embeddings résultants
negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération de l'image. S'il n'est pas défini, il faut passer `negative_prompt_embeds` à la place. 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`.
clean_caption (bool, par défaut `False`) : Si `True`, la fonction prétraite et nettoie la légende fournie avant l'encodage.
Encode le prompt dans les états cachés de l'encodeur de texte.
## IFSuperResolutionPipeline[[diffusers.IFSuperResolutionPipeline]]
#### diffusers.IFSuperResolutionPipeline[[diffusers.IFSuperResolutionPipeline]]
```python
diffusers.IFSuperResolutionPipeline(tokenizer: T5Tokenizer, text_encoder: T5EncoderModel, unet: UNet2DConditionModel, scheduler: DDPMScheduler, image_noising_scheduler: DDPMScheduler, safety_checker: diffusers.pipelines.deepfloyd_if.safety_checker.IFSafetyChecker | None, feature_extractor: transformers.models.clip.image_processing_pil_clip.CLIPImageProcessorPil | None, watermarker: diffusers.pipelines.deepfloyd_if.watermark.IFWatermarker | None, requires_safety_checker: bool = True)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/deepfloyd_if/pipeline_if_superresolution.py#L82)
#### __appel__[[diffusers.IFSuperResolutionPipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, height: int = None, width: int = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor] = None, num_inference_steps: int = 50, timesteps: list[int] = None, guidance_scale: float = 4.0, 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, 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 = 250, clean_caption: bool = True)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/deepfloyd_if/pipeline_if_superresolution.py#L614)
**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, il faut passer `prompt_embeds` à la place.
height (`int`, *facultatif*, valeur par défaut None) : La hauteur en pixels de l'image générée.
width (`int`, *facultatif*, valeur par défaut None) : La largeur en pixels de l'image générée.
image (`PIL.Image.Image`, `np.ndarray`, `torch.Tensor`) : L'image à 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.
timesteps (`list[int]`, *facultatif*, valeur par défaut None) : Étapes de temps personnalisées à utiliser pour le processus de débruitage. Si non définies, des étapes de temps `num_inference_steps` équidistantes sont utilisées. Doivent être dans un ordre décroissant.
guidance_scale (`float`, *facultatif*, valeur par défaut 4.0) : Échelle de guidage telle que définie dans [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` est défini comme `w` de l'équation 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). L'échelle de guidage est activée en définissant `guidance_scale > 1`. Une échelle de guidage plus élevée encourage la génération d'images étroitement liées au `prompt` texte, généralement au détriment de la qualité de l'image.
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`).
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 (η) du papier DDIM : https://huggingface.co/papers/2010.02502. S'applique uniquement à [schedulers.DDIMScheduler](/docs/diffusers/main/fr/api/schedulers/ddim#diffusers.DDIMScheduler), sera ignoré pour les autres.
generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Un ou une liste de [générateurs torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) pour rendre la génération déterministe.
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`.
output_type (`str`, *facultatif*, par défaut `"pil"`) : Le format de sortie de l'image générée. Choisissez entre [PIL](https://pillow.readthedocs.io/en/stable/) : `PIL.Image.Image` ou `np.array`.
return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `~pipelines.stable_diffusion.IFPipelineOutput` plutôt qu'un simple tuple.
callback (`Callable`, *facultatif*) : une fonction qui sera appelée toutes les `callback_steps` étapes pendant l'inférence. La fonction sera 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` sera appelée. Si non spécifié, le callback sera 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 sous `self.processor` dans [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
noise_level (`int`, *facultatif*, valeur par défaut 250) : La quantité de bruit à ajouter à l'image agrandie. Doit être comprise dans l'intervalle `[0, 1000)`
clean_caption (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut nettoyer la légende avant de créer les embeddings. Nécessite l'installation de `beautifulsoup4` et `ftfy`. Si les dépendances ne sont pas installées, les embeddings seront créés à partir du prompt brut.
**Retourne :** `~pipelines.stable_diffusion.IFPipelineOutput` ou `tuple`
`~pipelines.stable_diffusion.IFPipelineOutput` if `return_dict` is True, otherwise a `tuple. When returning a tuple, the first element is a list with the generated images, and the second element is a list of `bool`s denoting whether the corresponding generated image likely represents "not-safe-for-work" (nsfw) or watermarked content, according to the `safety_checker`.
Fonction appelée lors de l'appel du pipeline pour la génération.
Exemples :
```py
>>> from diffusers import IFPipeline, IFSuperResolutionPipeline, DiffusionPipeline
>>> from diffusers.utils import pt_to_pil
>>> import torch
>>> pipe = IFPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0", variant="fp16", torch_dtype=torch.float16)
>>> pipe.enable_model_cpu_offload()
>>> prompt = 'a photo of a kangaroo wearing an orange hoodie and blue sunglasses standing in front of the eiffel tower holding a sign that says "very deep learning"'
>>> prompt_embeds, negative_embeds = pipe.encode_prompt(prompt)
>>> image = pipe(prompt_embeds=prompt_embeds, negative_prompt_embeds=negative_embeds, output_type="pt").images
>>> # save intermediate image
>>> pil_image = pt_to_pil(image)
>>> pil_image[0].save("./if_stage_I.png")
>>> super_res_1_pipe = IFSuperResolutionPipeline.from_pretrained(
... "DeepFloyd/IF-II-L-v1.0", text_encoder=None, variant="fp16", torch_dtype=torch.float16
... )
>>> super_res_1_pipe.enable_model_cpu_offload()
>>> image = super_res_1_pipe(
... image=image, prompt_embeds=prompt_embeds, negative_prompt_embeds=negative_embeds
... ).images
>>> image[0].save("./if_stage_II.png")
```
#### encode_prompt[[diffusers.IFSuperResolutionPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], do_classifier_free_guidance: bool = True, num_images_per_prompt: int = 1, device: typing.Optional[torch.device] = None, negative_prompt: str | list[str] | None = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, clean_caption: bool = False)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/deepfloyd_if/pipeline_if_superresolution.py#L302)
**Paramètres :**
prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder
do_classifier_free_guidance (`bool`, *facultatif*, par défaut `True`) : indique s'il faut utiliser le guidage sans classifieur ou non
num_images_per_prompt (`int`, *facultatif*, valeur par défaut 1) : nombre d'images à générer par invite
device : (`torch.device`, *facultatif*) : le torch device sur lequel placer les embeddings résultants
negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération de l'image. S'il n'est pas défini, il faut passer `negative_prompt_embeds` à la place. 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`.
clean_caption (bool, par défaut `False`) : Si `True`, la fonction prétraite et nettoie la légende fournie avant l'encodage.
Encode le prompt dans les états cachés de l'encodeur de texte.
## IFImg2ImgPipeline[[diffusers.IFImg2ImgPipeline]]
#### diffusers.IFImg2ImgPipeline[[diffusers.IFImg2ImgPipeline]]
```python
diffusers.IFImg2ImgPipeline(tokenizer: T5Tokenizer, text_encoder: T5EncoderModel, unet: UNet2DConditionModel, scheduler: DDPMScheduler, safety_checker: diffusers.pipelines.deepfloyd_if.safety_checker.IFSafetyChecker | None, feature_extractor: transformers.models.clip.image_processing_pil_clip.CLIPImageProcessorPil | None, watermarker: diffusers.pipelines.deepfloyd_if.watermark.IFWatermarker | None, requires_safety_checker: bool = True)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/deepfloyd_if/pipeline_if_img2img.py#L120)
#### __appel__[[diffusers.IFImg2ImgPipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, image: typing.Union[PIL.Image.Image, torch.Tensor, numpy.ndarray, list[PIL.Image.Image], list[torch.Tensor], list[numpy.ndarray]] = None, strength: float = 0.7, num_inference_steps: int = 80, timesteps: list[int] = None, 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.Union[torch.Generator, list[torch.Generator], NoneType] = 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, clean_caption: bool = True, cross_attention_kwargs: dict[str, typing.Any] | None = None)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/deepfloyd_if/pipeline_if_img2img.py#L661)
**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, il faut passer `prompt_embeds` à la place.
image (`torch.Tensor` ou `PIL.Image.Image`) : `Image`, ou tenseur représentant un lot d'images, qui servira de point de départ au processus.
strength (`float`, *facultatif*, valeur par défaut 0,7) : Indique conceptuellement dans quelle mesure transformer l'`image` de référence. Doit être compris entre 0 et 1. `image` sera utilisée comme point de départ, en y ajoutant davantage de bruit à mesure que `strength` augmente. Le nombre d'étapes de débruitage dépend de la quantité de bruit initialement ajoutée. Lorsque `strength` vaut 1, le bruit ajouté sera maximal et le processus de débruitage s'exécutera pendant le nombre complet d'itérations spécifié dans `num_inference_steps`. Une valeur de 1 ignore donc essentiellement `image`.
num_inference_steps (`int`, *facultatif*, valeur par défaut 80) : 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.
timesteps (`list[int]`, *facultatif*) : Étapes de temps personnalisées à utiliser pour le processus de débruitage. Si non définies, des étapes de temps `num_inference_steps` équidistantes sont utilisées. Doivent être dans l'ordre décroissant.
guidance_scale (`float`, *facultatif*, valeur par défaut 10.0) : Échelle de guidage telle que définie dans [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` est défini comme `w` de l'équation 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). L'échelle de guidage est activée en définissant `guidance_scale > 1`. Une échelle de guidage plus élevée encourage la génération d'images étroitement liées au `prompt` texte, généralement au détriment de la qualité de l'image.
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`).
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 (η) du papier DDIM : https://huggingface.co/papers/2010.02502. S'applique uniquement à [schedulers.DDIMScheduler](/docs/diffusers/main/fr/api/schedulers/ddim#diffusers.DDIMScheduler), sera ignoré pour les autres.
generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Un ou une liste de [générateurs torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) pour rendre la génération déterministe.
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`.
output_type (`str`, *facultatif*, par défaut `"pil"`) : Le format de sortie de l'image générée. Choisissez entre [PIL](https://pillow.readthedocs.io/en/stable/) : `PIL.Image.Image` ou `np.array`.
return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `~pipelines.stable_diffusion.IFPipelineOutput` plutôt qu'un simple tuple.
callback (`Callable`, *facultatif*) : une fonction qui sera appelée toutes les `callback_steps` étapes pendant l'inférence. La fonction sera 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` sera appelée. Si non spécifié, le callback sera appelé à chaque étape.
clean_caption (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut nettoyer la légende avant de créer les embeddings. Nécessite l'installation de `beautifulsoup4` et `ftfy`. Si les dépendances ne sont pas installées, les embeddings seront créés à partir du prompt brut.
cross_attention_kwargs (`dict`, *facultatif*) : Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'`AttentionProcessor` tel que défini sous `self.processor` dans [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
**Retourne :** `~pipelines.stable_diffusion.IFPipelineOutput` ou `tuple`
`~pipelines.stable_diffusion.IFPipelineOutput` if `return_dict` is True, otherwise a `tuple. When returning a tuple, the first element is a list with the generated images, and the second element is a list of `bool`s denoting whether the corresponding generated image likely represents "not-safe-for-work" (nsfw) or watermarked content, according to the `safety_checker`.
Fonction appelée lors de l'appel du pipeline pour la génération.
Exemples :
```py
>>> from diffusers import IFImg2ImgPipeline, IFImg2ImgSuperResolutionPipeline, DiffusionPipeline
>>> from diffusers.utils import pt_to_pil
>>> import torch
>>> from PIL import Image
>>> import requests
>>> from io import BytesIO
>>> url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg"
>>> response = requests.get(url)
>>> original_image = Image.open(BytesIO(response.content)).convert("RGB")
>>> original_image = original_image.resize((768, 512))
>>> pipe = IFImg2ImgPipeline.from_pretrained(
... "DeepFloyd/IF-I-XL-v1.0",
... variant="fp16",
... torch_dtype=torch.float16,
... )
>>> pipe.enable_model_cpu_offload()
>>> prompt = "A fantasy landscape in style minecraft"
>>> prompt_embeds, negative_embeds = pipe.encode_prompt(prompt)
>>> image = pipe(
... image=original_image,
... prompt_embeds=prompt_embeds,
... negative_prompt_embeds=negative_embeds,
... output_type="pt",
... ).images
>>> # save intermediate image
>>> pil_image = pt_to_pil(image)
>>> pil_image[0].save("./if_stage_I.png")
>>> super_res_1_pipe = IFImg2ImgSuperResolutionPipeline.from_pretrained(
... "DeepFloyd/IF-II-L-v1.0",
... text_encoder=None,
... variant="fp16",
... torch_dtype=torch.float16,
... )
>>> super_res_1_pipe.enable_model_cpu_offload()
>>> image = super_res_1_pipe(
... image=image,
... original_image=original_image,
... prompt_embeds=prompt_embeds,
... negative_prompt_embeds=negative_embeds,
... ).images
>>> image[0].save("./if_stage_II.png")
```
#### encode_prompt[[diffusers.IFImg2ImgPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], do_classifier_free_guidance: bool = True, num_images_per_prompt: int = 1, device: typing.Optional[torch.device] = None, negative_prompt: str | list[str] | None = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, clean_caption: bool = False)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/deepfloyd_if/pipeline_if_img2img.py#L192)
**Paramètres :**
prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder
do_classifier_free_guidance (`bool`, *facultatif*, par défaut `True`) : indique s'il faut utiliser le guidage sans classifieur ou non
num_images_per_prompt (`int`, *facultatif*, valeur par défaut 1) : nombre d'images à générer par invite
device : (`torch.device`, *facultatif*) : le torch device sur lequel placer les embeddings résultants
negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération de l'image. S'il n'est pas défini, il faut passer `negative_prompt_embeds` à la place. 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`.
clean_caption (bool, par défaut `False`) : Si `True`, la fonction prétraite et nettoie la légende fournie avant l'encodage.
Encode le prompt dans les états cachés de l'encodeur de texte.
## IFImg2ImgSuperResolutionPipeline[[diffusers.IFImg2ImgSuperResolutionPipeline]]
#### diffusers.IFImg2ImgSuperResolutionPipeline[[diffusers.IFImg2ImgSuperResolutionPipeline]]
```python
diffusers.IFImg2ImgSuperResolutionPipeline(tokenizer: T5Tokenizer, text_encoder: T5EncoderModel, unet: UNet2DConditionModel, scheduler: DDPMScheduler, image_noising_scheduler: DDPMScheduler, safety_checker: diffusers.pipelines.deepfloyd_if.safety_checker.IFSafetyChecker | None, feature_extractor: transformers.models.clip.image_processing_pil_clip.CLIPImageProcessorPil | None, watermarker: diffusers.pipelines.deepfloyd_if.watermark.IFWatermarker | None, requires_safety_checker: bool = True)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/deepfloyd_if/pipeline_if_img2img_superresolution.py#L124)
#### __appel__[[diffusers.IFImg2ImgSuperResolutionPipeline.__call__]]
```python
__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor], original_image: typing.Union[PIL.Image.Image, torch.Tensor, numpy.ndarray, list[PIL.Image.Image], list[torch.Tensor], list[numpy.ndarray]] = None, strength: float = 0.8, prompt: str | list[str] = None, num_inference_steps: int = 50, timesteps: list[int] = None, guidance_scale: float = 4.0, 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, 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 = 250, clean_caption: bool = True)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/deepfloyd_if/pipeline_if_img2img_superresolution.py#L744)
**Paramètres :**
image (`torch.Tensor` ou `PIL.Image.Image`) : `Image`, ou tenseur représentant un lot d'images, qui servira de point de départ au processus.
original_image (`torch.Tensor` ou `PIL.Image.Image`) : L'image originale à partir de laquelle `image` a été modifiée.
strength (`float`, *facultatif*, valeur par défaut 0.8) : Indique conceptuellement dans quelle mesure transformer l'`image` de référence. Doit être compris entre 0 et 1. `image` sera utilisée comme point de départ, en y ajoutant davantage de bruit à mesure que `strength` augmente. Le nombre d'étapes de débruitage dépend de la quantité de bruit initialement ajoutée. Lorsque `strength` vaut 1, le bruit ajouté sera maximal et le processus de débruitage s'exécutera pendant le nombre complet d'itérations spécifié dans `num_inference_steps`. Une valeur de 1 ignore donc essentiellement `image`.
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, il faut passer `prompt_embeds` à la place.
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.
timesteps (`list[int]`, *facultatif*) : Étapes de temps personnalisées à utiliser pour le processus de débruitage. Si non définies, des étapes de temps `num_inference_steps` équidistantes sont utilisées. Doivent être dans l'ordre décroissant.
guidance_scale (`float`, *facultatif*, valeur par défaut 4.0) : Échelle de guidage telle que définie dans [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` est défini comme `w` de l'équation 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). L'échelle de guidage est activée en définissant `guidance_scale > 1`. Une échelle de guidage plus élevée encourage la génération d'images étroitement liées au `prompt` texte, généralement au détriment de la qualité de l'image.
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`).
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 (η) du papier DDIM : https://huggingface.co/papers/2010.02502. S'applique uniquement à [schedulers.DDIMScheduler](/docs/diffusers/main/fr/api/schedulers/ddim#diffusers.DDIMScheduler), sera ignoré pour les autres.
generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Un ou une liste de [générateurs torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) pour rendre la génération déterministe.
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`.
output_type (`str`, *facultatif*, par défaut `"pil"`) : Le format de sortie de l'image générée. Choisissez entre [PIL](https://pillow.readthedocs.io/en/stable/) : `PIL.Image.Image` ou `np.array`.
return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `~pipelines.stable_diffusion.IFPipelineOutput` plutôt qu'un simple tuple.
callback (`Callable`, *facultatif*) : une fonction qui sera appelée toutes les `callback_steps` étapes pendant l'inférence. La fonction sera 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` sera appelée. Si non spécifié, le callback sera 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 sous `self.processor` dans [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
noise_level (`int`, *facultatif*, valeur par défaut 250) : La quantité de bruit à ajouter à l'image agrandie. Doit être comprise dans l'intervalle `[0, 1000)`
clean_caption (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut nettoyer la légende avant de créer les embeddings. Nécessite l'installation de `beautifulsoup4` et `ftfy`. Si les dépendances ne sont pas installées, les embeddings seront créés à partir du prompt brut.
**Retourne :** `~pipelines.stable_diffusion.IFPipelineOutput` ou `tuple`
`~pipelines.stable_diffusion.IFPipelineOutput` if `return_dict` is True, otherwise a `tuple. When returning a tuple, the first element is a list with the generated images, and the second element is a list of `bool`s denoting whether the corresponding generated image likely represents "not-safe-for-work" (nsfw) or watermarked content, according to the `safety_checker`.
Fonction appelée lors de l'appel du pipeline pour la génération.
Exemples :
```py
>>> from diffusers import IFImg2ImgPipeline, IFImg2ImgSuperResolutionPipeline, DiffusionPipeline
>>> from diffusers.utils import pt_to_pil
>>> import torch
>>> from PIL import Image
>>> import requests
>>> from io import BytesIO
>>> url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg"
>>> response = requests.get(url)
>>> original_image = Image.open(BytesIO(response.content)).convert("RGB")
>>> original_image = original_image.resize((768, 512))
>>> pipe = IFImg2ImgPipeline.from_pretrained(
... "DeepFloyd/IF-I-XL-v1.0",
... variant="fp16",
... torch_dtype=torch.float16,
... )
>>> pipe.enable_model_cpu_offload()
>>> prompt = "A fantasy landscape in style minecraft"
>>> prompt_embeds, negative_embeds = pipe.encode_prompt(prompt)
>>> image = pipe(
... image=original_image,
... prompt_embeds=prompt_embeds,
... negative_prompt_embeds=negative_embeds,
... output_type="pt",
... ).images
>>> # save intermediate image
>>> pil_image = pt_to_pil(image)
>>> pil_image[0].save("./if_stage_I.png")
>>> super_res_1_pipe = IFImg2ImgSuperResolutionPipeline.from_pretrained(
... "DeepFloyd/IF-II-L-v1.0",
... text_encoder=None,
... variant="fp16",
... torch_dtype=torch.float16,
... )
>>> super_res_1_pipe.enable_model_cpu_offload()
>>> image = super_res_1_pipe(
... image=image,
... original_image=original_image,
... prompt_embeds=prompt_embeds,
... negative_prompt_embeds=negative_embeds,
... ).images
>>> image[0].save("./if_stage_II.png")
```
#### encode_prompt[[diffusers.IFImg2ImgSuperResolutionPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], do_classifier_free_guidance: bool = True, num_images_per_prompt: int = 1, device: typing.Optional[torch.device] = None, negative_prompt: str | list[str] | None = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, clean_caption: bool = False)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/deepfloyd_if/pipeline_if_img2img_superresolution.py#L344)
**Paramètres :**
prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder
do_classifier_free_guidance (`bool`, *facultatif*, par défaut `True`) : indique s'il faut utiliser le guidage sans classifieur ou non
num_images_per_prompt (`int`, *facultatif*, valeur par défaut 1) : nombre d'images à générer par invite
device : (`torch.device`, *facultatif*) : le torch device sur lequel placer les embeddings résultants
negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération de l'image. S'il n'est pas défini, il faut passer `negative_prompt_embeds` à la place. 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`.
clean_caption (bool, par défaut `False`) : Si `True`, la fonction prétraite et nettoie la légende fournie avant l'encodage.
Encode le prompt dans les états cachés de l'encodeur de texte.
## IFInpaintingPipeline[[diffusers.IFInpaintingPipeline]]
#### diffusers.IFInpaintingPipeline[[diffusers.IFInpaintingPipeline]]
```python
diffusers.IFInpaintingPipeline(tokenizer: T5Tokenizer, text_encoder: T5EncoderModel, unet: UNet2DConditionModel, scheduler: DDPMScheduler, safety_checker: diffusers.pipelines.deepfloyd_if.safety_checker.IFSafetyChecker | None, feature_extractor: transformers.models.clip.image_processing_pil_clip.CLIPImageProcessorPil | None, watermarker: diffusers.pipelines.deepfloyd_if.watermark.IFWatermarker | None, requires_safety_checker: bool = True)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/deepfloyd_if/pipeline_if_inpainting.py#L123)
#### __appel__[[diffusers.IFInpaintingPipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, image: typing.Union[PIL.Image.Image, torch.Tensor, numpy.ndarray, list[PIL.Image.Image], list[torch.Tensor], list[numpy.ndarray]] = None, mask_image: typing.Union[PIL.Image.Image, torch.Tensor, numpy.ndarray, list[PIL.Image.Image], list[torch.Tensor], list[numpy.ndarray]] = None, strength: float = 1.0, num_inference_steps: int = 50, timesteps: list[int] = None, guidance_scale: float = 7.0, 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, 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, clean_caption: bool = True, cross_attention_kwargs: dict[str, typing.Any] | None = None)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/deepfloyd_if/pipeline_if_inpainting.py#L753)
**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, il faut passer `prompt_embeds` à la place.
image (`torch.Tensor` ou `PIL.Image.Image`) : `Image`, ou tenseur représentant un lot d'images, qui servira de point de départ au processus.
mask_image (`PIL.Image.Image`) : `Image` ou tenseur représentant un lot d'images, à masquer avec `image`. Les pixels blancs du masque seront repeints, tandis que les pixels noirs seront conservés. Si `mask_image` est une image PIL, elle sera convertie en un seul canal (luminance) avant utilisation. S'il s'agit d'un tenseur, il doit contenir un seul canal de couleur (L) au lieu de trois, la forme attendue étant donc `(B, H, W, 1)`.
strength (`float`, *facultatif*, valeur par défaut 1.0) : Indique conceptuellement dans quelle mesure transformer l'`image` de référence. Doit être compris entre 0 et 1. `image` sera utilisée comme point de départ, en y ajoutant davantage de bruit à mesure que `strength` augmente. Le nombre d'étapes de débruitage dépend de la quantité de bruit initialement ajoutée. Lorsque `strength` vaut 1, le bruit ajouté sera maximal et le processus de débruitage s'exécutera pendant le nombre complet d'itérations spécifié dans `num_inference_steps`. Une valeur de 1 ignore donc essentiellement `image`.
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.
timesteps (`list[int]`, *facultatif*) : Étapes de temps personnalisées à utiliser pour le processus de débruitage. Si non définies, des étapes de temps `num_inference_steps` équidistantes sont utilisées. Doivent être dans l'ordre décroissant.
guidance_scale (`float`, *facultatif*, valeur par défaut 7.0) : Échelle de guidage telle que définie dans [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` est défini comme `w` de l'équation 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). L'échelle de guidage est activée en définissant `guidance_scale > 1`. Une échelle de guidage plus élevée encourage la génération d'images étroitement liées au `prompt` texte, généralement au détriment de la qualité de l'image.
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`).
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 (η) du papier DDIM : https://huggingface.co/papers/2010.02502. S'applique uniquement à [schedulers.DDIMScheduler](/docs/diffusers/main/fr/api/schedulers/ddim#diffusers.DDIMScheduler), sera ignoré pour les autres.
generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Un ou une liste de [générateurs torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) pour rendre la génération déterministe.
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`.
output_type (`str`, *facultatif*, par défaut `"pil"`) : Le format de sortie de l'image générée. Choisissez entre [PIL](https://pillow.readthedocs.io/en/stable/) : `PIL.Image.Image` ou `np.array`.
return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `~pipelines.stable_diffusion.IFPipelineOutput` plutôt qu'un simple tuple.
callback (`Callable`, *facultatif*) : une fonction qui sera appelée toutes les `callback_steps` étapes pendant l'inférence. La fonction sera 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` sera appelée. Si non spécifié, le callback sera appelé à chaque étape.
clean_caption (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut nettoyer la légende avant de créer les embeddings. Nécessite l'installation de `beautifulsoup4` et `ftfy`. Si les dépendances ne sont pas installées, les embeddings seront créés à partir du prompt brut.
cross_attention_kwargs (`dict`, *facultatif*) : Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'`AttentionProcessor` tel que défini sous `self.processor` dans [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
**Retourne :** `~pipelines.stable_diffusion.IFPipelineOutput` ou `tuple`
`~pipelines.stable_diffusion.IFPipelineOutput` if `return_dict` is True, otherwise a `tuple. When returning a tuple, the first element is a list with the generated images, and the second element is a list of `bool`s denoting whether the corresponding generated image likely represents "not-safe-for-work" (nsfw) or watermarked content, according to the `safety_checker`.
Fonction appelée lors de l'appel du pipeline pour la génération.
Exemples :
```py
>>> from diffusers import IFInpaintingPipeline, IFInpaintingSuperResolutionPipeline, DiffusionPipeline
>>> from diffusers.utils import pt_to_pil
>>> import torch
>>> from PIL import Image
>>> import requests
>>> from io import BytesIO
>>> url = "https://huggingface.co/datasets/diffusers/docs-images/resolve/main/if/person.png"
>>> response = requests.get(url)
>>> original_image = Image.open(BytesIO(response.content)).convert("RGB")
>>> original_image = original_image
>>> url = "https://huggingface.co/datasets/diffusers/docs-images/resolve/main/if/glasses_mask.png"
>>> response = requests.get(url)
>>> mask_image = Image.open(BytesIO(response.content))
>>> mask_image = mask_image
>>> pipe = IFInpaintingPipeline.from_pretrained(
... "DeepFloyd/IF-I-XL-v1.0", variant="fp16", torch_dtype=torch.float16
... )
>>> pipe.enable_model_cpu_offload()
>>> prompt = "blue sunglasses"
>>> prompt_embeds, negative_embeds = pipe.encode_prompt(prompt)
>>> image = pipe(
... image=original_image,
... mask_image=mask_image,
... prompt_embeds=prompt_embeds,
... negative_prompt_embeds=negative_embeds,
... output_type="pt",
... ).images
>>> # save intermediate image
>>> pil_image = pt_to_pil(image)
>>> pil_image[0].save("./if_stage_I.png")
>>> super_res_1_pipe = IFInpaintingSuperResolutionPipeline.from_pretrained(
... "DeepFloyd/IF-II-L-v1.0", text_encoder=None, variant="fp16", torch_dtype=torch.float16
... )
>>> super_res_1_pipe.enable_model_cpu_offload()
>>> image = super_res_1_pipe(
... image=image,
... mask_image=mask_image,
... original_image=original_image,
... prompt_embeds=prompt_embeds,
... negative_prompt_embeds=negative_embeds,
... ).images
>>> image[0].save("./if_stage_II.png")
```
#### encode_prompt[[diffusers.IFInpaintingPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], do_classifier_free_guidance: bool = True, num_images_per_prompt: int = 1, device: typing.Optional[torch.device] = None, negative_prompt: str | list[str] | None = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, clean_caption: bool = False)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/deepfloyd_if/pipeline_if_inpainting.py#L195)
**Paramètres :**
prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder
do_classifier_free_guidance (`bool`, *facultatif*, par défaut `True`) : indique s'il faut utiliser le guidage sans classifieur ou non
num_images_per_prompt (`int`, *facultatif*, valeur par défaut 1) : nombre d'images à générer par invite
device : (`torch.device`, *facultatif*) : le torch device sur lequel placer les embeddings résultants
negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération de l'image. S'il n'est pas défini, il faut passer `negative_prompt_embeds` à la place. 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`.
clean_caption (bool, par défaut `False`) : Si `True`, la fonction prétraite et nettoie la légende fournie avant l'encodage.
Encode le prompt dans les états cachés de l'encodeur de texte.
## IFInpaintingSuperResolutionPipeline[[diffusers.IFInpaintingSuperResolutionPipeline]]
#### diffusers.IFInpaintingSuperResolutionPipeline[[diffusers.IFInpaintingSuperResolutionPipeline]]
```python
diffusers.IFInpaintingSuperResolutionPipeline(tokenizer: T5Tokenizer, text_encoder: T5EncoderModel, unet: UNet2DConditionModel, scheduler: DDPMScheduler, image_noising_scheduler: DDPMScheduler, safety_checker: diffusers.pipelines.deepfloyd_if.safety_checker.IFSafetyChecker | None, feature_extractor: transformers.models.clip.image_processing_pil_clip.CLIPImageProcessorPil | None, watermarker: diffusers.pipelines.deepfloyd_if.watermark.IFWatermarker | None, requires_safety_checker: bool = True)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/deepfloyd_if/pipeline_if_inpainting_superresolution.py#L126)
#### __appel__[[diffusers.IFInpaintingSuperResolutionPipeline.__call__]]
```python
__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor], original_image: typing.Union[PIL.Image.Image, torch.Tensor, numpy.ndarray, list[PIL.Image.Image], list[torch.Tensor], list[numpy.ndarray]] = None, mask_image: typing.Union[PIL.Image.Image, torch.Tensor, numpy.ndarray, list[PIL.Image.Image], list[torch.Tensor], list[numpy.ndarray]] = None, strength: float = 0.8, prompt: str | list[str] = None, num_inference_steps: int = 100, timesteps: list[int] = None, guidance_scale: float = 4.0, 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, 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, clean_caption: bool = True)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/deepfloyd_if/pipeline_if_inpainting_superresolution.py#L832)
**Paramètres :**
image (`torch.Tensor` ou `PIL.Image.Image`) : `Image`, ou tenseur représentant un lot d'images, qui servira de point de départ au processus.
original_image (`torch.Tensor` ou `PIL.Image.Image`) : L'image originale à partir de laquelle `image` a été modifiée.
mask_image (`PIL.Image.Image`) : `Image` ou tenseur représentant un lot d'images, à masquer avec `image`. Les pixels blancs du masque seront repeints, tandis que les pixels noirs seront conservés. Si `mask_image` est une image PIL, elle sera convertie en un seul canal (luminance) avant utilisation. S'il s'agit d'un tenseur, il doit contenir un seul canal de couleur (L) au lieu de trois, la forme attendue étant donc `(B, H, W, 1)`.
strength (`float`, *facultatif*, valeur par défaut 0.8) : Indique conceptuellement dans quelle mesure transformer l'`image` de référence. Doit être compris entre 0 et 1. `image` sera utilisée comme point de départ, en y ajoutant davantage de bruit à mesure que `strength` augmente. Le nombre d'étapes de débruitage dépend de la quantité de bruit initialement ajoutée. Lorsque `strength` vaut 1, le bruit ajouté sera maximal et le processus de débruitage s'exécutera pendant le nombre complet d'itérations spécifié dans `num_inference_steps`. Une valeur de 1 ignore donc essentiellement `image`.
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, il faut passer `prompt_embeds` à la place.
num_inference_steps (`int`, *facultatif*, valeur par défaut 100) : Le nombre d'étapes de débruitage. Un plus grand nombre d'étapes de débruitage conduit généralement à une image de meilleure qualité, au prix d'une inférence plus lente.
timesteps (`list[int]`, *facultatif*) : Étapes de temps personnalisées à utiliser pour le processus de débruitage. Si non définies, des étapes de temps `num_inference_steps` équidistantes sont utilisées. Doivent être dans l'ordre décroissant.
guidance_scale (`float`, *facultatif*, valeur par défaut 4.0) : Échelle de guidage telle que définie dans [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` est défini comme `w` de l'équation 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). L'échelle de guidage est activée en définissant `guidance_scale > 1`. Une échelle de guidage plus élevée encourage la génération d'images étroitement liées au `prompt` texte, généralement au détriment de la qualité de l'image.
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`).
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 (η) du papier DDIM : https://huggingface.co/papers/2010.02502. S'applique uniquement à [schedulers.DDIMScheduler](/docs/diffusers/main/fr/api/schedulers/ddim#diffusers.DDIMScheduler), sera ignoré pour les autres.
generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Un ou une liste de [générateurs torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) pour rendre la génération déterministe.
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`.
output_type (`str`, *facultatif*, par défaut `"pil"`) : Le format de sortie de l'image générée. Choisissez entre [PIL](https://pillow.readthedocs.io/en/stable/) : `PIL.Image.Image` ou `np.array`.
return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `~pipelines.stable_diffusion.IFPipelineOutput` plutôt qu'un simple tuple.
callback (`Callable`, *facultatif*) : une fonction qui sera appelée toutes les `callback_steps` étapes pendant l'inférence. La fonction sera 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` sera appelée. Si non spécifié, le callback sera 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 sous `self.processor` dans [diffusers.models.attention_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 à l'image agrandie. Doit être comprise dans l'intervalle `[0, 1000)`
clean_caption (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut nettoyer la légende avant de créer les embeddings. Nécessite l'installation de `beautifulsoup4` et `ftfy`. Si les dépendances ne sont pas installées, les embeddings seront créés à partir du prompt brut.
**Retourne :** `~pipelines.stable_diffusion.IFPipelineOutput` ou `tuple`
`~pipelines.stable_diffusion.IFPipelineOutput` if `return_dict` is True, otherwise a `tuple. When returning a tuple, the first element is a list with the generated images, and the second element is a list of `bool`s denoting whether the corresponding generated image likely represents "not-safe-for-work" (nsfw) or watermarked content, according to the `safety_checker`.
Fonction appelée lors de l'appel du pipeline pour la génération.
Exemples :
```py
>>> from diffusers import IFInpaintingPipeline, IFInpaintingSuperResolutionPipeline, DiffusionPipeline
>>> from diffusers.utils import pt_to_pil
>>> import torch
>>> from PIL import Image
>>> import requests
>>> from io import BytesIO
>>> url = "https://huggingface.co/datasets/diffusers/docs-images/resolve/main/if/person.png"
>>> response = requests.get(url)
>>> original_image = Image.open(BytesIO(response.content)).convert("RGB")
>>> original_image = original_image
>>> url = "https://huggingface.co/datasets/diffusers/docs-images/resolve/main/if/glasses_mask.png"
>>> response = requests.get(url)
>>> mask_image = Image.open(BytesIO(response.content))
>>> mask_image = mask_image
>>> pipe = IFInpaintingPipeline.from_pretrained(
... "DeepFloyd/IF-I-XL-v1.0", variant="fp16", torch_dtype=torch.float16
... )
>>> pipe.enable_model_cpu_offload()
>>> prompt = "blue sunglasses"
>>> prompt_embeds, negative_embeds = pipe.encode_prompt(prompt)
>>> image = pipe(
... image=original_image,
... mask_image=mask_image,
... prompt_embeds=prompt_embeds,
... negative_prompt_embeds=negative_embeds,
... output_type="pt",
... ).images
>>> # save intermediate image
>>> pil_image = pt_to_pil(image)
>>> pil_image[0].save("./if_stage_I.png")
>>> super_res_1_pipe = IFInpaintingSuperResolutionPipeline.from_pretrained(
... "DeepFloyd/IF-II-L-v1.0", text_encoder=None, variant="fp16", torch_dtype=torch.float16
... )
>>> super_res_1_pipe.enable_model_cpu_offload()
>>> image = super_res_1_pipe(
... image=image,
... mask_image=mask_image,
... original_image=original_image,
... prompt_embeds=prompt_embeds,
... negative_prompt_embeds=negative_embeds,
... ).images
>>> image[0].save("./if_stage_II.png")
```
#### encode_prompt[[diffusers.IFInpaintingSuperResolutionPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], do_classifier_free_guidance: bool = True, num_images_per_prompt: int = 1, device: typing.Optional[torch.device] = None, negative_prompt: str | list[str] | None = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, clean_caption: bool = False)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/deepfloyd_if/pipeline_if_inpainting_superresolution.py#L346)
**Paramètres :**
prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder
do_classifier_free_guidance (`bool`, *facultatif*, par défaut `True`) : indique s'il faut utiliser le guidage sans classifieur ou non
num_images_per_prompt (`int`, *facultatif*, valeur par défaut 1) : nombre d'images à générer par invite
device : (`torch.device`, *facultatif*) : le torch device sur lequel placer les embeddings résultants
negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération de l'image. S'il n'est pas défini, il faut passer `negative_prompt_embeds` à la place. 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`.
clean_caption (bool, par défaut `False`) : Si `True`, la fonction prétraite et nettoie la légende fournie avant l'encodage.
Encode le prompt dans les états cachés de l'encodeur de texte.
# DeepFloyd IF
## Aperçu
DeepFloyd IF est un nouveau modèle open source de pointe de génération d'images à partir de texte, doté d'un haut degré de photoréalisme et de compréhension du langage. Le modèle est modulaire et se compose d'un encodeur de texte figé et de trois modules de diffusion de pixels en cascade :
- Étape 1 : un modèle de base qui génère une image de 64x64 px à partir d'un prompt texte,
- Étape 2 : un modèle de super-résolution 64x64 px => 256x256 px, et
- Étape 3 : un modèle de super-résolution 256x256 px => 1024x1024 px
Les étapes 1 et 2 utilisent un encodeur de texte figé basé sur le transformeur T5 pour extraire des embeddings de texte, qui sont ensuite injectés dans une architecture UNet enrichie d'attention croisée et de pooling d'attention. L'étape 3 est le [modèle de suréchantillonnage x4 de Stability AI](https://huggingface.co/stabilityai/stable-diffusion-x4-upscaler). Le résultat est un modèle très efficace qui surpasse les modèles de l'état de l'art actuels, atteignant un score FID zero-shot de 6,66 sur le jeu de données COCO. Notre travail souligne le potentiel des architectures UNet plus grandes dans la première étape des modèles de diffusion en cascade et esquisse un avenir prometteur pour la synthèse d'images à partir de texte.
## Utilisation
Avant de pouvoir utiliser IF, vous devez accepter ses conditions d’utilisation. Pour ce faire :
1. Assurez-vous de disposer d'un [compte Hugging Face](https://huggingface.co/join) et d'être connecté.
2. Acceptez la licence sur la carte du modèle de [DeepFloyd/IF-I-XL-v1.0](https://huggingface.co/DeepFloyd/IF-I-XL-v1.0). L’acceptation de la licence sur la carte du modèle de l’étape I entraîne l’acceptation automatique pour les autres modèles IF.
3. Assurez-vous de vous connecter localement. Installez `huggingface_hub` :
```sh
pip install huggingface_hub --upgrade
```
exécuter la fonction de connexion dans un shell Python :
```py
from huggingface_hub import login
login()
```
et saisissez votre [jeton d'accès Hugging Face Hub](https://huggingface.co/docs/hub/security-tokens#what-are-user-access-tokens).
Nous installons ensuite `diffusers` et les dépendances :
```sh
pip install -q diffusers accelerate transformers
```
Les sections suivantes présentent des exemples plus détaillés de l'utilisation de IF. Plus précisément :
- [Génération d'images à partir de texte](#text-to-image-generation)
- [Génération d'image à partir d'image](#text-guided-image-to-image-generation)
- [Inpainting](#text-guided-inpainting-generation)
- [Réutilisation des poids du modèle](#converting-between-different-pipelines)
- [Optimisation de la vitesse](#optimizing-for-speed)
- [Optimisation de la mémoire](#optimizing-for-memory)
**Points de contrôle disponibles**
- *Étape 1*
- [DeepFloyd/IF-I-XL-v1.0](https://huggingface.co/DeepFloyd/IF-I-XL-v1.0)
- [DeepFloyd/IF-I-L-v1.0](https://huggingface.co/DeepFloyd/IF-I-L-v1.0)
- [DeepFloyd/IF-I-M-v1.0](https://huggingface.co/DeepFloyd/IF-I-M-v1.0)
- *Étape 2*
- [DeepFloyd/IF-II-L-v1.0](https://huggingface.co/DeepFloyd/IF-II-L-v1.0)
- [DeepFloyd/IF-II-M-v1.0](https://huggingface.co/DeepFloyd/IF-II-M-v1.0)
- *Étape 3*
- [stabilityai/stable-diffusion-x4-upscaler](https://huggingface.co/stabilityai/stable-diffusion-x4-upscaler)
**Google Colab** [](https://colab.research.google.com/github/huggingface/notebooks/blob/main/diffusers/deepfloyd_if_free_tier_google_colab.ipynb)
### Génération d'images à partir de texte
Par défaut, diffusers utilise le [model cpu offloading](../../optimization/memory#model-offloading) pour exécuter l'ensemble du pipeline IF avec seulement 14 Go de VRAM.
```python
from diffusers import DiffusionPipeline
from diffusers.utils import pt_to_pil, make_image_grid
import torch
# stage 1
stage_1 = DiffusionPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0", variant="fp16", dtype=torch.float16)
stage_1.enable_model_cpu_offload()
# stage 2
stage_2 = DiffusionPipeline.from_pretrained(
"DeepFloyd/IF-II-L-v1.0", text_encoder=None, variant="fp16", dtype=torch.float16
)
stage_2.enable_model_cpu_offload()
# stage 3
safety_modules = {
"feature_extractor": stage_1.feature_extractor,
"safety_checker": stage_1.safety_checker,
"watermarker": stage_1.watermarker,
}
stage_3 = DiffusionPipeline.from_pretrained(
"stabilityai/stable-diffusion-x4-upscaler", **safety_modules, dtype=torch.float16
)
stage_3.enable_model_cpu_offload()
prompt = 'a photo of a kangaroo wearing an orange hoodie and blue sunglasses standing in front of the eiffel tower holding a sign that says "very deep learning"'
generator = torch.manual_seed(1)
# text embeds
prompt_embeds, negative_embeds = stage_1.encode_prompt(prompt)
# stage 1
Xet Storage Details
- Size:
- 87.2 kB
- Xet hash:
- 9ecaf4a2d64123309d71645a6eada3e7d7c98216708c41127ad50ff4aa3ec58c
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.