Buckets:
# Flux
Flux est une série de modèles de génération d'images à partir de texte basés sur des transformeurs de diffusion. Pour en savoir plus sur Flux, consultez le [article de blog](https://blackforestlabs.ai/announcing-black-forest-labs/) original des créateurs de Flux, Black Forest Labs.
Les points de contrôle originaux du modèle Flux peuvent être trouvés [ici](https://huggingface.co/black-forest-labs). Le code d'inférence original peut être trouvé [ici](https://github.com/black-forest-labs/flux).
> [!TIP]
> Flux peut être assez coûteux à exécuter sur du matériel grand public. Toutefois, vous pouvez effectuer une série d'optimisations pour l'exécuter plus rapidement et de manière plus économe en mémoire. Consultez [cette section](https://huggingface.co/blog/sd3#memory-optimizations-for-sd3) pour plus de détails. De plus, Flux peut bénéficier de la quantification pour une meilleure efficacité mémoire, au prix d'une latence d'inférence accrue. Reportez-vous à [ce billet de blog](https://huggingface.co/blog/quanto-diffusers) pour en savoir plus. Pour une liste exhaustive des ressources, consultez [ce gist](https://gist.github.com/sayakpaul/b664605caf0aa3bf8585ab109dd5ac9c).
>
> [La mise en cache](../../optimization/cache) peut également accélérer l'inférence en stockant et en réutilisant les sorties intermédiaires.
Flux est disponible dans les variantes suivantes :
| type de modèle | identifiant du modèle |
|:----------:|:--------:|
| Distillé par pas de temps | [`black-forest-labs/FLUX.1-schnell`](https://huggingface.co/black-forest-labs/FLUX.1-schnell) |
| Distillé par guidage | [`black-forest-labs/FLUX.1-dev`](https://huggingface.co/black-forest-labs/FLUX.1-dev) |
| Remplissage Inpainting/Outpainting (Guidance-distilled) | [`black-forest-labs/FLUX.1-Fill-dev`](https://huggingface.co/black-forest-labs/FLUX.1-Fill-dev) |
| Canny Control (Guidance distillée) | [`black-forest-labs/FLUX.1-Canny-dev`](https://huggingface.co/black-forest-labs/FLUX.1-Canny-dev) |
| Contrôle de la profondeur (Guidance distillée) | [`black-forest-labs/FLUX.1-Depth-dev`](https://huggingface.co/black-forest-labs/FLUX.1-Depth-dev) |
| Canny Control (LoRA) | [`black-forest-labs/FLUX.1-Canny-dev-lora`](https://huggingface.co/black-forest-labs/FLUX.1-Canny-dev-lora) |
| Contrôle de la profondeur (LoRA) | [`black-forest-labs/FLUX.1-Depth-dev-lora`](https://huggingface.co/black-forest-labs/FLUX.1-Depth-dev-lora) |
| Redux (adaptateur) | [`black-forest-labs/FLUX.1-Redux-dev`](https://huggingface.co/black-forest-labs/FLUX.1-Redux-dev) |
| Kontext | [`black-forest-labs/FLUX.1-kontext`](https://huggingface.co/black-forest-labs/FLUX.1-Kontext-dev) |
Tous les points de contrôle ont des usages différents, que nous détaillons ci-dessous.
### Distillé par pas de temps
* `max_sequence_length` ne peut pas dépasser 256.
* `guidance_scale` doit être 0.
* Étant donné qu'il s'agit d'un modèle distillé sur les pas de temps, il bénéficie d'un nombre réduit d'étapes d'échantillonnage.
```python
import torch
from diffusers import FluxPipeline
pipe = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", dtype=torch.bfloat16)
pipe.enable_model_cpu_offload()
prompt = "A cat holding a sign that says hello world"
out = pipe(
prompt=prompt,
guidance_scale=0.,
height=768,
width=1360,
num_inference_steps=4,
max_sequence_length=256,
).images[0]
out.save("image.png")
```
### Distillé par guidage
* La variante distillée par guidage nécessite environ 50 étapes d'échantillonnage pour une génération de bonne qualité.
* Il n'a aucune limitation concernant `max_sequence_length`.
```python
import torch
from diffusers import FluxPipeline
pipe = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-dev", dtype=torch.bfloat16)
pipe.enable_model_cpu_offload()
prompt = "a tiny astronaut hatching from an egg on the moon"
out = pipe(
prompt=prompt,
guidance_scale=3.5,
height=768,
width=1360,
num_inference_steps=50,
).images[0]
out.save("image.png")
```
### Remplissage Inpainting/Outpainting
* Le pipeline Flux Fill ne nécessite pas `strength` en entrée, contrairement aux pipelines d'inpainting classiques.
* Il prend en charge à la fois l'inpainting et l'outpainting.
```python
import torch
from diffusers import FluxFillPipeline
from diffusers.utils import load_image
image = load_image("https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/cup.png")
mask = load_image("https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/cup_mask.png")
repo_id = "black-forest-labs/FLUX.1-Fill-dev"
pipe = FluxFillPipeline.from_pretrained(repo_id, dtype=torch.bfloat16).to("cuda") # or "mps", "xpu", "cpu"
image = pipe(
prompt="a white paper cup",
image=image,
mask_image=mask,
height=1632,
width=1232,
max_sequence_length=512,
generator=torch.Generator("cpu").manual_seed(0)
).images[0]
image.save(f"output.png")
```
### Canny Control
**Remarque :** `black-forest-labs/Flux.1-Canny-dev` n'est _pas_ un modèle [ControlNetModel](/docs/diffusers/main/fr/api/models/controlnet#diffusers.ControlNetModel). Les modèles ControlNet sont un composant distinct du UNet/Transformer, dont les résidus sont ajoutés au modèle sous-jacent réel. Canny Control est une architecture alternative qui obtient des résultats pratiquement identiques à ceux d'un modèle ControlNet, en utilisant la concaténation par canaux avec la condition de contrôle d'entrée et en veillant à ce que le transformer apprenne le contrôle de la structure en suivant la condition aussi fidèlement que possible.
```python
# !pip install -U controlnet-aux
import torch
from controlnet_aux import CannyDetector
from diffusers import FluxControlPipeline
from diffusers.utils import load_image
pipe = FluxControlPipeline.from_pretrained("black-forest-labs/FLUX.1-Canny-dev", dtype=torch.bfloat16).to("cuda") # or "mps", "xpu", "cpu"
prompt = "A robot made of exotic candies and chocolates of different kinds. The background is filled with confetti and celebratory gifts."
control_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png")
processor = CannyDetector()
control_image = processor(control_image, low_threshold=50, high_threshold=200, detect_resolution=1024, image_resolution=1024)
image = pipe(
prompt=prompt,
control_image=control_image,
height=1024,
width=1024,
num_inference_steps=50,
guidance_scale=30.0,
).images[0]
image.save("output.png")
```
Le contrôle Canny est également possible avec une variante LoRA de cette condition. L'utilisation est la suivante :
```python
# !pip install -U controlnet-aux
import torch
from controlnet_aux import CannyDetector
from diffusers import FluxControlPipeline
from diffusers.utils import load_image
pipe = FluxControlPipeline.from_pretrained("black-forest-labs/FLUX.1-dev", dtype=torch.bfloat16).to("cuda") # or "mps", "xpu", "cpu"
pipe.load_lora_weights("black-forest-labs/FLUX.1-Canny-dev-lora")
prompt = "A robot made of exotic candies and chocolates of different kinds. The background is filled with confetti and celebratory gifts."
control_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png")
processor = CannyDetector()
control_image = processor(control_image, low_threshold=50, high_threshold=200, detect_resolution=1024, image_resolution=1024)
image = pipe(
prompt=prompt,
control_image=control_image,
height=1024,
width=1024,
num_inference_steps=50,
guidance_scale=30.0,
).images[0]
image.save("output.png")
```
### Contrôle de la profondeur
**Remarque :** `black-forest-labs/Flux.1-Depth-dev` n'est _pas_ un modèle ControlNet. Les modèles [ControlNetModel](/docs/diffusers/main/fr/api/models/controlnet#diffusers.ControlNetModel) constituent un composant distinct de l'UNet/Transformer, dont les résidus sont ajoutés au modèle sous-jacent réel. Le contrôle de profondeur est une architecture alternative qui obtient des résultats pratiquement identiques à ceux d'un modèle ControlNet, en utilisant la concaténation par canal avec la condition de contrôle d'entrée et en veillant à ce que le transformer apprenne le contrôle de structure en suivant la condition aussi fidèlement que possible.
```python
# !pip install git+https://github.com/huggingface/image_gen_aux
import torch
from diffusers import FluxControlPipeline, FluxTransformer2DModel
from diffusers.utils import load_image
from image_gen_aux import DepthPreprocessor
pipe = FluxControlPipeline.from_pretrained("black-forest-labs/FLUX.1-Depth-dev", dtype=torch.bfloat16).to("cuda") # or "mps", "xpu", "cpu"
prompt = "A robot made of exotic candies and chocolates of different kinds. The background is filled with confetti and celebratory gifts."
control_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png")
processor = DepthPreprocessor.from_pretrained("LiheYoung/depth-anything-large-hf")
control_image = processor(control_image)[0].convert("RGB")
image = pipe(
prompt=prompt,
control_image=control_image,
height=1024,
width=1024,
num_inference_steps=30,
guidance_scale=10.0,
generator=torch.Generator().manual_seed(42),
).images[0]
image.save("output.png")
```
Le contrôle de la profondeur est également possible avec une variante LoRA de cette condition. L'utilisation est la suivante :
```python
# !pip install git+https://github.com/huggingface/image_gen_aux
import torch
from diffusers import FluxControlPipeline, FluxTransformer2DModel
from diffusers.utils import load_image
from image_gen_aux import DepthPreprocessor
pipe = FluxControlPipeline.from_pretrained("black-forest-labs/FLUX.1-dev", dtype=torch.bfloat16).to("cuda") # or "mps", "xpu", "cpu"
pipe.load_lora_weights("black-forest-labs/FLUX.1-Depth-dev-lora")
prompt = "A robot made of exotic candies and chocolates of different kinds. The background is filled with confetti and celebratory gifts."
control_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png")
processor = DepthPreprocessor.from_pretrained("LiheYoung/depth-anything-large-hf")
control_image = processor(control_image)[0].convert("RGB")
image = pipe(
prompt=prompt,
control_image=control_image,
height=1024,
width=1024,
num_inference_steps=30,
guidance_scale=10.0,
generator=torch.Generator().manual_seed(42),
).images[0]
image.save("output.png")
```
### Redux
* Le pipeline Flux Redux est un adaptateur pour les modèles de base FLUX.1. Il peut être utilisé avec flux-dev et flux-schnell, pour la génération d'image à partir d'image.
* Vous pouvez d’abord utiliser le `FluxPriorReduxPipeline` pour obtenir les `prompt_embeds` et les `pooled_prompt_embeds`, puis les transmettre au `FluxPipeline` pour la génération d’image à partir d’image.
* Lors de l’utilisation de `FluxPriorReduxPipeline` avec un pipeline de base, vous pouvez définir `text_encoder=None` et `text_encoder_2=None` dans le pipeline de base afin d’économiser de la VRAM.
```python
import torch
from diffusers import FluxPriorReduxPipeline, FluxPipeline
from diffusers.utils import load_image
device = "cuda" # or "mps", "xpu", "cpu"
dtype = torch.bfloat16
repo_redux = "black-forest-labs/FLUX.1-Redux-dev"
repo_base = "black-forest-labs/FLUX.1-dev"
pipe_prior_redux = FluxPriorReduxPipeline.from_pretrained(repo_redux, dtype=dtype).to(device)
pipe = FluxPipeline.from_pretrained(
repo_base,
text_encoder=None,
text_encoder_2=None,
dtype=torch.bfloat16
).to(device)
image = load_image("https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/style_ziggy/img5.png")
pipe_prior_output = pipe_prior_redux(image)
images = pipe(
guidance_scale=2.5,
num_inference_steps=50,
generator=torch.Generator("cpu").manual_seed(0),
**pipe_prior_output,
).images
images[0].save("flux-redux.png")
```
### Kontext
Flux Kontext est un modèle qui permet un contrôle en contexte du processus de génération d’images, facilitant ainsi l’édition, l’affinement, le re-éclairage, le transfert de style, la personnalisation de personnages et bien plus encore.
```python
import torch
from diffusers import FluxKontextPipeline
from diffusers.utils import load_image
pipe = FluxKontextPipeline.from_pretrained(
"black-forest-labs/FLUX.1-Kontext-dev", dtype=torch.bfloat16
)
pipe.to("cuda") # or "mps", "xpu", "cpu"
image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/yarn-art-pikachu.png").convert("RGB")
prompt = "Make Pikachu hold a sign that says 'Black Forest Labs is awesome', yarn art style, detailed, vibrant colors"
image = pipe(
image=image,
prompt=prompt,
guidance_scale=2.5,
generator=torch.Generator().manual_seed(42),
).images[0]
image.save("flux-kontext.png")
```
Flux Kontext est livré avec un vérificateur de sécurité d'intégrité, qui doit être exécuté après l'étape de génération d'image. Pour exécuter le vérificateur de sécurité, installez le dépôt officiel de [black-forest-labs/flux](https://github.com/black-forest-labs/flux) et ajoutez le code suivant :
```python
from flux.content_filters import PixtralContentFilter
# ... pipeline invocation to generate images
integrity_checker = PixtralContentFilter(torch.device("cuda"))
image_ = np.array(image) / 255.0
image_ = 2 * image_ - 1
image_ = torch.from_numpy(image_).to("cuda", dtype=torch.float32).unsqueeze(0).permute(0, 3, 1, 2)
if integrity_checker.test_image(image_):
raise ValueError("Your image has been flagged. Choose another prompt/image or try again.")
```
### Kontext Inpainting
`FluxKontextInpaintPipeline` permet de modifier une image dans une région masquée fixe. Il prend actuellement en charge à la fois le conditionnement par texte et le conditionnement par image de référence.
```python
import torch
from diffusers import FluxKontextInpaintPipeline
from diffusers.utils import load_image
prompt = "Change the yellow dinosaur to green one"
img_url = (
"https://github.com/ZenAI-Vietnam/Flux-Kontext-pipelines/blob/main/assets/dinosaur_input.jpeg?raw=true"
)
mask_url = (
"https://github.com/ZenAI-Vietnam/Flux-Kontext-pipelines/blob/main/assets/dinosaur_mask.png?raw=true"
)
source = load_image(img_url)
mask = load_image(mask_url)
pipe = FluxKontextInpaintPipeline.from_pretrained(
"black-forest-labs/FLUX.1-Kontext-dev", dtype=torch.bfloat16
)
pipe.to("cuda") # or "mps", "xpu", "cpu"
image = pipe(prompt=prompt, image=source, mask_image=mask, strength=1.0).images[0]
image.save("kontext_inpainting_normal.png")
```
```python
import torch
from diffusers import FluxKontextInpaintPipeline
from diffusers.utils import load_image
pipe = FluxKontextInpaintPipeline.from_pretrained(
"black-forest-labs/FLUX.1-Kontext-dev", dtype=torch.bfloat16
)
pipe.to("cuda") # or "mps", "xpu", "cpu"
prompt = "Replace this ball"
img_url = "https://images.pexels.com/photos/39362/the-ball-stadion-football-the-pitch-39362.jpeg?auto=compress&cs=tinysrgb&dpr=1&w=500"
mask_url = "https://github.com/ZenAI-Vietnam/Flux-Kontext-pipelines/blob/main/assets/ball_mask.png?raw=true"
image_reference_url = "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTah3x6OL_ECMBaZ5ZlJJhNsyC-OSMLWAI-xw&s"
source = load_image(img_url)
mask = load_image(mask_url)
image_reference = load_image(image_reference_url)
mask = pipe.mask_processor.blur(mask, blur_factor=12)
image = pipe(
prompt=prompt, image=source, mask_image=mask, image_reference=image_reference, strength=1.0
).images[0]
image.save("kontext_inpainting_ref.png")
```
## Combiner les LoRAs Flux Turbo avec Flux Control, Fill et Redux
Nous pouvons combiner les LoRA Flux Turbo avec Flux Control et d’autres pipelines comme Fill et Redux pour permettre une inférence en peu d’étapes. L’exemple ci-dessous montre comment faire pour le LoRA Flux Control de profondeur et le LoRA turbo de [`ByteDance/Hyper-SD`](https://hf.co/ByteDance/Hyper-SD).
```py
from diffusers import FluxControlPipeline
from image_gen_aux import DepthPreprocessor
from diffusers.utils import load_image
from huggingface_hub import hf_hub_download
import torch
control_pipe = FluxControlPipeline.from_pretrained("black-forest-labs/FLUX.1-dev", dtype=torch.bfloat16)
control_pipe.load_lora_weights("black-forest-labs/FLUX.1-Depth-dev-lora", adapter_name="depth")
control_pipe.load_lora_weights(
hf_hub_download("ByteDance/Hyper-SD", "Hyper-FLUX.1-dev-8steps-lora.safetensors"), adapter_name="hyper-sd"
)
control_pipe.set_adapters(["depth", "hyper-sd"], adapter_weights=[0.85, 0.125])
control_pipe.enable_model_cpu_offload()
prompt = "A robot made of exotic candies and chocolates of different kinds. The background is filled with confetti and celebratory gifts."
control_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png")
processor = DepthPreprocessor.from_pretrained("LiheYoung/depth-anything-large-hf")
control_image = processor(control_image)[0].convert("RGB")
image = control_pipe(
prompt=prompt,
control_image=control_image,
height=1024,
width=1024,
num_inference_steps=8,
guidance_scale=10.0,
generator=torch.Generator().manual_seed(42),
).images[0]
image.save("output.png")
```
## Remarque concernant `unload_lora_weights()` lors de l'utilisation de LoRAs Flux
Lors du déchargement des poids Control LoRA, appelez `pipe.unload_lora_weights(reset_to_overwritten_params=True)` pour réinitialiser complètement `pipe.transformer` à sa forme d'origine. Le pipeline résultant peut ensuite être utilisé avec des méthodes telles que [DiffusionPipeline.from_pipe()](/docs/diffusers/main/fr/api/pipelines/overview#diffusers.DiffusionPipeline.from_pipe). Plus de détails sur cet argument sont disponibles dans [cette PR](https://github.com/huggingface/diffusers/pull/10397).
## IP-Adapter
> [!TIP]
> Découvrez [IP-Adapter](../../using-diffusers/ip_adapter) pour en savoir plus sur le fonctionnement des IP-Adapters.
Un IP-Adapter vous permet de guider Flux avec des images, en plus du prompt texte. C'est particulièrement utile lorsque vous décrivez des concepts complexes difficiles à formuler par le texte seul et que vous disposez d'images de référence.
```python
import torch
from diffusers import FluxPipeline
from diffusers.utils import load_image
pipe = FluxPipeline.from_pretrained(
"black-forest-labs/FLUX.1-dev", dtype=torch.bfloat16
).to("cuda") # or "mps", "xpu", "cpu"
image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/flux_ip_adapter_input.jpg").resize((1024, 1024))
pipe.load_ip_adapter(
"XLabs-AI/flux-ip-adapter",
weight_name="ip_adapter.safetensors",
image_encoder_pretrained_model_name_or_path="openai/clip-vit-large-patch14"
)
pipe.set_ip_adapter_scale(1.0)
image = pipe(
width=1024,
height=1024,
prompt="wearing sunglasses",
negative_prompt="",
true_cfg_scale=4.0,
generator=torch.Generator().manual_seed(4444),
ip_adapter_image=image,
).images[0]
image.save('flux_ip_adapter_output.jpg')
```
Exemples d'IP-Adapter avec le prompt « portant des lunettes de soleil »
## Optimiser
Flux est un modèle très volumineux et nécessite environ 50 Go de RAM/VRAM pour charger tous les composants de modélisation. Activez certaines des optimisations ci-dessous pour réduire les besoins en mémoire.
### Group offloading
[Group offloading](../../optimization/memory#group-offloading) réduit l’utilisation de la VRAM en déplaçant des groupes de couches internes plutôt que le modèle entier ou les poids. Il est nécessaire d’utiliser [apply_group_offloading()](/docs/diffusers/main/fr/api/utilities#diffusers.hooks.apply_group_offloading) sur tous les composants du modèle d’un pipeline. Le paramètre `offload_type` permet de basculer entre le déchargement au niveau des blocs et celui au niveau des feuilles. En le définissant sur `leaf_level`, les paramètres de plus bas niveau (feuilles) sont déplacés vers le CPU au lieu d’effectuer le déchargement au niveau des modules.
Sur les appareils CUDA prenant en charge le flux de données asynchrone, définissez `use_stream=True` pour superposer le transfert de données et le calcul afin d’accélérer l’inférence.
> [!TIP]
> Il est possible de mélanger le déchargement au niveau des blocs et au niveau des feuilles pour différents composants d'un pipeline.
```py
import torch
from diffusers import FluxPipeline
from diffusers.hooks import apply_group_offloading
model_id = "black-forest-labs/FLUX.1-dev"
dtype = torch.bfloat16
pipe = FluxPipeline.from_pretrained(
model_id,
dtype=dtype,
)
apply_group_offloading(
pipe.transformer,
offload_type="leaf_level",
offload_device=torch.device("cpu"),
onload_device=torch.device("cuda"),
use_stream=True,
)
apply_group_offloading(
pipe.text_encoder,
offload_device=torch.device("cpu"),
onload_device=torch.device("cuda"),
offload_type="leaf_level",
use_stream=True,
)
apply_group_offloading(
pipe.text_encoder_2,
offload_device=torch.device("cpu"),
onload_device=torch.device("cuda"),
offload_type="leaf_level",
use_stream=True,
)
apply_group_offloading(
pipe.vae,
offload_device=torch.device("cpu"),
onload_device=torch.device("cuda"),
offload_type="leaf_level",
use_stream=True,
)
prompt="A cat wearing sunglasses and working as a lifeguard at pool."
generator = torch.Generator().manual_seed(181201)
image = pipe(
prompt,
width=576,
height=1024,
num_inference_steps=30,
generator=generator
).images[0]
image
```
### Exécution de l'inférence en FP16
Flux peut générer des images de haute qualité en FP16 (c'est-à-dire pour accélérer l'inférence sur les GPU Turing/Volta) mais produit des sorties différentes par rapport à FP32/BF16. Le problème est que certaines activations dans les encodeurs de texte doivent être tronquées lors de l'exécution en FP16, ce qui affecte l'image globale. Forcer les encodeurs de texte à s'exécuter avec une inférence en FP32 élimine ainsi cette différence de sortie. Voir [ici](https://github.com/huggingface/diffusers/pull/9097#issuecomment-2272292516) pour plus de détails.
Code d'inférence FP16 :
```python
import torch
from diffusers import FluxPipeline
pipe = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", dtype=torch.bfloat16) # can replace schnell with dev
# to run on low vram GPUs (i.e. between 4 and 32 GB VRAM)
pipe.enable_sequential_cpu_offload()
pipe.vae.enable_slicing()
pipe.vae.enable_tiling()
pipe.to(torch.float16) # casting here instead of in the pipeline constructor because doing so in the constructor loads all models into CPU memory at once
prompt = "A cat holding a sign that says hello world"
out = pipe(
prompt=prompt,
guidance_scale=0.,
height=768,
width=1360,
num_inference_steps=4,
max_sequence_length=256,
).images[0]
out.save("image.png")
```
### Quantification
La quantification aide à réduire les besoins en mémoire des très grands modèles en stockant les poids du modèle dans un type de données de précision inférieure. Cependant, la quantification peut avoir un impact variable sur la qualité de la vidéo selon le modèle vidéo.
Reportez-vous à l’aperçu de la [Quantization](../../quantization/overview) pour en savoir plus sur les backends de quantification pris en charge et sur la sélection d’un backend de quantification adapté à votre cas d’usage. L’exemple ci-dessous montre comment charger un [FluxPipeline](/docs/diffusers/main/fr/api/pipelines/flux#diffusers.FluxPipeline) quantifié pour l’inférence avec bitsandbytes.
```py
import torch
from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig, FluxTransformer2DModel, FluxPipeline
from transformers import BitsAndBytesConfig as BitsAndBytesConfig, T5EncoderModel
quant_config = BitsAndBytesConfig(load_in_8bit=True)
text_encoder_8bit = T5EncoderModel.from_pretrained(
"black-forest-labs/FLUX.1-dev",
subfolder="text_encoder_2",
quantization_config=quant_config,
dtype=torch.float16,
)
quant_config = DiffusersBitsAndBytesConfig(load_in_8bit=True)
transformer_8bit = FluxTransformer2DModel.from_pretrained(
"black-forest-labs/FLUX.1-dev",
subfolder="transformer",
quantization_config=quant_config,
dtype=torch.float16,
)
pipeline = FluxPipeline.from_pretrained(
"black-forest-labs/FLUX.1-dev",
text_encoder_2=text_encoder_8bit,
transformer=transformer_8bit,
dtype=torch.float16,
device_map="balanced",
)
prompt = "a tiny astronaut hatching from an egg on the moon"
image = pipeline(prompt, guidance_scale=3.5, height=768, width=1360, num_inference_steps=50).images[0]
image.save("flux.png")
```
## Chargement de fichier unique pour le `FluxTransformer2DModel`
Le `FluxTransformer2DModel` prend en charge le chargement de points de contrôle au format d’origine fourni par Black Forest Labs. Cela est également utile lors du chargement de versions affinées ou quantifiées des modèles publiées par la communauté.
> [!TIP]
> L’inférence `FP8` peut être fragile selon le type de GPU, la version de CUDA et la version de `torch` que vous utilisez. Il est recommandé d’utiliser la bibliothèque `optimum-quanto` pour exécuter l’inférence FP8 sur votre machine.
L'exemple suivant montre comment exécuter Flux avec moins de 16 Go de VRAM.
Installez d'abord `optimum-quanto`
```shell
pip install optimum-quanto
```
Puis exécutez l’exemple suivant
```python
import torch
from diffusers import FluxTransformer2DModel, FluxPipeline
from transformers import T5EncoderModel, CLIPTextModel
from optimum.quanto import freeze, qfloat8, quantize
bfl_repo = "black-forest-labs/FLUX.1-dev"
dtype = torch.bfloat16
transformer = FluxTransformer2DModel.from_single_file("https://huggingface.co/Kijai/flux-fp8/blob/main/flux1-dev-fp8.safetensors", dtype=dtype)
quantize(transformer, weights=qfloat8)
freeze(transformer)
text_encoder_2 = T5EncoderModel.from_pretrained(bfl_repo, subfolder="text_encoder_2", dtype=dtype)
quantize(text_encoder_2, weights=qfloat8)
freeze(text_encoder_2)
pipe = FluxPipeline.from_pretrained(bfl_repo, transformer=None, text_encoder_2=None, dtype=dtype)
pipe.transformer = transformer
pipe.text_encoder_2 = text_encoder_2
pipe.enable_model_cpu_offload()
prompt = "A cat holding a sign that says hello world"
image = pipe(
prompt,
guidance_scale=3.5,
output_type="pil",
num_inference_steps=20,
generator=torch.Generator("cpu").manual_seed(0)
).images[0]
image.save("flux-fp8-dev.png")
```
## FluxPipeline[[diffusers.FluxPipeline]]
#### diffusers.FluxPipeline[[diffusers.FluxPipeline]]
```python
diffusers.FluxPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, text_encoder_2: T5EncoderModel, tokenizer_2: T5Tokenizer, transformer: FluxTransformer2DModel, image_encoder: CLIPVisionModelWithProjection = None, feature_extractor: CLIPImageProcessorPil = None)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux.py#L146)
**Paramètres :**
transformer ([FluxTransformer2DModel](/docs/diffusers/main/fr/api/models/flux_transformer#diffusers.FluxTransformer2DModel)) : architecture Transformer conditionnelle (MMDiT) pour le débruitage des latents d'image encodés.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents d'image encodés.
vae ([AutoencoderKL](/docs/diffusers/main/fr/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des images vers et depuis des représentations latentes.
text_encoder (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), plus précisément la variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).
text_encoder_2 (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), plus précisément la variante [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).
tokenizer (`CLIPTokenizer`) : Tokenizer de la classe [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer).
tokenizer_2 (`T5TokenizerFast`) : Second Tokenizer de la classe [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).
Le pipeline Flux pour la génération d'images à partir de texte.
Référence : https://blackforestlabs.ai/announcing-black-forest-labs/
#### __appel__[[diffusers.FluxPipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, negative_prompt: str | list[str] = None, negative_prompt_2: str | list[str] | None = None, true_cfg_scale: float = 1.0, height: int | None = None, width: int | None = None, num_inference_steps: int = 28, sigmas: list[float] | None = None, guidance_scale: float = 3.5, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, negative_ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, negative_ip_adapter_image_embeds: list[torch.Tensor] | None = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, output_type: str | None = 'pil', return_dict: bool = True, joint_attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux.py#L600)
**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.
prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer à `tokenizer_2` et `text_encoder_2`. S'il n'est pas défini, `prompt` sera utilisé à la place.
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. Ignoré lorsque le guidage n'est pas utilisé (c'est-à-dire ignoré si `true_cfg_scale` n'est pas supérieur à `1`).
negative_prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image, à envoyer à `tokenizer_2` et `text_encoder_2`. S’il n’est pas défini, `negative_prompt` est utilisé dans tous les encodeurs de texte.
true_cfg_scale (`float`, *facultatif*, valeur par défaut 1.0) : le guidance sans classifieur (échelle de guidance) est activé lorsque `true_cfg_scale` > 1 et que `negative_prompt` est fourni.
height (`int`, *facultatif*, par défaut self.unet.config.sample_size * self.vae_scale_factor) : La hauteur en pixels de l'image générée. Cette valeur est fixée à 1024 par défaut pour obtenir les meilleurs résultats.
width (`int`, *facultatif*, par défaut self.unet.config.sample_size * self.vae_scale_factor) : La largeur en pixels de l'image générée. Cette valeur est fixée à 1024 par défaut pour obtenir les meilleurs résultats.
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.
sigmas (`list[float]`, *facultatif*) : Sigmas personnalisés à utiliser pour le processus de débruitage avec les planificateurs qui prennent en charge un argument `sigmas` dans leur méthode `set_timesteps`. S'ils ne sont pas définis, le comportement par défaut lorsque `num_inference_steps` est passé sera utilisé.
guidance_scale (`float`, *facultatif*, valeur par défaut 3,5) : L'échelle de guidage intégrée est activée en définissant `guidance_scale` > 1. Une valeur plus élevée de `guidance_scale` encourage le modèle à générer des images plus alignées avec le `prompt`, au détriment de la qualité de l'image. Les modèles distillés par guidage approximent le vrai guidage sans classifieur pour `guidance_scale` > 1. Consultez l'[article](https://huggingface.co/papers/2210.03142) pour en savoir plus.
num_images_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre d'images à générer par invite.
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.
latents (`torch.FloatTensor`, *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 sera généré par échantillonnage à l'aide du `generator` aléatoire fourni.
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`.
pooled_prompt_embeds (`torch.FloatTensor`, *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`.
ip_adapter_image : (`PipelineImageInput`, *facultatif*) : Entrée d'image facultative pour travailler avec les IP Adapters.
ip_adapter_image_embeds (`list[torch.Tensor]`, *facultatif*) : Embeddings d'images pré-générés pour IP-Adapter. Il doit s'agir d'une liste dont la longueur est égale au nombre d'IP-adapters. Chaque élément doit être un tenseur de forme `(batch_size, num_images, emb_dim)`. S'il n'est pas fourni, les embeddings sont calculés à partir de l'argument d'entrée `ip_adapter_image`.
negative_ip_adapter_image : (`PipelineImageInput`, *facultatif*) : Entrée d'image facultative pour travailler avec les IP Adapters.
negative_ip_adapter_image_embeds (`list[torch.Tensor]`, *facultatif*) : Embeddings d'images pré-générés pour IP-Adapter. Il doit s'agir d'une liste dont la longueur est égale au nombre d'IP-adapters. Chaque élément doit être un tenseur de forme `(batch_size, num_images, emb_dim)`. S'il n'est pas fourni, les embeddings sont calculés à partir de l'argument d'entrée `ip_adapter_image`.
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`.
negative_pooled_prompt_embeds (`torch.FloatTensor`, *facultatif*) : Embeddings de texte négatifs 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, les pooled negative_prompt_embeds seront 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](https://pillow.readthedocs.io/en/stable/) : `PIL.Image.Image` ou `np.array`.
return_dict (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut retourner un `~pipelines.flux.FluxPipelineOutput` plutôt qu'un simple tuple.
joint_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).
callback_on_step_end (`Callable`, *facultatif*) : une fonction appelée à la fin de chaque étape de débruitage pendant l’inférence. La fonction est appelée avec les arguments suivants : `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` contiendra une liste de tous les tenseurs, tels que spécifiés par `callback_on_step_end_tensor_inputs`.
callback_on_step_end_tensor_inputs (`list`, *facultatif*) : La liste des entrées tensorielles pour la fonction `callback_on_step_end`. Les tenseurs spécifiés dans la liste seront passés en tant qu'argument `callback_kwargs`. Vous ne pourrez inclure que les variables listées dans l'attribut `._callback_tensor_inputs` de votre classe de pipeline.
max_sequence_length (`int` par défaut 512) : Longueur maximale de la séquence à utiliser avec le `prompt`.
**Retourne :** `~pipelines.flux.FluxPipelineOutput` ou `tuple`
`~pipelines.flux.FluxPipelineOutput` si `return_dict` est True, sinon un `tuple`. En cas de retour d'un tuple, le premier élément est une liste contenant les images générées.
Fonction appelée lors de l'appel du pipeline pour la génération.
Exemples :
```py
>>> import torch
>>> from diffusers import FluxPipeline
>>> pipe = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")
>>> prompt = "A cat holding a sign that says hello world"
>>> # Depending on the variant being used, the pipeline call will slightly vary.
>>> # Refer to the pipeline documentation for more details.
>>> image = pipe(prompt, num_inference_steps=4, guidance_scale=0.0).images[0]
>>> image.save("flux.png")
```
#### encode_prompt[[diffusers.FluxPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], prompt_2: str | list[str] | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, max_sequence_length: int = 512, lora_scale: float | None = None)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux.py#L312)
**Paramètres :**
prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder
prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer au `tokenizer_2` et au `text_encoder_2`. S'il n'est pas défini, `prompt` est utilisé dans tous les encodeurs de texte
device : (`torch.device`) : appareil torch
num_images_per_prompt (`int`) : nombre d'images à générer par invite
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`.
pooled_prompt_embeds (`torch.FloatTensor`, *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`.
lora_scale (`float`, *facultatif*) : Échelle LoRA appliquée à toutes les couches LoRA de l'encodeur de texte si des couches LoRA sont chargées.
## FluxImg2ImgPipeline[[diffusers.FluxImg2ImgPipeline]]
#### diffusers.FluxImg2ImgPipeline[[diffusers.FluxImg2ImgPipeline]]
```python
diffusers.FluxImg2ImgPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, text_encoder_2: T5EncoderModel, tokenizer_2: T5Tokenizer, transformer: FluxTransformer2DModel, image_encoder: CLIPVisionModelWithProjection = None, feature_extractor: CLIPImageProcessorPil = None)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_img2img.py#L169)
**Paramètres :**
transformer ([FluxTransformer2DModel](/docs/diffusers/main/fr/api/models/flux_transformer#diffusers.FluxTransformer2DModel)) : architecture Transformer conditionnelle (MMDiT) pour le débruitage des latents d'image encodés.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents d'image encodés.
vae ([AutoencoderKL](/docs/diffusers/main/fr/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des images vers et depuis des représentations latentes.
text_encoder (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), plus précisément la variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).
text_encoder_2 (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), plus précisément la variante [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).
tokenizer (`CLIPTokenizer`) : Tokenizer de la classe [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer).
tokenizer_2 (`T5TokenizerFast`) : Second Tokenizer de la classe [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).
Le pipeline Flux pour l'inpainting d'images.
Référence : https://blackforestlabs.ai/announcing-black-forest-labs/
#### __appel__[[diffusers.FluxImg2ImgPipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, negative_prompt: str | list[str] = None, negative_prompt_2: str | list[str] | None = None, true_cfg_scale: float = 1.0, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, height: int | None = None, width: int | None = None, strength: float = 0.6, num_inference_steps: int = 28, sigmas: list[float] | None = None, guidance_scale: float = 7.0, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, negative_ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, negative_ip_adapter_image_embeds: list[torch.Tensor] | None = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, output_type: str | None = 'pil', return_dict: bool = True, joint_attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_img2img.py#L678)
**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.
prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer à `tokenizer_2` et `text_encoder_2`. S'il n'est pas défini, `prompt` sera utilisé à la place
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. Ignoré lorsque le guidage n'est pas utilisé (c'est-à-dire ignoré si `true_cfg_scale` n'est pas supérieur à `1`).
negative_prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image, à envoyer à `tokenizer_2` et `text_encoder_2`. S’il n’est pas défini, `negative_prompt` est utilisé dans tous les encodeurs de texte.
true_cfg_scale (`float`, *facultatif*, valeur par défaut 1.0) : le guidance sans classifieur (échelle de guidance) est activé lorsque `true_cfg_scale` > 1 et que `negative_prompt` est fourni.
image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` ou `list[np.ndarray]`) : `Image`, tableau numpy ou tenseur représentant un lot d’images à utiliser comme point de départ. Pour un tableau numpy et un tenseur pytorch, la plage de valeurs attendue est comprise entre `[0, 1]`. S’il s’agit d’un tenseur ou d’une liste de tenseurs, la forme attendue doit être `(B, C, H, W)` ou `(C, H, W)`. S’il s’agit d’un tableau numpy ou d’une liste de tableaux, la forme attendue doit être `(B, H, W, C)` ou `(H, W, C)`. Il peut également accepter des latents d’image en tant que `image`, mais si des latents sont transmis directement, ils ne sont pas réencodés.
height (`int`, *facultatif*, par défaut self.unet.config.sample_size * self.vae_scale_factor) : La hauteur en pixels de l'image générée. Cette valeur est fixée à 1024 par défaut pour obtenir les meilleurs résultats.
width (`int`, *facultatif*, par défaut self.unet.config.sample_size * self.vae_scale_factor) : La largeur en pixels de l'image générée. Cette valeur est fixée à 1024 par défaut pour obtenir les meilleurs résultats.
strength (`float`, *facultatif*, valeur par défaut 1.0) : Indique dans quelle mesure transformer l'`image` de référence. Doit être compris entre 0 et 1. `image` est utilisé comme point de départ et plus le `strength` est élevé, plus du bruit est ajouté. Le nombre d'étapes de débruitage dépend de la quantité de bruit initialement ajoutée. Lorsque `strength` vaut 1, le bruit ajouté est maximal et le processus de débruitage s'exécute pendant le nombre complet d'itérations spécifié dans `num_inference_steps`. Une valeur de 1 ignore 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.
sigmas (`list[float]`, *facultatif*) : Sigmas personnalisés à utiliser pour le processus de débruitage avec les planificateurs qui prennent en charge un argument `sigmas` dans leur méthode `set_timesteps`. S'ils ne sont pas définis, le comportement par défaut lorsque `num_inference_steps` est passé sera utilisé.
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.
num_images_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre d'images à générer par invite.
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.
latents (`torch.FloatTensor`, *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 sera généré par échantillonnage à l'aide du `generator` aléatoire fourni.
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`.
pooled_prompt_embeds (`torch.FloatTensor`, *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_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`.
negative_pooled_prompt_embeds (`torch.FloatTensor`, *facultatif*) : Embeddings de texte négatifs 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, les pooled negative_prompt_embeds seront générés à partir de l'argument d'entrée `negative_prompt`.
ip_adapter_image : (`PipelineImageInput`, *facultatif*) : Entrée d'image facultative pour travailler avec les IP Adapters.
ip_adapter_image_embeds (`list[torch.Tensor]`, *facultatif*) : Embeddings d'images pré-générés pour IP-Adapter. Il doit s'agir d'une liste dont la longueur est égale au nombre d'IP-adapters. Chaque élément doit être un tenseur de forme `(batch_size, num_images, emb_dim)`. S'il n'est pas fourni, les embeddings sont calculés à partir de l'argument d'entrée `ip_adapter_image`.
negative_ip_adapter_image : (`PipelineImageInput`, *facultatif*) : Entrée d'image facultative pour travailler avec les IP Adapters.
negative_ip_adapter_image_embeds (`list[torch.Tensor]`, *facultatif*) : Embeddings d'images pré-générés pour IP-Adapter. Il doit s'agir d'une liste dont la longueur est égale au nombre d'IP-adapters. Chaque élément doit être un tenseur de forme `(batch_size, num_images, emb_dim)`. S'il n'est pas fourni, les embeddings sont calculés à partir de l'argument d'entrée `ip_adapter_image`.
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*, valeur par défaut `True`) : Indique s'il faut retourner un `~pipelines.flux.FluxPipelineOutput` plutôt qu'un simple tuple.
joint_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).
callback_on_step_end (`Callable`, *facultatif*) : une fonction appelée à la fin de chaque étape de débruitage pendant l’inférence. La fonction est appelée avec les arguments suivants : `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` contiendra une liste de tous les tenseurs, tels que spécifiés par `callback_on_step_end_tensor_inputs`.
callback_on_step_end_tensor_inputs (`list`, *facultatif*) : La liste des entrées tensorielles pour la fonction `callback_on_step_end`. Les tenseurs spécifiés dans la liste seront passés en tant qu'argument `callback_kwargs`. Vous ne pourrez inclure que les variables listées dans l'attribut `._callback_tensor_inputs` de votre classe de pipeline.
max_sequence_length (`int` par défaut 512) : Longueur maximale de la séquence à utiliser avec le `prompt`.
**Retourne :** `~pipelines.flux.FluxPipelineOutput` ou `tuple`
`~pipelines.flux.FluxPipelineOutput` si `return_dict` est True, sinon un `tuple`. En cas de retour d'un tuple, le premier élément est une liste contenant les images générées.
Fonction appelée lors de l'appel du pipeline pour la génération.
Exemples :
```py
>>> import torch
>>> from diffusers import FluxImg2ImgPipeline
>>> from diffusers.utils import load_image
>>> device = "cuda"
>>> pipe = FluxImg2ImgPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", torch_dtype=torch.bfloat16)
>>> pipe = pipe.to(device)
>>> url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg"
>>> init_image = load_image(url).resize((1024, 1024))
>>> prompt = "cat wizard, gandalf, lord of the rings, detailed, fantasy, cute, adorable, Pixar, Disney, 8k"
>>> images = pipe(
... prompt=prompt, image=init_image, num_inference_steps=4, strength=0.95, guidance_scale=0.0
... ).images[0]
```
#### encode_prompt[[diffusers.FluxImg2ImgPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], prompt_2: str | list[str] | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, max_sequence_length: int = 512, lora_scale: float | None = None)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_img2img.py#L335)
**Paramètres :**
prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder
prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer au `tokenizer_2` et au `text_encoder_2`. S'il n'est pas défini, `prompt` est utilisé dans tous les encodeurs de texte
device : (`torch.device`) : appareil torch
num_images_per_prompt (`int`) : nombre d'images à générer par invite
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`.
pooled_prompt_embeds (`torch.FloatTensor`, *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`.
lora_scale (`float`, *facultatif*) : Échelle LoRA appliquée à toutes les couches LoRA de l'encodeur de texte si des couches LoRA sont chargées.
## FluxInpaintPipeline[[diffusers.FluxInpaintPipeline]]
#### diffusers.FluxInpaintPipeline[[diffusers.FluxInpaintPipeline]]
```python
diffusers.FluxInpaintPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, text_encoder_2: T5EncoderModel, tokenizer_2: T5Tokenizer, transformer: FluxTransformer2DModel, image_encoder: CLIPVisionModelWithProjection = None, feature_extractor: CLIPImageProcessorPil = None)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_inpaint.py#L166)
**Paramètres :**
transformer ([FluxTransformer2DModel](/docs/diffusers/main/fr/api/models/flux_transformer#diffusers.FluxTransformer2DModel)) : architecture Transformer conditionnelle (MMDiT) pour le débruitage des latents d'image encodés.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents d'image encodés.
vae ([AutoencoderKL](/docs/diffusers/main/fr/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des images vers et depuis des représentations latentes.
text_encoder (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), plus précisément la variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).
text_encoder_2 (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), plus précisément la variante [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).
tokenizer (`CLIPTokenizer`) : Tokenizer de la classe [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer).
tokenizer_2 (`T5TokenizerFast`) : Second Tokenizer de la classe [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).
Le pipeline Flux pour l'inpainting d'images.
Référence : https://blackforestlabs.ai/announcing-black-forest-labs/
#### __appel__[[diffusers.FluxInpaintPipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, negative_prompt: str | list[str] = None, negative_prompt_2: str | list[str] | None = None, true_cfg_scale: float = 1.0, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, mask_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, masked_image_latents: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, height: int | None = None, width: int | None = None, padding_mask_crop: int | None = None, strength: float = 0.6, num_inference_steps: int = 28, sigmas: list[float] | None = None, guidance_scale: float = 7.0, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, negative_ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, negative_ip_adapter_image_embeds: list[torch.Tensor] | None = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, output_type: str | None = 'pil', return_dict: bool = True, joint_attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_inpaint.py#L777)
**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.
prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer à `tokenizer_2` et `text_encoder_2`. S'il n'est pas défini, `prompt` sera utilisé à la place
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. Ignoré lorsque le guidage n'est pas utilisé (c'est-à-dire ignoré si `true_cfg_scale` n'est pas supérieur à `1`).
negative_prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image, à envoyer à `tokenizer_2` et `text_encoder_2`. S’il n’est pas défini, `negative_prompt` est utilisé dans tous les encodeurs de texte.
true_cfg_scale (`float`, *facultatif*, valeur par défaut 1.0) : le guidance sans classifieur (échelle de guidance) est activé lorsque `true_cfg_scale` > 1 et que `negative_prompt` est fourni.
image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` ou `list[np.ndarray]`) : `Image`, tableau numpy ou tenseur représentant un lot d’images à utiliser comme point de départ. Pour un tableau numpy et un tenseur pytorch, la plage de valeurs attendue est comprise entre `[0, 1]`. S’il s’agit d’un tenseur ou d’une liste de tenseurs, la forme attendue doit être `(B, C, H, W)` ou `(C, H, W)`. S’il s’agit d’un tableau numpy ou d’une liste de tableaux, la forme attendue doit être `(B, H, W, C)` ou `(H, W, C)`. Il peut également accepter des latents d’image en tant que `image`, mais si des latents sont transmis directement, ils ne sont pas réencodés.
mask_image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` ou `list[np.ndarray]`) : `Image`, tableau numpy ou tenseur représentant un lot d'images à masquer `image`. Les pixels blancs du masque sont repeints tandis que les pixels noirs sont conservés. Si `mask_image` est une image PIL, elle est convertie en un seul canal (luminance) avant utilisation. S'il s'agit d'un tableau numpy ou d'un tenseur pytorch, il doit contenir un seul canal de couleur (L) au lieu de trois, de sorte que la forme attendue pour un tenseur pytorch serait `(B, 1, H, W)`, `(B, H, W)`, `(1, H, W)` ou `(H, W)`. Et pour un tableau numpy, elle serait `(B, H, W, 1)`, `(B, H, W)`, `(H, W, 1)` ou `(H, W)`.
masked_image_latents (`torch.Tensor`, `list[torch.Tensor]`) : `Tensor` représentant un lot d'images pour masquer `image` générée par le VAE. Si non fourni, le tenseur de latents du masque sera généré par `mask_image`.
height (`int`, *facultatif*, par défaut self.unet.config.sample_size * self.vae_scale_factor) : La hauteur en pixels de l'image générée. Cette valeur est fixée à 1024 par défaut pour obtenir les meilleurs résultats.
width (`int`, *facultatif*, par défaut self.unet.config.sample_size * self.vae_scale_factor) : La largeur en pixels de l'image générée. Cette valeur est fixée à 1024 par défaut pour obtenir les meilleurs résultats.
padding_mask_crop (`int`, *facultatif*, valeur par défaut `None`) : La taille de la marge dans le recadrage à appliquer à l'image et au masquage. Si `None`, aucun recadrage n'est appliqué à l'image et à mask_image. Si `padding_mask_crop` n'est pas `None`, il recherche d'abord une région rectangulaire ayant le même ratio d'aspect que l'image et contenant toute la zone masquée, puis élargit cette zone en fonction de `padding_mask_crop`. L'image et mask_image sont ensuite recadrées en fonction de la zone élargie avant d'être redimensionnées à la taille de l'image d'origine pour l'inpainting. Cela est utile lorsque la zone masquée est petite tandis que l'image est grande et contient des informations non pertinentes pour l'inpainting, telles que l'arrière-plan.
strength (`float`, *facultatif*, valeur par défaut 1.0) : Indique dans quelle mesure transformer l'`image` de référence. Doit être compris entre 0 et 1. `image` est utilisé comme point de départ et plus le `strength` est élevé, plus du bruit est ajouté. Le nombre d'étapes de débruitage dépend de la quantité de bruit initialement ajoutée. Lorsque `strength` vaut 1, le bruit ajouté est maximal et le processus de débruitage s'exécute pendant le nombre complet d'itérations spécifié dans `num_inference_steps`. Une valeur de 1 ignore 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.
sigmas (`list[float]`, *facultatif*) : Sigmas personnalisés à utiliser pour le processus de débruitage avec les planificateurs qui prennent en charge un argument `sigmas` dans leur méthode `set_timesteps`. S'ils ne sont pas définis, le comportement par défaut lorsque `num_inference_steps` est passé sera utilisé.
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.
num_images_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre d'images à générer par invite.
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.
latents (`torch.FloatTensor`, *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 sera généré par échantillonnage à l'aide du `generator` aléatoire fourni.
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`.
pooled_prompt_embeds (`torch.FloatTensor`, *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_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`.
negative_pooled_prompt_embeds (`torch.FloatTensor`, *facultatif*) : Embeddings de texte négatifs 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, les pooled negative_prompt_embeds seront générés à partir de l'argument d'entrée `negative_prompt`.
ip_adapter_image : (`PipelineImageInput`, *facultatif*) : Entrée d'image facultative pour travailler avec les IP Adapters.
ip_adapter_image_embeds (`list[torch.Tensor]`, *facultatif*) : Embeddings d'images pré-générés pour IP-Adapter. Il doit s'agir d'une liste dont la longueur est égale au nombre d'IP-adapters. Chaque élément doit être un tenseur de forme `(batch_size, num_images, emb_dim)`. S'il n'est pas fourni, les embeddings sont calculés à partir de l'argument d'entrée `ip_adapter_image`.
negative_ip_adapter_image : (`PipelineImageInput`, *facultatif*) : Entrée d'image facultative pour travailler avec les IP Adapters.
negative_ip_adapter_image_embeds (`list[torch.Tensor]`, *facultatif*) : Embeddings d'images pré-générés pour IP-Adapter. Il doit s'agir d'une liste dont la longueur est égale au nombre d'IP-adapters. Chaque élément doit être un tenseur de forme `(batch_size, num_images, emb_dim)`. S'il n'est pas fourni, les embeddings sont calculés à partir de l'argument d'entrée `ip_adapter_image`.
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*, valeur par défaut `True`) : Indique s'il faut retourner un `~pipelines.flux.FluxPipelineOutput` plutôt qu'un simple tuple.
joint_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).
callback_on_step_end (`Callable`, *facultatif*) : une fonction appelée à la fin de chaque étape de débruitage pendant l’inférence. La fonction est appelée avec les arguments suivants : `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` contiendra une liste de tous les tenseurs, tels que spécifiés par `callback_on_step_end_tensor_inputs`.
callback_on_step_end_tensor_inputs (`list`, *facultatif*) : La liste des entrées tensorielles pour la fonction `callback_on_step_end`. Les tenseurs spécifiés dans la liste seront passés en tant qu'argument `callback_kwargs`. Vous ne pourrez inclure que les variables listées dans l'attribut `._callback_tensor_inputs` de votre classe de pipeline.
max_sequence_length (`int` par défaut 512) : Longueur maximale de la séquence à utiliser avec le `prompt`.
**Retourne :** `~pipelines.flux.FluxPipelineOutput` ou `tuple`
`~pipelines.flux.FluxPipelineOutput` si `return_dict` est True, sinon un `tuple`. En cas de retour d'un tuple, le premier élément est une liste contenant les images générées.
Fonction appelée lors de l'appel du pipeline pour la génération.
Exemples :
```py
>>> import torch
>>> from diffusers import FluxInpaintPipeline
>>> from diffusers.utils import load_image
>>> pipe = FluxInpaintPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")
>>> prompt = "Face of a yellow cat, high resolution, sitting on a park bench"
>>> img_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png"
>>> mask_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo_mask.png"
>>> source = load_image(img_url)
>>> mask = load_image(mask_url)
>>> image = pipe(prompt=prompt, image=source, mask_image=mask).images[0]
>>> image.save("flux_inpainting.png")
```
#### encode_prompt[[diffusers.FluxInpaintPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], prompt_2: str | list[str] | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, max_sequence_length: int = 512, lora_scale: float | None = None)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_inpaint.py#L339)
**Paramètres :**
prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder
prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer au `tokenizer_2` et au `text_encoder_2`. S'il n'est pas défini, `prompt` est utilisé dans tous les encodeurs de texte
device : (`torch.device`) : appareil torch
num_images_per_prompt (`int`) : nombre d'images à générer par invite
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`.
pooled_prompt_embeds (`torch.FloatTensor`, *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`.
lora_scale (`float`, *facultatif*) : Échelle LoRA appliquée à toutes les couches LoRA de l'encodeur de texte si des couches LoRA sont chargées.
## FluxControlNetInpaintPipeline[[diffusers.FluxControlNetInpaintPipeline]]
#### diffusers.FluxControlNetInpaintPipeline[[diffusers.FluxControlNetInpaintPipeline]]
```python
diffusers.FluxControlNetInpaintPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, text_encoder_2: T5EncoderModel, tokenizer_2: T5Tokenizer, transformer: FluxTransformer2DModel, controlnet: diffusers.models.controlnets.controlnet_flux.FluxControlNetModel | list[diffusers.models.controlnets.controlnet_flux.FluxControlNetModel] | tuple[diffusers.models.controlnets.controlnet_flux.FluxControlNetModel] | diffusers.models.controlnets.controlnet_flux.FluxMultiControlNetModel)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_controlnet_inpainting.py#L174)
**Paramètres :**
transformer ([FluxTransformer2DModel](/docs/diffusers/main/fr/api/models/flux_transformer#diffusers.FluxTransformer2DModel)) : architecture Transformer conditionnelle (MMDiT) pour le débruitage des latents d'image encodés.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents d'image encodés.
vae ([AutoencoderKL](/docs/diffusers/main/fr/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des images vers et depuis des représentations latentes.
text_encoder (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), plus précisément la variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).
text_encoder_2 (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), plus précisément la variante [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).
tokenizer (`CLIPTokenizer`) : Tokenizer de la classe [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer).
tokenizer_2 (`T5TokenizerFast`) : Second Tokenizer de la classe [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).
Le pipeline de controlnet Flux pour l'inpainting.
Référence : https://blackforestlabs.ai/announcing-black-forest-labs/
#### __appel__[[diffusers.FluxControlNetInpaintPipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, mask_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, masked_image_latents: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, control_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, height: int | None = None, width: int | None = None, strength: float = 0.6, padding_mask_crop: int | None = None, sigmas: list[float] | None = None, num_inference_steps: int = 28, guidance_scale: float = 7.0, control_guidance_start: float | list[float] = 0.0, control_guidance_end: float | list[float] = 1.0, control_mode: int | list[int] | None = None, controlnet_conditioning_scale: float | list[float] = 1.0, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, output_type: str | None = 'pil', return_dict: bool = True, joint_attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_controlnet_inpainting.py#L741)
**Paramètres :**
prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts pour guider la génération d'image.
prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer au `tokenizer_2` et au `text_encoder_2`.
image (`PIL.Image.Image` ou `list[PIL.Image.Image]` ou `torch.FloatTensor`) : L'image ou les images à inpainter.
mask_image (`PIL.Image.Image` ou `list[PIL.Image.Image]` ou `torch.FloatTensor`) : L’image ou les images de masque à utiliser pour l’inpainting. Les pixels blancs du masque seront repeints, tandis que les pixels noirs seront conservés.
masked_image_latents (`torch.FloatTensor`, *facultatif*) : Latents d'image masquée pré-générés.
control_image (`PIL.Image.Image` ou `list[PIL.Image.Image]` ou `torch.FloatTensor`) : La condition d'entrée de ControlNet. L'image pour contrôler la génération.
height (`int`, *facultatif*, par défaut self.default_sample_size * self.vae_scale_factor) : La hauteur en pixels de l'image générée.
width (`int`, *facultatif*, par défaut self.default_sample_size * self.vae_scale_factor) : La largeur en pixels de l'image générée.
strength (`float`, *facultatif*, valeur par défaut 0,6) : Indique conceptuellement dans quelle mesure la zone masquée doit être réintégrée. Doit être compris entre 0 et 1.
padding_mask_crop (`int`, *facultatif*) : La taille du bourrage à utiliser lors de la rognage du masque.
num_inference_steps (`int`, *facultatif*, valeur par défaut 28) : 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.
sigmas (`list[float]`, *facultatif*) : Sigmas personnalisés à utiliser pour le processus de débruitage avec les planificateurs qui prennent en charge un argument `sigmas` dans leur méthode `set_timesteps`. S'ils ne sont pas définis, le comportement par défaut lorsque `num_inference_steps` est passé sera utilisé.
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).
control_guidance_start (`float` ou `list[float]`, *facultatif*, valeur par défaut 0.0) : Le pourcentage des étapes totales à partir duquel le ControlNet commence à s'appliquer.
control_guidance_end (`float` ou `list[float]`, *facultatif*, par défaut 1.0) : Le pourcentage des étapes totales auquel le ControlNet cesse d’appliquer son effet.
control_mode (`int` ou `list[int]`, *facultatif*) : Le mode du ControlNet. Si plusieurs ControlNets sont utilisés, cela doit être une liste.
controlnet_conditioning_scale (`float` ou `list[float]`, *facultatif*, valeur par défaut 1.0) : Les sorties du ControlNet sont multipliées par `controlnet_conditioning_scale` avant d'être ajoutées au résidu dans le transformer d'origine.
num_images_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre d'images à générer par invite.
generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Un ou plusieurs [générateurs torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) pour rendre la génération déterministe.
latents (`torch.FloatTensor`, *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.
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 exemple* le pondération des prompts.
pooled_prompt_embeds (`torch.FloatTensor`, *facultatif*) : Embeddings de texte pré-générés.
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*, valeur par défaut `True`) : Indique s'il faut retourner un `~pipelines.flux.FluxPipelineOutput` plutôt qu'un simple tuple.
joint_attention_kwargs (`dict`, *facultatif*) : Arguments supplémentaires à passer au mécanisme d'attention conjointe.
callback_on_step_end (`Callable`, *facultatif*) : Une fonction appelée à la fin de chaque étape de débruitage pendant l'inférence.
callback_on_step_end_tensor_inputs (`list[str]`, *facultatif*) : La liste des entrées de tenseurs pour la fonction `callback_on_step_end`.
max_sequence_length (`int`, *facultatif*, valeur par défaut 512) : La longueur maximale de la séquence à générer.
**Retourne :** `~pipelines.flux.FluxPipelineOutput` ou `tuple`
`~pipelines.flux.FluxPipelineOutput` si `return_dict` est True, sinon un `tuple`. En cas de retour d'un tuple, le premier élément est une liste contenant les images générées.
Fonction appelée lors de l'appel du pipeline pour la génération.
Exemples :
```py
>>> import torch
>>> from diffusers import FluxControlNetInpaintPipeline
>>> from diffusers.models import FluxControlNetModel
>>> from diffusers.utils import load_image
>>> controlnet = FluxControlNetModel.from_pretrained(
... "InstantX/FLUX.1-dev-controlnet-canny", torch_dtype=torch.float16
... )
>>> pipe = FluxControlNetInpaintPipeline.from_pretrained(
... "black-forest-labs/FLUX.1-schnell", controlnet=controlnet, torch_dtype=torch.float16
... )
>>> pipe.to("cuda")
>>> control_image = load_image(
... "https://huggingface.co/InstantX/FLUX.1-dev-Controlnet-Canny-alpha/resolve/main/canny.jpg"
... )
>>> init_image = load_image(
... "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png"
... )
>>> mask_image = load_image(
... "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo_mask.png"
... )
>>> prompt = "A girl holding a sign that says InstantX"
>>> image = pipe(
... prompt,
... image=init_image,
... mask_image=mask_image,
... control_image=control_image,
... control_guidance_start=0.2,
... control_guidance_end=0.8,
... controlnet_conditioning_scale=0.7,
... strength=0.7,
... num_inference_steps=28,
... guidance_scale=3.5,
... ).images[0]
>>> image.save("flux_controlnet_inpaint.png")
```
#### encode_prompt[[diffusers.FluxControlNetInpaintPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], prompt_2: str | list[str] | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, max_sequence_length: int = 512, lora_scale: float | None = None)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_controlnet_inpainting.py#L349)
**Paramètres :**
prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder
prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer au `tokenizer_2` et au `text_encoder_2`. S'il n'est pas défini, `prompt` est utilisé dans tous les encodeurs de texte
device : (`torch.device`) : appareil torch
num_images_per_prompt (`int`) : nombre d'images à générer par invite
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`.
pooled_prompt_embeds (`torch.FloatTensor`, *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`.
lora_scale (`float`, *facultatif*) : Échelle LoRA appliquée à toutes les couches LoRA de l'encodeur de texte si des couches LoRA sont chargées.
## FluxControlNetImg2ImgPipeline[[diffusers.FluxControlNetImg2ImgPipeline]]
#### diffusers.FluxControlNetImg2ImgPipeline[[diffusers.FluxControlNetImg2ImgPipeline]]
```python
diffusers.FluxControlNetImg2ImgPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, text_encoder_2: T5EncoderModel, tokenizer_2: T5Tokenizer, transformer: FluxTransformer2DModel, controlnet: diffusers.models.controlnets.controlnet_flux.FluxControlNetModel | list[diffusers.models.controlnets.controlnet_flux.FluxControlNetModel] | tuple[diffusers.models.controlnets.controlnet_flux.FluxControlNetModel] | diffusers.models.controlnets.controlnet_flux.FluxMultiControlNetModel)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_controlnet_image_to_image.py#L172)
**Paramètres :**
transformer ([FluxTransformer2DModel](/docs/diffusers/main/fr/api/models/flux_transformer#diffusers.FluxTransformer2DModel)) : architecture Transformer conditionnelle (MMDiT) pour le débruitage des latents d'image encodés.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents d'image encodés.
vae ([AutoencoderKL](/docs/diffusers/main/fr/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des images vers et depuis des représentations latentes.
text_encoder (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), plus précisément la variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).
text_encoder_2 (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), plus précisément la variante [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).
tokenizer (`CLIPTokenizer`) : Tokenizer de la classe [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer).
tokenizer_2 (`T5TokenizerFast`) : Second Tokenizer de la classe [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).
Le pipeline Flux controlnet pour la génération d’image à partir d’image.
Référence : https://blackforestlabs.ai/announcing-black-forest-labs/
#### __appel__[[diffusers.FluxControlNetImg2ImgPipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, control_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, height: int | None = None, width: int | None = None, strength: float = 0.6, num_inference_steps: int = 28, sigmas: list[float] | None = None, guidance_scale: float = 7.0, control_guidance_start: float | list[float] = 0.0, control_guidance_end: float | list[float] = 1.0, control_mode: int | list[int] | None = None, controlnet_conditioning_scale: float | list[float] = 1.0, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, output_type: str | None = 'pil', return_dict: bool = True, joint_attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_controlnet_image_to_image.py#L637)
**Paramètres :**
prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts pour guider la génération d'image.
prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer au `tokenizer_2` et au `text_encoder_2`.
image (`PIL.Image.Image` ou `list[PIL.Image.Image]` ou `torch.FloatTensor`) : L'image ou les images à modifier avec le pipeline.
control_image (`PIL.Image.Image` ou `list[PIL.Image.Image]` ou `torch.FloatTensor`) : La condition d'entrée de ControlNet. L'image pour contrôler la génération.
height (`int`, *facultatif*, par défaut self.default_sample_size * self.vae_scale_factor) : La hauteur en pixels de l'image générée.
width (`int`, *facultatif*, par défaut self.default_sample_size * self.vae_scale_factor) : La largeur en pixels de l'image générée.
strength (`float`, *facultatif*, valeur par défaut 0.6) : Indique conceptuellement dans quelle mesure transformer l'`image` de référence. Doit être compris entre 0 et 1.
num_inference_steps (`int`, *facultatif*, valeur par défaut 28) : 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.
sigmas (`list[float]`, *facultatif*) : Sigmas personnalisés à utiliser pour le processus de débruitage avec les planificateurs qui prennent en charge un argument `sigmas` dans leur méthode `set_timesteps`. S'ils ne sont pas définis, le comportement par défaut lorsque `num_inference_steps` est passé sera utilisé.
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).
control_mode (`int` ou `list[int]`, *facultatif*) : Le mode du ControlNet. Si plusieurs ControlNets sont utilisés, cela doit être une liste.
controlnet_conditioning_scale (`float` ou `list[float]`, *facultatif*, valeur par défaut 1.0) : Les sorties du ControlNet sont multipliées par `controlnet_conditioning_scale` avant d'être ajoutées au résidu dans le transformer d'origine.
control_guidance_start (`float` ou `list[float]`, *facultatif*, valeur par défaut 0.0) : Le pourcentage des étapes totales à partir duquel le ControlNet commence à s'appliquer.
control_guidance_end (`float` ou `list[float]`, *facultatif*, par défaut 1.0) : Le pourcentage des étapes totales auquel le ControlNet cesse d’appliquer son effet.
num_images_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre d'images à générer par invite.
generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Un ou plusieurs [générateurs torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) pour rendre la génération déterministe.
latents (`torch.FloatTensor`, *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.
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 exemple* le pondération des prompts.
pooled_prompt_embeds (`torch.FloatTensor`, *facultatif*) : Embeddings de texte pré-générés.
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*, valeur par défaut `True`) : Indique s'il faut retourner un `~pipelines.flux.FluxPipelineOutput` plutôt qu'un simple tuple.
joint_attention_kwargs (`dict`, *facultatif*) : Arguments supplémentaires à passer au mécanisme d'attention conjointe.
callback_on_step_end (`Callable`, *facultatif*) : Une fonction appelée à la fin de chaque étape de débruitage pendant l'inférence.
callback_on_step_end_tensor_inputs (`list[str]`, *facultatif*) : La liste des entrées de tenseurs pour la fonction `callback_on_step_end`.
max_sequence_length (`int`, *facultatif*, valeur par défaut 512) : La longueur maximale de la séquence à générer.
**Retourne :** `~pipelines.flux.FluxPipelineOutput` ou `tuple`
`~pipelines.flux.FluxPipelineOutput` si `return_dict` est True, sinon un `tuple`. En cas de retour d'un tuple, le premier élément est une liste contenant les images générées.
Fonction appelée lors de l'appel du pipeline pour la génération.
Exemples :
```py
>>> import torch
>>> from diffusers import FluxControlNetImg2ImgPipeline, FluxControlNetModel
>>> from diffusers.utils import load_image
>>> device = "cuda" if torch.cuda.is_available() else "cpu"
>>> controlnet = FluxControlNetModel.from_pretrained(
... "InstantX/FLUX.1-dev-Controlnet-Canny-alpha", torch_dtype=torch.bfloat16
... )
>>> pipe = FluxControlNetImg2ImgPipeline.from_pretrained(
... "black-forest-labs/FLUX.1-schnell", controlnet=controlnet, torch_dtype=torch.float16
... )
>>> pipe.text_encoder.to(torch.float16)
>>> pipe.controlnet.to(torch.float16)
>>> pipe.to("cuda")
>>> control_image = load_image("https://huggingface.co/InstantX/SD3-Controlnet-Canny/resolve/main/canny.jpg")
>>> init_image = load_image(
... "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg"
... )
>>> prompt = "A girl in city, 25 years old, cool, futuristic"
>>> image = pipe(
... prompt,
... image=init_image,
... control_image=control_image,
... control_guidance_start=0.2,
... control_guidance_end=0.8,
... controlnet_conditioning_scale=1.0,
... strength=0.7,
... num_inference_steps=2,
... guidance_scale=3.5,
... ).images[0]
>>> image.save("flux_controlnet_img2img.png")
```
#### encode_prompt[[diffusers.FluxControlNetImg2ImgPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], prompt_2: str | list[str] | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, max_sequence_length: int = 512, lora_scale: float | None = None)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_controlnet_image_to_image.py#L338)
**Paramètres :**
prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder
prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer au `tokenizer_2` et au `text_encoder_2`. S'il n'est pas défini, `prompt` est utilisé dans tous les encodeurs de texte
device : (`torch.device`) : appareil torch
num_images_per_prompt (`int`) : nombre d'images à générer par invite
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`.
pooled_prompt_embeds (`torch.FloatTensor`, *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`.
lora_scale (`float`, *facultatif*) : Échelle LoRA appliquée à toutes les couches LoRA de l'encodeur de texte si des couches LoRA sont chargées.
## FluxControlPipeline[[diffusers.FluxControlPipeline]]
#### diffusers.FluxControlPipeline[[diffusers.FluxControlPipeline]]
```python
diffusers.FluxControlPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, text_encoder_2: T5EncoderModel, tokenizer_2: T5Tokenizer, transformer: FluxTransformer2DModel)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_control.py#L159)
**Paramètres :**
transformer ([FluxTransformer2DModel](/docs/diffusers/main/fr/api/models/flux_transformer#diffusers.FluxTransformer2DModel)) : architecture Transformer conditionnelle (MMDiT) pour le débruitage des latents d'image encodés.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents d'image encodés.
vae ([AutoencoderKL](/docs/diffusers/main/fr/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des images vers et depuis des représentations latentes.
text_encoder (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), plus précisément la variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).
text_encoder_2 (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), plus précisément la variante [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).
tokenizer (`CLIPTokenizer`) : Tokenizer de la classe [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer).
tokenizer_2 (`T5TokenizerFast`) : Second Tokenizer de la classe [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).
Le pipeline Flux pour la génération contrôlée d'images à partir de texte avec des conditions d'image.
Référence : https://bfl.ai/flux-1-tools
#### __appel__[[diffusers.FluxControlPipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, control_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 28, sigmas: list[float] | None = None, guidance_scale: float = 3.5, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, output_type: str | None = 'pil', return_dict: bool = True, joint_attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_control.py#L583)
**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.
prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer à `tokenizer_2` et `text_encoder_2`. S'il n'est pas défini, `prompt` sera utilisé à la place
control_image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, `list[np.ndarray]`, : `list[list[torch.Tensor]]`, `list[list[np.ndarray]]` ou `list[list[PIL.Image.Image]]`) : La condition d’entrée ControlNet à fournir pour guider le `unet` lors de la génération. Si le type est spécifié comme `torch.Tensor`, il est transmis à ControlNet tel quel. `PIL.Image.Image` peut également être accepté en tant qu’image. Les dimensions de l’image de sortie sont par défaut celles de `image`. Si la hauteur et/ou la largeur sont passées, `image` est redimensionnée en conséquence. Si plusieurs ControlNets sont spécifiés dans `init`, les images doivent être passées sous forme de liste afin que chaque élément de la liste puisse être correctement groupé (batching) pour l’entrée d’un seul ControlNet.
height (`int`, *facultatif*, par défaut self.unet.config.sample_size * self.vae_scale_factor) : La hauteur en pixels de l'image générée. Cette valeur est fixée à 1024 par défaut pour obtenir les meilleurs résultats.
width (`int`, *facultatif*, par défaut self.unet.config.sample_size * self.vae_scale_factor) : La largeur en pixels de l'image générée. Cette valeur est fixée à 1024 par défaut pour obtenir les meilleurs résultats.
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.
sigmas (`list[float]`, *facultatif*) : Sigmas personnalisés à utiliser pour le processus de débruitage avec les planificateurs qui prennent en charge un argument `sigmas` dans leur méthode `set_timesteps`. S'ils ne sont pas définis, le comportement par défaut lorsque `num_inference_steps` est passé sera utilisé.
guidance_scale (`float`, *facultatif*, valeur par défaut 3,5) : L'échelle de guidage intégrée est activée en définissant `guidance_scale` > 1. Une valeur plus élevée de `guidance_scale` encourage le modèle à générer des images plus alignées avec le prompt, au détriment de la qualité de l'image. Les modèles distillés par guidage approximent le vrai guidage sans classifieur pour `guidance_scale` > 1. Consultez l'[article](https://huggingface.co/papers/2210.03142) pour en savoir plus.
num_images_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre d'images à générer par invite.
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.
latents (`torch.FloatTensor`, *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 sera généré par échantillonnage à l'aide du `generator` aléatoire fourni.
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`.
pooled_prompt_embeds (`torch.FloatTensor`, *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`.
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*, valeur par défaut `True`) : Indique s'il faut retourner un `~pipelines.flux.FluxPipelineOutput` plutôt qu'un simple tuple.
joint_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).
callback_on_step_end (`Callable`, *facultatif*) : une fonction appelée à la fin de chaque étape de débruitage pendant l’inférence. La fonction est appelée avec les arguments suivants : `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` contiendra une liste de tous les tenseurs, tels que spécifiés par `callback_on_step_end_tensor_inputs`.
callback_on_step_end_tensor_inputs (`list`, *facultatif*) : La liste des entrées tensorielles pour la fonction `callback_on_step_end`. Les tenseurs spécifiés dans la liste seront passés en tant qu'argument `callback_kwargs`. Vous ne pourrez inclure que les variables listées dans l'attribut `._callback_tensor_inputs` de votre classe de pipeline.
max_sequence_length (`int` par défaut 512) : Longueur maximale de la séquence à utiliser avec le `prompt`.
**Retourne :** `~pipelines.flux.FluxPipelineOutput` ou `tuple`
`~pipelines.flux.FluxPipelineOutput` si `return_dict` est True, sinon un `tuple`. En cas de retour d'un tuple, le premier élément est une liste contenant les images générées.
Fonction appelée lors de l'appel du pipeline pour la génération.
Exemples :
```py
>>> import torch
>>> from controlnet_aux import CannyDetector
>>> from diffusers import FluxControlPipeline
>>> from diffusers.utils import load_image
>>> pipe = FluxControlPipeline.from_pretrained(
... "black-forest-labs/FLUX.1-Canny-dev", torch_dtype=torch.bfloat16
... ).to("cuda")
>>> prompt = "A robot made of exotic candies and chocolates of different kinds. The background is filled with confetti and celebratory gifts."
>>> control_image = load_image(
... "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png"
... )
>>> processor = CannyDetector()
>>> control_image = processor(
... control_image, low_threshold=50, high_threshold=200, detect_resolution=1024, image_resolution=1024
... )
>>> image = pipe(
... prompt=prompt,
... control_image=control_image,
... height=1024,
... width=1024,
... num_inference_steps=50,
... guidance_scale=30.0,
... ).images[0]
>>> image.save("output.png")
```
#### encode_prompt[[diffusers.FluxControlPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], prompt_2: str | list[str] | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, max_sequence_length: int = 512, lora_scale: float | None = None)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_control.py#L326)
**Paramètres :**
prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder
prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer au `tokenizer_2` et au `text_encoder_2`. S'il n'est pas défini, `prompt` est utilisé dans tous les encodeurs de texte
device : (`torch.device`) : appareil torch
num_images_per_prompt (`int`) : nombre d'images à générer par invite
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`.
pooled_prompt_embeds (`torch.FloatTensor`, *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`.
lora_scale (`float`, *facultatif*) : Échelle LoRA appliquée à toutes les couches LoRA de l'encodeur de texte si des couches LoRA sont chargées.
## FluxControlImg2ImgPipeline[[diffusers.FluxControlImg2ImgPipeline]]
#### diffusers.FluxControlImg2ImgPipeline[[diffusers.FluxControlImg2ImgPipeline]]
```python
diffusers.FluxControlImg2ImgPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, text_encoder_2: T5EncoderModel, tokenizer_2: T5Tokenizer, transformer: FluxTransformer2DModel)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_control_img2img.py#L178)
**Paramètres :**
transformer ([FluxTransformer2DModel](/docs/diffusers/main/fr/api/models/flux_transformer#diffusers.FluxTransformer2DModel)) : architecture Transformer conditionnelle (MMDiT) pour le débruitage des latents d'image encodés.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents d'image encodés.
vae ([AutoencoderKL](/docs/diffusers/main/fr/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des images vers et depuis des représentations latentes.
text_encoder (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), plus précisément la variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).
text_encoder_2 (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), plus précisément la variante [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).
tokenizer (`CLIPTokenizer`) : Tokenizer de la classe [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer).
tokenizer_2 (`T5TokenizerFast`) : Second Tokenizer de la classe [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).
Le pipeline Flux pour l'inpainting d'images.
Référence : https://blackforestlabs.ai/announcing-black-forest-labs/
#### __appel__[[diffusers.FluxControlImg2ImgPipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, control_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, height: int | None = None, width: int | None = None, strength: float = 0.6, num_inference_steps: int = 28, sigmas: list[float] | None = None, guidance_scale: float = 7.0, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, output_type: str | None = 'pil', return_dict: bool = True, joint_attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_control_img2img.py#L636)
**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.
prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer à `tokenizer_2` et `text_encoder_2`. S'il n'est pas défini, `prompt` sera utilisé à la place
image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` ou `list[np.ndarray]`) : `Image`, tableau numpy ou tenseur représentant un lot d’images à utiliser comme point de départ. Pour un tableau numpy et un tenseur pytorch, la plage de valeurs attendue est comprise entre `[0, 1]`. S’il s’agit d’un tenseur ou d’une liste de tenseurs, la forme attendue doit être `(B, C, H, W)` ou `(C, H, W)`. S’il s’agit d’un tableau numpy ou d’une liste de tableaux, la forme attendue doit être `(B, H, W, C)` ou `(H, W, C)`. Il peut également accepter des latents d’image en tant que `image`, mais si des latents sont transmis directement, ils ne sont pas réencodés.
control_image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, `list[np.ndarray]`, : `list[list[torch.Tensor]]`, `list[list[np.ndarray]]` ou `list[list[PIL.Image.Image]]`) : La condition d’entrée ControlNet à fournir pour guider le `unet` lors de la génération. Si le type est spécifié comme `torch.Tensor`, il est transmis à ControlNet tel quel. `PIL.Image.Image` peut également être accepté en tant qu’image. Les dimensions de l’image de sortie sont par défaut celles de `image`. Si la hauteur et/ou la largeur sont passées, `image` est redimensionnée en conséquence. Si plusieurs ControlNets sont spécifiés dans `init`, les images doivent être passées sous forme de liste afin que chaque élément de la liste puisse être correctement groupé (batching) pour l’entrée d’un seul ControlNet.
height (`int`, *facultatif*, par défaut self.unet.config.sample_size * self.vae_scale_factor) : La hauteur en pixels de l'image générée. Cette valeur est fixée à 1024 par défaut pour obtenir les meilleurs résultats.
width (`int`, *facultatif*, par défaut self.unet.config.sample_size * self.vae_scale_factor) : La largeur en pixels de l'image générée. Cette valeur est fixée à 1024 par défaut pour obtenir les meilleurs résultats.
strength (`float`, *facultatif*, valeur par défaut 1.0) : Indique dans quelle mesure transformer l'`image` de référence. Doit être compris entre 0 et 1. `image` est utilisé comme point de départ et plus le `strength` est élevé, plus du bruit est ajouté. Le nombre d'étapes de débruitage dépend de la quantité de bruit initialement ajoutée. Lorsque `strength` vaut 1, le bruit ajouté est maximal et le processus de débruitage s'exécute pendant le nombre complet d'itérations spécifié dans `num_inference_steps`. Une valeur de 1 ignore 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.
sigmas (`list[float]`, *facultatif*) : Sigmas personnalisés à utiliser pour le processus de débruitage avec les planificateurs qui prennent en charge un argument `sigmas` dans leur méthode `set_timesteps`. S'ils ne sont pas définis, le comportement par défaut lorsque `num_inference_steps` est passé sera utilisé.
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.
num_images_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre d'images à générer par invite.
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.
latents (`torch.FloatTensor`, *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 sera généré par échantillonnage à l'aide du `generator` aléatoire fourni.
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`.
pooled_prompt_embeds (`torch.FloatTensor`, *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`.
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*, valeur par défaut `True`) : Indique s'il faut retourner un `~pipelines.flux.FluxPipelineOutput` plutôt qu'un simple tuple.
joint_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).
callback_on_step_end (`Callable`, *facultatif*) : une fonction appelée à la fin de chaque étape de débruitage pendant l’inférence. La fonction est appelée avec les arguments suivants : `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` contiendra une liste de tous les tenseurs, tels que spécifiés par `callback_on_step_end_tensor_inputs`.
callback_on_step_end_tensor_inputs (`list`, *facultatif*) : La liste des entrées tensorielles pour la fonction `callback_on_step_end`. Les tenseurs spécifiés dans la liste seront passés en tant qu'argument `callback_kwargs`. Vous ne pourrez inclure que les variables listées dans l'attribut `._callback_tensor_inputs` de votre classe de pipeline.
max_sequence_length (`int` par défaut 512) : Longueur maximale de la séquence à utiliser avec le `prompt`.
**Retourne :** `~pipelines.flux.FluxPipelineOutput` ou `tuple`
`~pipelines.flux.FluxPipelineOutput` si `return_dict` est True, sinon un `tuple`. En cas de retour d'un tuple, le premier élément est une liste contenant les images générées.
Fonction appelée lors de l'appel du pipeline pour la génération.
Exemples :
```py
>>> import torch
>>> from controlnet_aux import CannyDetector
>>> from diffusers import FluxControlImg2ImgPipeline
>>> from diffusers.utils import load_image
>>> pipe = FluxControlImg2ImgPipeline.from_pretrained(
... "black-forest-labs/FLUX.1-Canny-dev", torch_dtype=torch.bfloat16
... ).to("cuda")
>>> prompt = "A robot made of exotic candies and chocolates of different kinds. Abstract background"
>>> image = load_image(
... "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/watercolor-painting.jpg"
... )
>>> control_image = load_image(
... "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png"
... )
>>> processor = CannyDetector()
>>> control_image = processor(
... control_image, low_threshold=50, high_threshold=200, detect_resolution=1024, image_resolution=1024
... )
>>> image = pipe(
... prompt=prompt,
... image=image,
... control_image=control_image,
... strength=0.8,
... height=1024,
... width=1024,
... num_inference_steps=50,
... guidance_scale=30.0,
... ).images[0]
>>> image.save("output.png")
```
#### encode_prompt[[diffusers.FluxControlImg2ImgPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], prompt_2: str | list[str] | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, max_sequence_length: int = 512, lora_scale: float | None = None)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_control_img2img.py#L337)
**Paramètres :**
prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder
prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer au `tokenizer_2` et au `text_encoder_2`. S'il n'est pas défini, `prompt` est utilisé dans tous les encodeurs de texte
device : (`torch.device`) : appareil torch
num_images_per_prompt (`int`) : nombre d'images à générer par invite
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`.
pooled_prompt_embeds (`torch.FloatTensor`, *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`.
lora_scale (`float`, *facultatif*) : Échelle LoRA appliquée à toutes les couches LoRA de l'encodeur de texte si des couches LoRA sont chargées.
## FluxPriorReduxPipeline[[diffusers.FluxPriorReduxPipeline]]
#### diffusers.FluxPriorReduxPipeline[[diffusers.FluxPriorReduxPipeline]]
```python
diffusers.FluxPriorReduxPipeline(image_encoder: SiglipVisionModel, feature_extractor: SiglipImageProcessorPil, image_embedder: ReduxImageEncoder, text_encoder: CLIPTextModel = None, tokenizer: CLIPTokenizer = None, text_encoder_2: T5EncoderModel = None, tokenizer_2: T5Tokenizer = None)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_prior_redux.py#L83)
**Paramètres :**
image_encoder (`SiglipVisionModel`) : modèle de vision SIGLIP pour encoder l'image d'entrée.
feature_extractor (`SiglipImageProcessor`) : Processeur d'images pour la prétraitement des images destinées au modèle SIGLIP.
image_embedder (`ReduxImageEncoder`) : encodeur d'images Redux pour traiter les embeddings SIGLIP.
text_encoder (`CLIPTextModel`, *facultatif*) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), plus précisément la variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).
text_encoder_2 (`T5EncoderModel`, *facultatif*) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), plus précisément la variante [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).
tokenizer (`CLIPTokenizer`, *facultatif*) : Tokenizer de la classe [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer).
tokenizer_2 (`T5TokenizerFast`, *facultatif*) : Second Tokenizer de classe [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).
Le pipeline Flux Redux pour la génération d'image à partir d'image.
Référence : https://blackforestlabs.ai/flux-1-tools/
#### __appel__[[diffusers.FluxPriorReduxPipeline.__call__]]
```python
__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, prompt_embeds_scale: float | list[float] | None = 1.0, pooled_prompt_embeds_scale: float | list[float] | None = 1.0, return_dict: bool = True)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_prior_redux.py#L378)
**Paramètres :**
image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` ou `list[np.ndarray]`) : `Image`, tableau numpy ou tenseur représentant un lot d'images à utiliser comme point de départ. Pour un tableau numpy et un tenseur pytorch, la plage de valeurs attendue est comprise entre `[0, 1]` S'il s'agit d'un tenseur ou d'une liste de tenseurs, la forme attendue doit être `(B, C, H, W)` ou `(C, H, W)`. S'il s'agit d'un tableau numpy ou d'une liste de tableaux, la forme attendue doit être `(B, H, W, C)` ou `(H, W, C)`
prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts pour guider la génération d’image. **fonctionnalité expérimentale** : pour utiliser cette fonctionnalité, assurez-vous de charger explicitement les encodeurs de texte dans le pipeline. Les prompts seront ignorés si les encodeurs de texte ne sont pas chargés.
prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer au `tokenizer_2` et au `text_encoder_2`.
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 exemple* le pondération des prompts.
pooled_prompt_embeds (`torch.FloatTensor`, *facultatif*) : Embeddings de texte pré-générés.
prompt_embeds_scale (`float` ou `list[float]`, *facultatif*, valeur par défaut 1.0) : Facteur d'échelle (ou liste de facteurs d'échelle par image) appliqué aux embeddings de prompt redux avant leur retour.
pooled_prompt_embeds_scale (`float` ou `list[float]`, *facultatif*, valeur par défaut 1.0) : Facteur d'échelle (ou liste de facteurs d'échelle par image) appliqué aux embeddings de prompt regroupés par redux avant leur retour.
return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `~pipelines.flux.FluxPriorReduxPipelineOutput` plutôt qu'un simple tuple.
**Retourne :** `~pipelines.flux.FluxPriorReduxPipelineOutput` ou `tuple`
`~pipelines.flux.FluxPriorReduxPipelineOutput` si `return_dict` est True, sinon un `tuple`. En cas de retour d'un tuple, le premier élément est une liste contenant les images générées.
Fonction appelée lors de l'appel du pipeline pour la génération.
Exemples :
```py
>>> import torch
>>> from diffusers import FluxPriorReduxPipeline, FluxPipeline
>>> from diffusers.utils import load_image
>>> device = "cuda"
>>> dtype = torch.bfloat16
>>> repo_redux = "black-forest-labs/FLUX.1-Redux-dev"
>>> repo_base = "black-forest-labs/FLUX.1-dev"
>>> pipe_prior_redux = FluxPriorReduxPipeline.from_pretrained(repo_redux, torch_dtype=dtype).to(device)
>>> pipe = FluxPipeline.from_pretrained(
... repo_base, text_encoder=None, text_encoder_2=None, torch_dtype=torch.bfloat16
... ).to(device)
>>> image = load_image(
... "https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/style_ziggy/img5.png"
... )
>>> pipe_prior_output = pipe_prior_redux(image)
>>> images = pipe(
... guidance_scale=2.5,
... num_inference_steps=50,
... generator=torch.Generator("cpu").manual_seed(0),
... **pipe_prior_output,
... ).images
>>> images[0].save("flux-redux.png")
```
#### encode_prompt[[diffusers.FluxPriorReduxPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], prompt_2: str | list[str] | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, max_sequence_length: int = 512, lora_scale: float | None = None)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_prior_redux.py#L299)
**Paramètres :**
prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder
prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer au `tokenizer_2` et au `text_encoder_2`. S'il n'est pas défini, `prompt` est utilisé dans tous les encodeurs de texte
device : (`torch.device`) : appareil torch
num_images_per_prompt (`int`) : nombre d'images à générer par invite
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`.
pooled_prompt_embeds (`torch.FloatTensor`, *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`.
lora_scale (`float`, *facultatif*) : Échelle LoRA appliquée à toutes les couches LoRA de l'encodeur de texte si des couches LoRA sont chargées.
## FluxFillPipeline[[diffusers.FluxFillPipeline]]
#### diffusers.FluxFillPipeline[[diffusers.FluxFillPipeline]]
```python
diffusers.FluxFillPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, text_encoder_2: T5EncoderModel, tokenizer_2: T5Tokenizer, transformer: FluxTransformer2DModel)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_fill.py#L167)
**Paramètres :**
transformer ([FluxTransformer2DModel](/docs/diffusers/main/fr/api/models/flux_transformer#diffusers.FluxTransformer2DModel)) : architecture Transformer conditionnelle (MMDiT) pour le débruitage des latents d'image encodés.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents d'image encodés.
vae ([AutoencoderKL](/docs/diffusers/main/fr/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des images vers et depuis des représentations latentes.
text_encoder (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), plus précisément la variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).
text_encoder_2 (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), plus précisément la variante [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).
tokenizer (`CLIPTokenizer`) : Tokenizer de la classe [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer).
tokenizer_2 (`T5TokenizerFast`) : Second Tokenizer de la classe [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).
Le pipeline Flux Fill pour l'inpainting/outpainting d'images.
Référence : https://blackforestlabs.ai/flux-1-tools/
#### __appel__[[diffusers.FluxFillPipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, image: typing.Optional[torch.FloatTensor] = None, mask_image: typing.Optional[torch.FloatTensor] = None, masked_image_latents: typing.Optional[torch.FloatTensor] = None, height: int | None = None, width: int | None = None, strength: float = 1.0, num_inference_steps: int = 50, sigmas: list[float] | None = None, guidance_scale: float = 30.0, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, output_type: str | None = 'pil', return_dict: bool = True, joint_attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_fill.py#L700)
**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.
prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer à `tokenizer_2` et `text_encoder_2`. S'il n'est pas défini, `prompt` sera utilisé à la place
image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` ou `list[np.ndarray]`) : `Image`, tableau numpy ou tenseur représentant un lot d'images à utiliser comme point de départ. Pour un tableau numpy et un tenseur pytorch, la plage de valeurs attendue est comprise entre `[0, 1]` S'il s'agit d'un tenseur ou d'une liste de tenseurs, la forme attendue doit être `(B, C, H, W)` ou `(C, H, W)`. S'il s'agit d'un tableau numpy ou d'une liste de tableaux, la forme attendue doit être `(B, H, W, C)` ou `(H, W, C)`.
mask_image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` ou `list[np.ndarray]`) : `Image`, tableau numpy ou tenseur représentant un lot d'images à masquer `image`. Les pixels blancs du masque sont repeints tandis que les pixels noirs sont conservés. Si `mask_image` est une image PIL, elle est convertie en un seul canal (luminance) avant utilisation. S'il s'agit d'un tableau numpy ou d'un tenseur pytorch, il doit contenir un seul canal de couleur (L) au lieu de trois, de sorte que la forme attendue pour un tenseur pytorch serait `(B, 1, H, W)`, `(B, H, W)`, `(1, H, W)` ou `(H, W)`. Et pour un tableau numpy, elle serait `(B, H, W, 1)`, `(B, H, W)`, `(H, W, 1)` ou `(H, W)`.
masked_image_latents (`torch.Tensor`, `list[torch.Tensor]`) : `Tensor` représentant un lot d'images pour masquer `image` générée par le VAE. Si non fourni, le tenseur de latents du masque sera généré par `mask_image`.
height (`int`, *facultatif*, par défaut self.unet.config.sample_size * self.vae_scale_factor) : La hauteur en pixels de l'image générée. Cette valeur est fixée à 1024 par défaut pour obtenir les meilleurs résultats.
width (`int`, *facultatif*, par défaut self.unet.config.sample_size * self.vae_scale_factor) : La largeur en pixels de l'image générée. Cette valeur est fixée à 1024 par défaut pour obtenir les meilleurs résultats.
strength (`float`, *facultatif*, valeur par défaut 1.0) : Indique dans quelle mesure transformer l'`image` de référence. Doit être compris entre 0 et 1. `image` est utilisé comme point de départ et plus le `strength` est élevé, plus du bruit est ajouté. Le nombre d'étapes de débruitage dépend de la quantité de bruit initialement ajoutée. Lorsque `strength` vaut 1, le bruit ajouté est maximal et le processus de débruitage s'exécute pendant le nombre complet d'itérations spécifié dans `num_inference_steps`. Une valeur de 1 ignore 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.
sigmas (`list[float]`, *facultatif*) : Sigmas personnalisés à utiliser pour le processus de débruitage avec les planificateurs qui prennent en charge un argument `sigmas` dans leur méthode `set_timesteps`. S'ils ne sont pas définis, le comportement par défaut lorsque `num_inference_steps` est passé sera utilisé.
guidance_scale (`float`, *facultatif*, valeur par défaut 30.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.
num_images_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre d'images à générer par invite.
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.
latents (`torch.FloatTensor`, *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 sera généré par échantillonnage à l'aide du `generator` aléatoire fourni.
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`.
pooled_prompt_embeds (`torch.FloatTensor`, *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`.
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*, valeur par défaut `True`) : Indique s'il faut retourner un `~pipelines.flux.FluxPipelineOutput` plutôt qu'un simple tuple.
joint_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).
callback_on_step_end (`Callable`, *facultatif*) : une fonction appelée à la fin de chaque étape de débruitage pendant l’inférence. La fonction est appelée avec les arguments suivants : `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` contiendra une liste de tous les tenseurs, tels que spécifiés par `callback_on_step_end_tensor_inputs`.
callback_on_step_end_tensor_inputs (`list`, *facultatif*) : La liste des entrées tensorielles pour la fonction `callback_on_step_end`. Les tenseurs spécifiés dans la liste seront passés en tant qu'argument `callback_kwargs`. Vous ne pourrez inclure que les variables listées dans l'attribut `._callback_tensor_inputs` de votre classe de pipeline.
max_sequence_length (`int` par défaut 512) : Longueur maximale de la séquence à utiliser avec le `prompt`.
**Retourne :** `~pipelines.flux.FluxPipelineOutput` ou `tuple`
`~pipelines.flux.FluxPipelineOutput` si `return_dict` est True, sinon un `tuple`. En cas de retour d'un tuple, le premier élément est une liste contenant les images générées.
Fonction appelée lors de l'appel du pipeline pour la génération.
Exemples :
```py
>>> import torch
>>> from diffusers import FluxFillPipeline
>>> from diffusers.utils import load_image
>>> image = load_image("https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/cup.png")
>>> mask = load_image("https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/cup_mask.png")
>>> pipe = FluxFillPipeline.from_pretrained("black-forest-labs/FLUX.1-Fill-dev", torch_dtype=torch.bfloat16)
>>> pipe.enable_model_cpu_offload() # save some VRAM by offloading the model to CPU
>>> image = pipe(
... prompt="a white paper cup",
... image=image,
... mask_image=mask,
... height=1632,
... width=1232,
... guidance_scale=30,
... num_inference_steps=50,
... max_sequence_length=512,
... generator=torch.Generator("cpu").manual_seed(0),
... ).images[0]
>>> image.save("flux_fill.png")
```
#### encode_prompt[[diffusers.FluxFillPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], prompt_2: str | list[str] | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, max_sequence_length: int = 512, lora_scale: float | None = None)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_fill.py#L421)
**Paramètres :**
prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder
prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer au `tokenizer_2` et au `text_encoder_2`. S'il n'est pas défini, `prompt` est utilisé dans tous les encodeurs de texte
device : (`torch.device`) : appareil torch
num_images_per_prompt (`int`) : nombre d'images à générer par invite
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`.
pooled_prompt_embeds (`torch.FloatTensor`, *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`.
lora_scale (`float`, *facultatif*) : Échelle LoRA appliquée à toutes les couches LoRA de l'encodeur de texte si des couches LoRA sont chargées.
## FluxKontextPipeline[[diffusers.FluxKontextPipeline]]
#### diffusers.FluxKontextPipeline[[diffusers.FluxKontextPipeline]]
```python
diffusers.FluxKontextPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, text_encoder_2: T5EncoderModel, tokenizer_2: T5Tokenizer, transformer: FluxTransformer2DModel, image_encoder: CLIPVisionModelWithProjection = None, feature_extractor: CLIPImageProcessorPil = None)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_kontext.py#L190)
**Paramètres :**
transformer ([FluxTransformer2DModel](/docs/diffusers/main/fr/api/models/flux_transformer#diffusers.FluxTransformer2DModel)) : architecture Transformer conditionnelle (MMDiT) pour le débruitage des latents d'image encodés.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents d'image encodés.
vae ([AutoencoderKL](/docs/diffusers/main/fr/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des images vers et depuis des représentations latentes.
text_encoder (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), plus précisément la variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).
text_encoder_2 (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), plus précisément la variante [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).
tokenizer (`CLIPTokenizer`) : Tokenizer de la classe [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer).
tokenizer_2 (`T5TokenizerFast`) : Second Tokenizer de la classe [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).
Le pipeline Flux Kontext pour la génération d’images à partir d’images et de texte.
Référence : https://bfl.ai/announcements/flux-1-kontext-dev
#### __appel__[[diffusers.FluxKontextPipeline.__call__]]
```python
__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, negative_prompt: str | list[str] = None, negative_prompt_2: str | list[str] | None = None, true_cfg_scale: float = 1.0, height: int | None = None, width: int | None = None, num_inference_steps: int = 28, sigmas: list[float] | None = None, guidance_scale: float = 3.5, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, negative_ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, negative_ip_adapter_image_embeds: list[torch.Tensor] | None = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, output_type: str | None = 'pil', return_dict: bool = True, joint_attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512, max_area: int = 1048576, _auto_resize: bool = True)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_kontext.py#L695)
**Paramètres :**
image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` ou `list[np.ndarray]`) : `Image`, tableau numpy ou tenseur représentant un lot d’images à utiliser comme point de départ. Pour un tableau numpy et un tenseur pytorch, la plage de valeurs attendue est comprise entre `[0, 1]`. S’il s’agit d’un tenseur ou d’une liste de tenseurs, la forme attendue doit être `(B, C, H, W)` ou `(C, H, W)`. S’il s’agit d’un tableau numpy ou d’une liste de tableaux, la forme attendue doit être `(B, H, W, C)` ou `(H, W, C)`. Il peut également accepter des latents d’image en tant que `image`, mais si des latents sont transmis directement, ils ne sont pas réencodés.
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.
prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer à `tokenizer_2` et `text_encoder_2`. S'il n'est pas défini, `prompt` sera utilisé à la place.
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. Ignoré lorsque le guidage n'est pas utilisé (c'est-à-dire ignoré si `true_cfg_scale` n'est pas supérieur à `1`).
negative_prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image, à envoyer à `tokenizer_2` et `text_encoder_2`. S’il n’est pas défini, `negative_prompt` est utilisé dans tous les encodeurs de texte.
true_cfg_scale (`float`, *facultatif*, valeur par défaut 1.0) : lorsque la valeur est supérieure à 1.0 et qu'un `negative_prompt` est fourni, active le vrai classifier-free guidance.
height (`int`, *facultatif*, par défaut self.unet.config.sample_size * self.vae_scale_factor) : La hauteur en pixels de l'image générée. Cette valeur est fixée à 1024 par défaut pour obtenir les meilleurs résultats.
width (`int`, *facultatif*, par défaut self.unet.config.sample_size * self.vae_scale_factor) : La largeur en pixels de l'image générée. Cette valeur est fixée à 1024 par défaut pour obtenir les meilleurs résultats.
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.
sigmas (`list[float]`, *facultatif*) : Sigmas personnalisés à utiliser pour le processus de débruitage avec les planificateurs qui prennent en charge un argument `sigmas` dans leur méthode `set_timesteps`. S'ils ne sont pas définis, le comportement par défaut lorsque `num_inference_steps` est passé sera utilisé.
guidance_scale (`float`, *facultatif*, valeur par défaut 3,5) : L'échelle de guidage intégrée est activée en définissant `guidance_scale` > 1. Une valeur plus élevée de `guidance_scale` encourage le modèle à générer des images plus alignées avec le prompt, au détriment de la qualité de l'image. Les modèles distillés par guidage approximent le vrai guidage sans classifieur pour `guidance_scale` > 1. Consultez l'[article](https://huggingface.co/papers/2210.03142) pour en savoir plus.
num_images_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre d'images à générer par invite.
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.
latents (`torch.FloatTensor`, *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 sera généré par échantillonnage à l'aide du `generator` aléatoire fourni.
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`.
pooled_prompt_embeds (`torch.FloatTensor`, *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`.
ip_adapter_image : (`PipelineImageInput`, *facultatif*) : Entrée d'image facultative pour travailler avec les IP Adapters.
ip_adapter_image_embeds (`list[torch.Tensor]`, *facultatif*) : Embeddings d'images pré-générés pour IP-Adapter. Il doit s'agir d'une liste dont la longueur est égale au nombre d'IP-adapters. Chaque élément doit être un tenseur de forme `(batch_size, num_images, emb_dim)`. S'il n'est pas fourni, les embeddings sont calculés à partir de l'argument d'entrée `ip_adapter_image`.
negative_ip_adapter_image : (`PipelineImageInput`, *facultatif*) : Entrée d'image facultative pour travailler avec les IP Adapters.
negative_ip_adapter_image_embeds (`list[torch.Tensor]`, *facultatif*) : Embeddings d'images pré-générés pour IP-Adapter. Il doit s'agir d'une liste dont la longueur est égale au nombre d'IP-adapters. Chaque élément doit être un tenseur de forme `(batch_size, num_images, emb_dim)`. S'il n'est pas fourni, les embeddings sont calculés à partir de l'argument d'entrée `ip_adapter_image`.
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`.
negative_pooled_prompt_embeds (`torch.FloatTensor`, *facultatif*) : Embeddings de texte négatifs 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, les pooled negative_prompt_embeds seront 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](https://pillow.readthedocs.io/en/stable/) : `PIL.Image.Image` ou `np.array`.
return_dict (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut retourner un `~pipelines.flux.FluxPipelineOutput` plutôt qu'un simple tuple.
joint_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).
callback_on_step_end (`Callable`, *facultatif*) : une fonction appelée à la fin de chaque étape de débruitage pendant l’inférence. La fonction est appelée avec les arguments suivants : `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` contiendra une liste de tous les tenseurs, tels que spécifiés par `callback_on_step_end_tensor_inputs`.
callback_on_step_end_tensor_inputs (`list`, *facultatif*) : La liste des entrées tensorielles pour la fonction `callback_on_step_end`. Les tenseurs spécifiés dans la liste seront passés en tant qu'argument `callback_kwargs`. Vous ne pourrez inclure que les variables listées dans l'attribut `._callback_tensor_inputs` de votre classe de pipeline.
max_sequence_length (`int` par défaut 512) : Longueur maximale de la séquence à utiliser avec le `prompt`.
max_area (`int`, par défaut `1024 ** 2`) : La surface maximale de l'image générée, en pixels. La hauteur et la largeur seront ajustées pour s'adapter à cette surface tout en conservant le ratio d'aspect.
_auto_resize (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut redimensionner automatiquement l'image d'entrée aux résolutions préférées.
**Retourne :** `~pipelines.flux.FluxPipelineOutput` ou `tuple`
`~pipelines.flux.FluxPipelineOutput` si `return_dict` est True, sinon un `tuple`. En cas de retour d'un tuple, le premier élément est une liste contenant les images générées.
Fonction appelée lors de l'appel du pipeline pour la génération.
Exemples :
```py
>>> import torch
>>> from diffusers import FluxKontextPipeline
>>> from diffusers.utils import load_image
>>> pipe = FluxKontextPipeline.from_pretrained(
... "black-forest-labs/FLUX.1-Kontext-dev", torch_dtype=torch.bfloat16
... )
>>> pipe.to("cuda")
>>> image = load_image(
... "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/yarn-art-pikachu.png"
... ).convert("RGB")
>>> prompt = "Make Pikachu hold a sign that says 'Black Forest Labs is awesome', yarn art style, detailed, vibrant colors"
>>> image = pipe(
... image=image,
... prompt=prompt,
... guidance_scale=2.5,
... generator=torch.Generator().manual_seed(42),
... ).images[0]
>>> image.save("output.png")
```
#### encode_prompt[[diffusers.FluxKontextPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], prompt_2: str | list[str] | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, max_sequence_length: int = 512, lora_scale: float | None = None)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_kontext.py#L360)
**Paramètres :**
prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder
prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer au `tokenizer_2` et au `text_encoder_2`. S'il n'est pas défini, `prompt` est utilisé dans tous les encodeurs de texte
device : (`torch.device`) : appareil torch
num_images_per_prompt (`int`) : nombre d'images à générer par invite
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`.
pooled_prompt_embeds (`torch.FloatTensor`, *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`.
lora_scale (`float`, *facultatif*) : Échelle LoRA appliquée à toutes les couches LoRA de l'encodeur de texte si des couches LoRA sont chargées.
## FluxKontextInpaintPipeline[[diffusers.FluxKontextInpaintPipeline]]
#### diffusers.FluxKontextInpaintPipeline[[diffusers.FluxKontextInpaintPipeline]]
```python
diffusers.FluxKontextInpaintPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, text_encoder_2: T5EncoderModel, tokenizer_2: T5Tokenizer, transformer: FluxTransformer2DModel, image_encoder: CLIPVisionModelWithProjection = None, feature_extractor: CLIPImageProcessorPil = None)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_kontext_inpaint.py#L214)
**Paramètres :**
transformer ([FluxTransformer2DModel](/docs/diffusers/main/fr/api/models/flux_transformer#diffusers.FluxTransformer2DModel)) : architecture Transformer conditionnelle (MMDiT) pour le débruitage des latents d'image encodés.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents d'image encodés.
vae ([AutoencoderKL](/docs/diffusers/main/fr/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des images vers et depuis des représentations latentes.
text_encoder (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), plus précisément la variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).
text_encoder_2 (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), plus précisément la variante [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl).
tokenizer (`CLIPTokenizer`) : Tokenizer de la classe [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer).
tokenizer_2 (`T5TokenizerFast`) : Second Tokenizer de la classe [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).
Le pipeline Flux Kontext pour la génération d'images à partir de texte.
Référence : https://blackforestlabs.ai/announcing-black-forest-labs/
#### __appel__[[diffusers.FluxKontextInpaintPipeline.__call__]]
```python
__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, image_reference: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, mask_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, negative_prompt: str | list[str] = None, negative_prompt_2: str | list[str] | None = None, true_cfg_scale: float = 1.0, height: int | None = None, width: int | None = None, strength: float = 1.0, padding_mask_crop: int | None = None, num_inference_steps: int = 28, sigmas: list[float] | None = None, guidance_scale: float = 3.5, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, negative_ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, negative_ip_adapter_image_embeds: list[torch.Tensor] | None = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, output_type: str | None = 'pil', return_dict: bool = True, joint_attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512, max_area: int = 1048576, _auto_resize: bool = True)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_kontext_inpaint.py#L884)
**Paramètres :**
image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` ou `list[np.ndarray]`) : `Image`, tableau numpy ou tenseur représentant un lot d’images à inpainter (les parties de l’image à masquer avec `mask_image` et à repeindre selon `prompt` et `image_reference`). Pour un tableau numpy comme pour un tenseur pytorch, la plage de valeurs attendue est comprise entre `[0, 1]`. S’il s’agit d’un tenseur ou d’une liste de tenseurs, la forme attendue doit être `(B, C, H, W)` ou `(C, H, W)`. S’il s’agit d’un tableau numpy ou d’une liste de tableaux, la forme attendue doit être `(B, H, W, C)` ou `(H, W, C)`. Il peut également accepter des latents d’image en tant que `image`, mais si des latents sont transmis directement, ils ne sont pas réencodés.
image_reference (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` ou `list[np.ndarray]`) : `Image`, tableau numpy ou tenseur représentant un lot d’images à utiliser comme point de départ pour la zone masquée. Pour un tableau numpy et un tenseur pytorch, la plage de valeurs attendue est comprise entre `[0, 1]` S’il s’agit d’un tenseur ou d’une liste de tenseurs, la forme attendue doit être `(B, C, H, W)` ou `(C, H, W)` S’il s’agit d’un tableau numpy ou d’une liste de tableaux, la forme attendue doit être `(B, H, W, C)` ou `(H, W, C)` Il peut également accepter des latents d’image en tant que `image`, mais si des latents sont transmis directement, ils ne sont pas réencodés.
mask_image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` ou `list[np.ndarray]`) : `Image`, tableau numpy ou tenseur représentant un lot d'images à masquer `image`. Les pixels blancs du masque sont repeints tandis que les pixels noirs sont conservés. Si `mask_image` est une image PIL, elle est convertie en un seul canal (luminance) avant utilisation. S'il s'agit d'un tableau numpy ou d'un tenseur pytorch, il doit contenir un seul canal de couleur (L) au lieu de trois, de sorte que la forme attendue pour un tenseur pytorch serait `(B, 1, H, W)`, `(B, H, W)`, `(1, H, W)` ou `(H, W)`. Et pour un tableau numpy, elle serait `(B, H, W, 1)`, `(B, H, W)`, `(H, W, 1)` ou `(H, W)`.
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.
prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer à `tokenizer_2` et `text_encoder_2`. S'il n'est pas défini, `prompt` sera utilisé à la place.
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. Ignoré lorsque le guidage n'est pas utilisé (c'est-à-dire ignoré si `true_cfg_scale` n'est pas supérieur à `1`).
negative_prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image, à envoyer à `tokenizer_2` et `text_encoder_2`. S’il n’est pas défini, `negative_prompt` est utilisé dans tous les encodeurs de texte.
true_cfg_scale (`float`, *facultatif*, valeur par défaut 1.0) : le guidance sans classifieur (échelle de guidance) est activé lorsque `true_cfg_scale` > 1 et que `negative_prompt` est fourni.
height (`int`, *facultatif*, par défaut self.unet.config.sample_size * self.vae_scale_factor) : La hauteur en pixels de l'image générée. Cette valeur est fixée à 1024 par défaut pour obtenir les meilleurs résultats.
width (`int`, *facultatif*, par défaut self.unet.config.sample_size * self.vae_scale_factor) : La largeur en pixels de l'image générée. Cette valeur est fixée à 1024 par défaut pour obtenir les meilleurs résultats.
strength (`float`, *facultatif*, valeur par défaut 1.0) : Indique dans quelle mesure transformer l'`image` de référence. Doit être compris entre 0 et 1. `image` est utilisé comme point de départ et plus le `strength` est élevé, plus du bruit est ajouté. Le nombre d'étapes de débruitage dépend de la quantité de bruit initialement ajoutée. Lorsque `strength` vaut 1, le bruit ajouté est maximal et le processus de débruitage s'exécute pendant le nombre complet d'itérations spécifié dans `num_inference_steps`. Une valeur de 1 ignore essentiellement `image`.
padding_mask_crop (`int`, *facultatif*, valeur par défaut `None`) : La taille de la marge dans le recadrage à appliquer à l'image et au masquage. Si `None`, aucun recadrage n'est appliqué à l'image et à mask_image. Si `padding_mask_crop` n'est pas `None`, il recherche d'abord une région rectangulaire ayant le même ratio d'aspect que l'image et contenant toute la zone masquée, puis élargit cette zone en fonction de `padding_mask_crop`. L'image et mask_image sont ensuite recadrées en fonction de la zone élargie avant d'être redimensionnées à la taille de l'image d'origine pour l'inpainting. Cela est utile lorsque la zone masquée est petite tandis que l'image est grande et contient des informations non pertinentes pour l'inpainting, telles que l'arrière-plan.
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.
sigmas (`list[float]`, *facultatif*) : Sigmas personnalisés à utiliser pour le processus de débruitage avec les planificateurs qui prennent en charge un argument `sigmas` dans leur méthode `set_timesteps`. S'ils ne sont pas définis, le comportement par défaut lorsque `num_inference_steps` est passé sera utilisé.
guidance_scale (`float`, *facultatif*, valeur par défaut 3,5) : L'échelle de guidage intégrée est activée en définissant `guidance_scale` > 1. Une valeur plus élevée de `guidance_scale` encourage le modèle à générer des images plus alignées avec le `prompt`, au détriment de la qualité de l'image. Les modèles distillés par guidage approximent le vrai guidage sans classifieur pour `guidance_scale` > 1. Consultez l'[article](https://huggingface.co/papers/2210.03142) pour en savoir plus.
num_images_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre d'images à générer par invite.
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.
latents (`torch.FloatTensor`, *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 sera généré par échantillonnage à l'aide du `generator` aléatoire fourni.
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`.
pooled_prompt_embeds (`torch.FloatTensor`, *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`.
ip_adapter_image : (`PipelineImageInput`, *facultatif*) : Entrée d'image facultative pour travailler avec les IP Adapters.
ip_adapter_image_embeds (`list[torch.Tensor]`, *facultatif*) : Embeddings d'images pré-générés pour IP-Adapter. Il doit s'agir d'une liste dont la longueur est égale au nombre d'IP-adapters. Chaque élément doit être un tenseur de forme `(batch_size, num_images, emb_dim)`. S'il n'est pas fourni, les embeddings sont calculés à partir de l'argument d'entrée `ip_adapter_image`.
negative_ip_adapter_image : (`PipelineImageInput`, *facultatif*) : Entrée d'image facultative pour travailler avec les IP Adapters.
negative_ip_adapter_image_embeds (`list[torch.Tensor]`, *facultatif*) : Embeddings d'images pré-générés pour IP-Adapter. Il doit s'agir d'une liste dont la longueur est égale au nombre d'IP-adapters. Chaque élément doit être un tenseur de forme `(batch_size, num_images, emb_dim)`. S'il n'est pas fourni, les embeddings sont calculés à partir de l'argument d'entrée `ip_adapter_image`.
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`.
negative_pooled_prompt_embeds (`torch.FloatTensor`, *facultatif*) : Embeddings de texte négatifs 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, les pooled negative_prompt_embeds seront 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](https://pillow.readthedocs.io/en/stable/) : `PIL.Image.Image` ou `np.array`.
return_dict (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut retourner un `~pipelines.flux.FluxPipelineOutput` plutôt qu'un simple tuple.
joint_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).
callback_on_step_end (`Callable`, *facultatif*) : une fonction appelée à la fin de chaque étape de débruitage pendant l’inférence. La fonction est appelée avec les arguments suivants : `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` contiendra une liste de tous les tenseurs, tels que spécifiés par `callback_on_step_end_tensor_inputs`.
callback_on_step_end_tensor_inputs (`list`, *facultatif*) : La liste des entrées tensorielles pour la fonction `callback_on_step_end`. Les tenseurs spécifiés dans la liste seront passés en tant qu'argument `callback_kwargs`. Vous ne pourrez inclure que les variables listées dans l'attribut `._callback_tensor_inputs` de votre classe de pipeline.
max_sequence_length (`int` par défaut 512) : Longueur maximale de la séquence à utiliser avec le `prompt`.
max_area (`int`, par défaut `1024 ** 2`) : La surface maximale de l'image générée, en pixels. La hauteur et la largeur seront ajustées pour s'adapter à cette surface tout en conservant le ratio d'aspect.
_auto_resize (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut redimensionner automatiquement l'image d'entrée aux résolutions préférées.
**Retourne :** `~pipelines.flux.FluxPipelineOutput` ou `tuple`
`~pipelines.flux.FluxPipelineOutput` si `return_dict` est True, sinon un `tuple`. En cas de retour d'un tuple, le premier élément est une liste contenant les images générées.
Fonction appelée lors de l'appel du pipeline pour la génération.
Exemples :
# Inpainting avec du texte uniquement
```py
>>> import torch
>>> from diffusers import FluxKontextInpaintPipeline
>>> from diffusers.utils import load_image
>>> prompt = "Change the yellow dinosaur to green one"
>>> img_url = (
... "https://github.com/ZenAI-Vietnam/Flux-Kontext-pipelines/blob/main/assets/dinosaur_input.jpeg?raw=true"
... )
>>> mask_url = (
... "https://github.com/ZenAI-Vietnam/Flux-Kontext-pipelines/blob/main/assets/dinosaur_mask.png?raw=true"
... )
>>> source = load_image(img_url)
>>> mask = load_image(mask_url)
>>> pipe = FluxKontextInpaintPipeline.from_pretrained(
... "black-forest-labs/FLUX.1-Kontext-dev", torch_dtype=torch.bfloat16
... )
>>> pipe.to("cuda")
>>> image = pipe(prompt=prompt, image=source, mask_image=mask, strength=1.0).images[0]
>>> image.save("kontext_inpainting_normal.png")
```
# Inpainting avec conditionnement par image
```py
>>> import torch
>>> from diffusers import FluxKontextInpaintPipeline
>>> from diffusers.utils import load_image
>>> pipe = FluxKontextInpaintPipeline.from_pretrained(
... "black-forest-labs/FLUX.1-Kontext-dev", torch_dtype=torch.bfloat16
... )
>>> pipe.to("cuda")
>>> prompt = "Replace this ball"
>>> img_url = "https://images.pexels.com/photos/39362/the-ball-stadion-football-the-pitch-39362.jpeg?auto=compress&cs=tinysrgb&dpr=1&w=500"
>>> mask_url = (
... "https://github.com/ZenAI-Vietnam/Flux-Kontext-pipelines/blob/main/assets/ball_mask.png?raw=true"
... )
>>> image_reference_url = (
... "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTah3x6OL_ECMBaZ5ZlJJhNsyC-OSMLWAI-xw&s"
... )
>>> source = load_image(img_url)
>>> mask = load_image(mask_url)
>>> image_reference = load_image(image_reference_url)
>>> mask = pipe.mask_processor.blur(mask, blur_factor=12)
>>> image = pipe(
... prompt=prompt, image=source, mask_image=mask, image_reference=image_reference, strength=1.0
... ).images[0]
>>> image.save("kontext_inpainting_ref.png")
```
#### encode_prompt[[diffusers.FluxKontextInpaintPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], prompt_2: str | list[str] | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.FloatTensor] = None, pooled_prompt_embeds: typing.Optional[torch.FloatTensor] = None, max_sequence_length: int = 512, lora_scale: float | None = None)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux/pipeline_flux_kontext_inpaint.py#L393)
**Paramètres :**
prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder
prompt_2 (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à envoyer au `tokenizer_2` et au `text_encoder_2`. S'il n'est pas défini, `prompt` est utilisé dans tous les encodeurs de texte
device : (`torch.device`) : appareil torch
num_images_per_prompt (`int`) : nombre d'images à générer par invite
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`.
pooled_prompt_embeds (`torch.FloatTensor`, *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`.
lora_scale (`float`, *facultatif*) : Échelle LoRA appliquée à toutes les couches LoRA de l'encodeur de texte si des couches LoRA sont chargées.
# Flux
Flux est une série de modèles de génération d'images à partir de texte basés sur des transformeurs de diffusion. Pour en savoir plus sur Flux, consultez le [article de blog](https://blackforestlabs.ai/announcing-black-forest-labs/) original des créateurs de Flux, Black Forest Labs.
Les points de contrôle originaux du modèle Flux peuvent être trouvés [ici](https://huggingface.co/black-forest-labs). Le code d'inférence original peut être trouvé [ici](https://github.com/black-forest-labs/flux).
> [!TIP]
> Flux peut être assez coûteux à exécuter sur du matériel grand public. Toutefois, vous pouvez effectuer une série d'optimisations pour l'exécuter plus rapidement et de manière plus économe en mémoire. Consultez [cette section](https://huggingface.co/blog/sd3#memory-optimizations-for-sd3) pour plus de détails. De plus, Flux peut bénéficier de la quantification pour une meilleure efficacité mémoire, au prix d'une latence d'inférence accrue. Reportez-vous à [ce billet de blog](https://huggingface.co/blog/quanto-diffusers) pour en savoir plus. Pour une liste exhaustive des ressources, consultez [ce gist](https://gist.github.com/sayakpaul/b664605caf0aa3bf8585ab109dd5ac9c).
>
> [La mise en cache](../../optimization/cache) peut également accélérer l'inférence en stockant et en réutilisant les sorties intermédiaires.
Flux est disponible dans les variantes suivantes :
| type de modèle | identifiant du modèle |
|:----------:|:--------:|
| Distillé par pas de temps | [`black-forest-labs/FLUX.1-schnell`](https://huggingface.co/black-forest-labs/FLUX.1-schnell) |
| Distillé par guidage | [`black-forest-labs/FLUX.1-dev`](https://huggingface.co/black-forest-labs/FLUX.1-dev) |
| Remplissage Inpainting/Outpainting (Guidance-distilled) | [`black-forest-labs/FLUX.1-Fill-dev`](https://huggingface.co/black-forest-labs/FLUX.1-Fill-dev) |
| Canny Control (Guidance distillée) | [`black-forest-labs/FLUX.1-Canny-dev`](https://huggingface.co/black-forest-labs/FLUX.1-Canny-dev) |
| Contrôle de la profondeur (Guidance distillée) | [`black-forest-labs/FLUX.1-Depth-dev`](https://huggingface.co/black-forest-labs/FLUX.1-Depth-dev) |
| Canny Control (LoRA) | [`black-forest-labs/FLUX.1-Canny-dev-lora`](https://huggingface.co/black-forest-labs/FLUX.1-Canny-dev-lora) |
| Contrôle de la profondeur (LoRA) | [`black-forest-labs/FLUX.1-Depth-dev-lora`](https://huggingface.co/black-forest-labs/FLUX.1-Depth-dev-lora) |
| Redux (adaptateur) | [`black-forest-labs/FLUX.1-Redux-dev`](https://huggingface.co/black-forest-labs/FLUX.1-Redux-dev) |
| Kontext | [`black-forest-labs/FLUX.1-kontext`](https://huggingface.co/black-forest-labs/FLUX.1-Kontext-dev) |
Tous les points de contrôle ont des usages différents, que nous détaillons ci-dessous.
### Distillé par pas de temps
* `max_sequence_length` ne peut pas dépasser 256.
* `guidance_scale` doit être 0.
* Étant donné qu'il s'agit d'un modèle distillé sur les pas de temps, il bénéficie d'un nombre réduit d'étapes d'échantillonnage.
```python
import torch
from diffusers import FluxPipeline
pipe = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", dtype=torch.bfloat16)
pipe.enable_model_cpu_offload()
prompt = "A cat holding a sign that says hello world"
out = pipe(
prompt=prompt,
guidance_scale=0.,
height=768,
width=1360,
num_inference_steps=4,
max_sequence_length=256,
).images[0]
out.save("image.png")
```
### Distillé par guidage
* La variante distillée par guidage nécessite environ 50 étapes d'échantillonnage pour une génération de bonne qualité.
* Il n'a aucune limitation concernant `max_sequence_length`.
```python
import torch
from diffusers import FluxPipeline
pipe = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-dev", dtype=torch.bfloat16)
pipe.enable_model_cpu_offload()
prompt = "a tiny astronaut hatching from an egg on the moon"
out = pipe(
prompt=prompt,
guidance_scale=3.5,
height=768,
width=1360,
num_inference_steps=50,
).images[0]
out.save("image.png")
```
### Remplissage Inpainting/Outpainting
* Le pipeline Flux Fill ne nécessite pas `strength` en entrée, contrairement aux pipelines d'inpainting classiques.
* Il prend en charge à la fois l'inpainting et l'outpainting.
```python
import torch
from diffusers import FluxFillPipeline
from diffusers.utils import load_image
image = load_image("https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/cup.png")
mask = load_image("https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/cup_mask.png")
repo_id = "black-forest-labs/FLUX.1-Fill-dev"
pipe = FluxFillPipeline.from_pretrained(repo_id, dtype=torch.bfloat16).to("cuda") # or "mps", "xpu", "cpu"
image = pipe(
prompt="a white paper cup",
image=image,
mask_image=mask,
height=1632,
width=1232,
Xet Storage Details
- Size:
- 181 kB
- Xet hash:
- 9d21ccc6873f1c9a2a4bb83bc9c86b4adb2300ea53d1ec686a886a23a48f31b8
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.