Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /main /fr /api /pipelines /flux2.md
mishig
3 days ago
preview code
download
raw
25.5 kB
# Flux2

  
  

Flux.2 est la série récente de modèles de génération d’images de Black Forest Labs, qui succède à la série [Flux.1](./flux). Il s’agit d’un modèle entièrement nouveau, doté d’une nouvelle architecture et d’un pré-entraînement effectué de zéro !

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

> [!TIP]
> Flux2 peut être relativement coûteux à exécuter sur du matériel grand public. Toutefois, vous pouvez appliquer 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.
>
> [La mise en cache](../../optimization/cache) peut également accélérer l'inférence en stockant et en réutilisant les sorties intermédiaires.

## Suréchantillonnage des légendes

Flux.2 peut potentiellement générer des résultats de meilleure qualité avec de meilleurs prompts. Il est possible de « remonter en résolution » un prompt d’entrée en définissant l’argument `caption_upsample_temperature` dans les arguments de l’appel du pipeline. L’[implémentation officielle](https://github.com/black-forest-labs/flux2/blob/5a5d316b1b42f6b59a8c9194b77c8256be848432/src/flux2/text_encoder.py#L140) recommande de fixer cette valeur à 0,15.

## Flux2Pipeline[[diffusers.Flux2Pipeline]]

#### diffusers.Flux2Pipeline[[diffusers.Flux2Pipeline]]

```python
diffusers.Flux2Pipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLFlux2, text_encoder: Mistral3ForConditionalGeneration, tokenizer: AutoProcessor, transformer: Flux2Transformer2DModel)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux2/pipeline_flux2.py#L251)

**Paramètres :**

transformer ([Flux2Transformer2DModel](/docs/diffusers/main/fr/api/models/flux2_transformer#diffusers.Flux2Transformer2DModel)) : 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 (`AutoencoderKLFlux2`) : Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des images vers et depuis des représentations latentes.

text_encoder (`Mistral3ForConditionalGeneration`) : [Mistral3ForConditionalGeneration](https://huggingface.co/docs/transformers/en/model_doc/mistral3#transformers.Mistral3ForConditionalGeneration)
tokenizer (`AutoProcessor`) : Tokenizer de la classe [PixtralProcessor](https://huggingface.co/docs/transformers/en/model_doc/pixtral#transformers.PixtralProcessor).
Le pipeline Flux2 pour la génération d'images à partir de texte.
Référence : [https://bfl.ai/blog/flux-2](https://bfl.ai/blog/flux-2)
#### __appel__[[diffusers.Flux2Pipeline.__call__]]
```python
__call__(image: PIL.Image.Image | list[PIL.Image.Image] | None = None, prompt: str | list[str] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, sigmas: list[float] | None = None, guidance_scale: float | None = 4.0, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, 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, text_encoder_out_layers: tuple[int] = (10, 20, 30), caption_upsample_temperature: float = None)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux2/pipeline_flux2.py#L746)
**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.
guidance_scale (`float`, *facultatif*, valeur par défaut 1.0) : 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 `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.
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é.
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.Tensor`, *facultatif*) : Latents bruités pré-générés, échantillonnés à partir d'une distribution gaussienne, à utiliser comme entrées pour la génération d'images. Peut être utilisé pour ajuster la même génération avec des prompts différents. S'il n'est pas fourni, un tenseur de latents sera généré par échantillonnage à l'aide du `generator` aléatoire fourni.
prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, *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`.
output_type (`str`, *facultatif*, par défaut `"pil"`) : Le format de sortie de l'image générée. Choisissez entre [PIL](https://pillow.readthedocs.io/en/stable/) : `PIL.Image.Image` ou `np.array`.
return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `~pipelines.qwenimage.QwenImagePipelineOutput` plutôt qu'un simple tuple.
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 de tenseurs 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`.
text_encoder_out_layers (`tuple[int]`) : Indices des couches à utiliser dans le `text_encoder` pour dériver les embeddings de prompt finaux.
caption_upsample_temperature (`float`) : Si une valeur est spécifiée, nous tenterons d'effectuer un suréchantillonnage des légendes pour des résultats potentiellement améliorés. Nous recommandons de le définir à 0,15 si un suréchantillonnage des légendes doit être effectué.
**Retourne :** `~pipelines.flux2.Flux2PipelineOutput` ou `tuple`
`~pipelines.flux2.Flux2PipelineOutput` 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 Flux2Pipeline

