#
# Sous licence Apache License, Version 2.0 (la « Licence ») ;
# vous ne pouvez utiliser ce fichier que conformément à la Licence.
# Vous pouvez obtenir un exemplaire de la Licence à
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Sauf exigence légale ou accord écrit
# distribué sous la Licence est distribué sur une base « EN L'ÉTAT »,
# SANS AUCUNE GARANTIE NI CONDITION, explicite ou implicite.
# Voir la Licence pour le langage spécifique régissant les autorisations et
# limitations under the License. -->

# NucleusMoE-Image

[NucleusMoE-Image](https://huggingface.co/NucleusAI/NucleusMoE-Image) est un modèle de génération d’images à partir de texte qui associe un DiT à flux unique, des couches feed-forward Mixture-of-Experts, une attention croisée avec un encodeur de texte Qwen3-VL et un planificateur discret Euler de flow-matching.

> [!TIP]
> Pensez à consulter le [guide des Schedulers](../../using-diffusers/schedulers) pour apprendre à explorer le compromis entre la vitesse et la qualité du scheduler, et à consulter la section [réutilisation des composants entre les pipelines](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) pour apprendre à charger efficacement les mêmes composants dans plusieurs pipelines.

## NucleusMoEImagePipeline[[diffusers.NucleusMoEImagePipeline]]

#### diffusers.NucleusMoEImagePipeline[[diffusers.NucleusMoEImagePipeline]]

```python
diffusers.NucleusMoEImagePipeline(transformer: NucleusMoEImageTransformer2DModel, scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLQwenImage, text_encoder: Qwen3VLForConditionalGeneration, processor: Qwen3VLProcessor)
```

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

**Paramètres :**

transformer (`NucleusMoEImageTransformer2DModel`) : architecture Transformer conditionnelle (MMDiT) pour le débruitage des latents d'image encodés.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/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 ([AutoencoderKLQwenImage](/docs/diffusers/v0.43.0/fr/api/models/autoencoderkl_qwenimage#diffusers.AutoencoderKLQwenImage)) : modèle de Variational Auto-Encoder (VAE) permettant d’encoder et de décoder des images vers et depuis des représentations latentes.

text_encoder (`Qwen3VLForConditionalGeneration`) : encodeur de texte pour le calcul des embeddings de prompt.

processor (`Qwen3VLProcessor`) : Processeur pour la tokenisation des entrées textuelles.

Pipeline pour la génération d'images à partir de texte utilisant NucleusMoE.

Ce pipeline utilise un DiT à flux unique avec des couches feed-forward Mixture-of-Experts, une attention croisée vers un encodeur de texte Qwen3-VL et un planificateur discret Euler de flow-matching.

#### __appel__[[diffusers.NucleusMoEImagePipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] = None, guidance_scale: float = 4.0, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, sigmas: list[float] | None = None, num_images_per_prompt: int = 1, max_sequence_length: int | None = None, return_index: int | None = None, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_mask: 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, dict], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'])
```

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

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

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, une chaîne vide est utilisée lorsque `true_cfg_scale > 1`.

guidance_scale (`float`, *facultatif*, valeur par défaut 4.0) : Échelle du guidage sans classifieur (classifier-free guidance). Les valeurs supérieures à 1 activent le CFG.

return_index (`int`, *facultatif*) : Index de la couche de la sortie du codeur de texte à utiliser pour les embeddings du prompt.

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.

num_inference_steps (`int`, *facultatif*, par défaut 50) : Le nombre d'étapes de débruitage.

sigmas (`list[float]`, *facultatif*) : Sigmas personnalisés pour le calendrier de débruitage. S'ils ne sont pas définis, un calendrier linéaire est 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 générateur torch ou une liste de générateurs torch pour rendre la génération déterministe.

latents (`torch.Tensor`, *facultatif*) : Latents bruités pré-générés à utiliser comme entrées pour la génération d'images.

prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées.

prompt_embeds_mask (`torch.Tensor`, *facultatif*) : Masque d'attention pour les embeddings de texte pré-générés.

negative_prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte négatif pré-générées.

negative_prompt_embeds_mask (`torch.Tensor`, *facultatif*) : Masque d'attention pour les embeddings de texte négatif 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"`, `"np"` ou `"latent"`.

return_dict (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut retourner un `NucleusMoEImagePipelineOutput` plutôt qu'un simple tuple.

attention_kwargs (`dict`, *facultatif*) : Arguments nommés passés au processeur d'attention.

callback_on_step_end (`Callable`, *facultatif*) : Une fonction appelée à la fin de chaque étape de débruitage.

callback_on_step_end_tensor_inputs (`list`, *facultatif*) : Entrées Tensor pour la fonction `callback_on_step_end`.

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

**Retourne :** `NucleusMoEImagePipelineOutput` ou `tuple`

`NucleusMoEImagePipelineOutput` si `return_dict` est True, sinon un `tuple` dont 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 NucleusMoEImagePipeline

>>> pipe = NucleusMoEImagePipeline.from_pretrained("NucleusAI/NucleusMoE-Image", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")
>>> prompt = "A cat holding a sign that says hello world"
>>> image = pipe(prompt, num_inference_steps=50).images[0]
>>> image.save("nucleus_moe.png")
```

#### encode_prompt[[diffusers.NucleusMoEImagePipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str] = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int | None = None, return_index: int | None = None)
```

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

**Paramètres :**

prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à encoder.

device (`torch.device`, *facultatif*) : Appareil Torch pour les tenseurs résultants.

num_images_per_prompt (`int`, par défaut 1) : Nombre d'images à générer par invite.

prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées. L'encodage est ignoré si elles sont fournies.

prompt_embeds_mask (`torch.Tensor`, *facultatif*) : Masque d'attention pour les embeddings pré-générés.

max_sequence_length (`int`, par défaut 1024) : Longueur maximale des jetons pour le prompt encodé.

Encode les prompts de texte en embeddings à l'aide de l'encodeur de texte Qwen3-VL.

## NucleusMoEImagePipelineOutput[[diffusers.pipelines.nucleusmoe_image.pipeline_output.NucleusMoEImagePipelineOutput]]

#### diffusers.pipelines.nucleusmoe_image.pipeline_output.NucleusMoEImagePipelineOutput[[diffusers.pipelines.nucleusmoe_image.pipeline_output.NucleusMoEImagePipelineOutput]]

```python
diffusers.pipelines.nucleusmoe_image.pipeline_output.NucleusMoEImagePipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray)
```

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

**Paramètres :**

images (`list[PIL.Image.Image]` ou `np.ndarray`) : Liste d'images PIL débruitées de longueur `batch_size` ou tableau numpy de forme `(batch_size, height, width, num_channels)`. Les images PIL ou le tableau numpy présentent les images débruitées du pipeline de diffusion.

Classe de sortie pour les pipelines d'image NucleusMoE.