>>> pipe = Flux2Pipeline.from_pretrained("black-forest-labs/FLUX.2-dev", 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=50, guidance_scale=2.5).images[0]
>>> image.save("flux.png")
```
## Flux2KleinPipeline[[diffusers.Flux2KleinPipeline]]
#### diffusers.Flux2KleinPipeline[[diffusers.Flux2KleinPipeline]]
```python
diffusers.Flux2KleinPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLFlux2, text_encoder: Qwen3ForCausalLM, tokenizer: Qwen2Tokenizer, transformer: Flux2Transformer2DModel, is_distilled: bool = False)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux2/pipeline_flux2_klein.py#L155)
**Paramètres :**
transformer ([Flux2Transformer2DModel](/docs/diffusers/main/fr/api/models/flux2_transformer#diffusers.Flux2Transformer2DModel)) : 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 (`AutoencoderKLFlux2`) : Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des images vers et depuis des représentations latentes.
text_encoder (`Qwen3ForCausalLM`) : [Qwen3ForCausalLM](https://huggingface.co/docs/transformers/en/model_doc/qwen3#transformers.Qwen3ForCausalLM)

tokenizer (`Qwen2TokenizerFast`) : Tokenizer de la classe [Qwen2TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/qwen2#transformers.Qwen2TokenizerFast).

Le pipeline Flux2 Klein pour la génération d'images à partir de texte.

Référence : [https://bfl.ai/blog/flux2-klein-towards-interactive-visual-intelligence](https://bfl.ai/blog/flux2-klein-towards-interactive-visual-intelligence)

#### __appel__[[diffusers.Flux2KleinPipeline.__call__]]

```python
__call__(image: list[PIL.Image.Image] | PIL.Image.Image | None = None, prompt: str | list[str] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, sigmas: list[float] | None = None, guidance_scale: float = 4.0, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: str | list[str] | None = None, output_type: str = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int, dict], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512, text_encoder_out_layers: tuple[int] = (9, 18, 27))
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux2/pipeline_flux2_klein.py#L614)

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

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.

guidance_scale (`float`, *facultatif*, valeur par défaut 4.0) : Échelle de guidage telle que définie dans [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` est défini comme `w` de l'équation 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). L'échelle de guidage est activée en définissant `guidance_scale > 1`. Une échelle de guidage plus élevée encourage la génération d'images étroitement liées au `prompt` texte, généralement au détriment de la qualité de l'image. Pour les modèles distillés par étapes, `guidance_scale` est ignoré.

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'il n'est pas défini, le comportement par défaut lorsque `num_inference_steps` est passé sera utilisé.

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.Tensor`, *facultatif*) : Latents bruités pré-générés, échantillonnés à partir d'une distribution gaussienne, à utiliser comme entrées pour la génération d'images. Peut être utilisé pour ajuster la même génération avec des prompts différents. S'il n'est pas fourni, un tenseur de latents sera généré par échantillonnage à l'aide du `generator` aléatoire fourni.
prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* pondération des prompts. Si non fourni, les incrustations de texte seront générées à partir de l'argument d'entrée `prompt`.

negative_prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte négatif pré-générées. Notez que "" est utilisé comme invite négative dans ce pipeline. S'il n'est pas fourni, il sera généré à partir de "".

output_type (`str`, *facultatif*, par défaut `"pil"`) : Le format de sortie de l'image générée. Choisissez entre [PIL](https://pillow.readthedocs.io/en/stable/) : `PIL.Image.Image` ou `np.array`.
return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `~pipelines.qwenimage.QwenImagePipelineOutput` plutôt qu'un simple tuple.

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

text_encoder_out_layers (`tuple[int]`) : Indices des couches à utiliser dans le `text_encoder` pour dériver les embeddings de prompt finaux.

**Retourne :** `~pipelines.flux2.Flux2PipelineOutput` ou `tuple`

`~pipelines.flux2.Flux2PipelineOutput` 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 Flux2KleinPipeline
>>> pipe = Flux2KleinPipeline.from_pretrained(
...     "black-forest-labs/FLUX.2-klein-base-9B", 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=50, guidance_scale=4.0).images[0]
>>> image.save("flux2_output.png")
```

## Flux2KleinKVPipeline[[diffusers.Flux2KleinKVPipeline]]

#### diffusers.Flux2KleinKVPipeline[[diffusers.Flux2KleinKVPipeline]]

```python
diffusers.Flux2KleinKVPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLFlux2, text_encoder: Qwen3ForCausalLM, tokenizer: Qwen2Tokenizer, transformer: Flux2Transformer2DModel, is_distilled: bool = True)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux2/pipeline_flux2_klein_kv.py#L155)

**Paramètres :**

transformer ([Flux2Transformer2DModel](/docs/diffusers/main/fr/api/models/flux2_transformer#diffusers.Flux2Transformer2DModel)) : 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 (`AutoencoderKLFlux2`) : Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des images vers et depuis des représentations latentes.

text_encoder (`Qwen3ForCausalLM`) : [Qwen3ForCausalLM](https://huggingface.co/docs/transformers/en/model_doc/qwen3#transformers.Qwen3ForCausalLM)
tokenizer (`Qwen2TokenizerFast`) : Tokenizer de la classe [Qwen2TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/qwen2#transformers.Qwen2TokenizerFast).
Le pipeline Flux2 Klein KV pour la génération d'images à partir de texte avec conditionnement par image de référence mise en cache KV.
À la première étape de débruitage, les jetons de l'image de référence sont inclus dans le passage avant et leurs projections K/V d'attention sont mises en cache. Aux étapes suivantes, les K/V mis en cache sont réutilisés sans recalcul, offrant une inférence plus rapide lors de l'utilisation d'images de référence.
Référence : [https://bfl.ai/blog/flux2-klein-towards-interactive-visual-intelligence](https://bfl.ai/blog/flux2-klein-towards-interactive-visual-intelligence)
#### __appel__[[diffusers.Flux2KleinKVPipeline.__call__]]
```python
__call__(image: list[PIL.Image.Image] | PIL.Image.Image | None = None, prompt: str | list[str] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 4, sigmas: list[float] | None = None, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, output_type: str = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int, dict], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512, text_encoder_out_layers: tuple[int] = (9, 18, 27))
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/flux2/pipeline_flux2_klein_kv.py#L610)
**Paramètres :**
image (`PIL.Image.Image` ou `List[PIL.Image.Image]`, *facultatif*) : Image(s) de référence pour le conditionnement. À la première étape de débruitage, les jetons de référence sont inclus dans le passage avant et leurs K/V d'attention sont mis en cache. Aux étapes suivantes, les K/V en cache sont réutilisés sans recalcul.
prompt (`str` ou `List[str]`, *facultatif*) : Le prompt ou les prompts pour guider la génération d'image.
height (`int`, *facultatif*) : La hauteur en pixels de l'image générée.
width (`int`, *facultatif*) : La largeur en pixels de l'image générée.
num_inference_steps (`int`, *facultatif*, par défaut 4) : Le nombre d'étapes de débruitage.
sigmas (`List[float]`, *facultatif*) : Sigmas personnalisés pour le calendrier de débruitage.
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*) : Générateur(s) pour une génération déterministe.

latents (`torch.Tensor`, *facultatif*) : Latents bruités pré-générés.

prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées.
output_type (`str`, *facultatif*, par défaut `"pil"`) : Format de sortie : `"pil"` ou `"np"`.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `Flux2PipelineOutput` ou un simple tuple.
attention_kwargs (`dict`, *facultatif*) : Autres arguments passés aux processeurs d'attention.

callback_on_step_end (`Callable`, *facultatif*) : Fonction de rappel appelée à la fin de chaque étape de débruitage.
callback_on_step_end_tensor_inputs (`List`, *facultatif*) : Entrées Tensor pour la fonction de rappel.

max_sequence_length (`int`, par défaut 512) : Longueur maximale de la séquence pour le prompt.

text_encoder_out_layers (`tuple[int]`) : Indices des couches pour l'extraction de l'état caché de l'encodeur de texte.
**Retourne :**
`~pipelines.flux2.Flux2PipelineOutput` ou `tuple`.
Fonction appelée lors de l'appel du pipeline pour la génération.
Exemples :
```py
>>> import torch
>>> from PIL import Image
>>> from diffusers import Flux2KleinKVPipeline
>>> pipe = Flux2KleinKVPipeline.from_pretrained(
...     "black-forest-labs/FLUX.2-klein-9b-kv", torch_dtype=torch.bfloat16
... )
>>> pipe.to("cuda")
>>> ref_image = Image.open("reference.png")
>>> image = pipe("A cat dressed like a wizard", image=ref_image, num_inference_steps=4).images[0]
>>> image.save("flux2_kv_output.png")
```
Xet Storage Details

Size:: 25.5 kB
Xet hash:: 1eb759ad26bc7a1b8dc8aeef9037c6888558ae118042044ddd40c038142217fb
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.