# Chroma

  
  

Chroma est un modèle de génération d'images à partir de texte basé sur Flux.

Les points de contrôle des modèles originaux de Chroma peuvent être trouvés ici :
* Affinage haute résolution : [lodestones/Chroma1-HD](https://huggingface.co/lodestones/Chroma1-HD)
* Modèle de base : [lodestones/Chroma1-Base](https://huggingface.co/lodestones/Chroma1-Base)
* Dépôt d’origine avec des points de contrôle de progression : [lodestones/Chroma](https://huggingface.co/lodestones/Chroma) (le chargement de ce dépôt avec `from_pretrained` chargera une version compatible Diffusers du point de contrôle `unlocked-v37`)

> [!TIP]
> Chroma peut utiliser toutes les mêmes optimisations que Flux.

## Inférence

```python
import torch
from diffusers import ChromaPipeline

pipe = ChromaPipeline.from_pretrained("lodestones/Chroma1-HD", dtype=torch.bfloat16)
pipe.enable_model_cpu_offload()

prompt = [
    "A high-fashion close-up portrait of a blonde woman in clear sunglasses. The image uses a bold teal and red color split for dramatic lighting. The background is a simple teal-green. The photo is sharp and well-composed, and is designed for viewing with anaglyph 3D glasses for optimal effect. It looks professionally done."
]
negative_prompt =  ["low quality, ugly, unfinished, out of focus, deformed, disfigure, blurry, smudged, restricted palette, flat colors"]

image = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    generator=torch.Generator("cpu").manual_seed(433),
    num_inference_steps=40,
    guidance_scale=3.0,
    num_images_per_prompt=1,
).images[0]
image.save("chroma.png")
```

## Chargement depuis un fichier unique

Pour utiliser des points de contrôle de modèles mis à jour qui ne sont pas au format Diffusers, vous pouvez utiliser la classe `ChromaTransformer2DModel` pour charger le modèle à partir d'un seul fichier au format d'origine. Cela est également utile lorsque vous essayez de charger des versions affinées ou quantifiées des modèles publiées par la communauté.

L'exemple suivant montre comment exécuter Chroma à partir d'un seul fichier.

Puis exécutez l’exemple suivant

```python
import torch
from diffusers import ChromaTransformer2DModel, ChromaPipeline

model_id = "lodestones/Chroma1-HD"
dtype = torch.bfloat16

transformer = ChromaTransformer2DModel.from_single_file("https://huggingface.co/lodestones/Chroma1-HD/blob/main/Chroma1-HD.safetensors", dtype=dtype)

pipe = ChromaPipeline.from_pretrained(model_id, transformer=transformer, dtype=dtype)
pipe.enable_model_cpu_offload()

prompt = [
    "A high-fashion close-up portrait of a blonde woman in clear sunglasses. The image uses a bold teal and red color split for dramatic lighting. The background is a simple teal-green. The photo is sharp and well-composed, and is designed for viewing with anaglyph 3D glasses for optimal effect. It looks professionally done."
]
negative_prompt =  ["low quality, ugly, unfinished, out of focus, deformed, disfigure, blurry, smudged, restricted palette, flat colors"]

image = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    generator=torch.Generator("cpu").manual_seed(433),
    num_inference_steps=40,
    guidance_scale=3.0,
).images[0]

image.save("chroma-single-file.png")
```

## ChromaPipeline[[diffusers.ChromaPipeline]]

#### diffusers.ChromaPipeline[[diffusers.ChromaPipeline]]

```python
diffusers.ChromaPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: T5EncoderModel, tokenizer: T5Tokenizer, transformer: ChromaTransformer2DModel, image_encoder: CLIPVisionModelWithProjection = None, feature_extractor: CLIPImageProcessorPil = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/chroma/pipeline_chroma.py#L150)

**Paramètres :**

transformer ([ChromaTransformer2DModel](/docs/diffusers/v0.43.0/fr/api/models/chroma_transformer#diffusers.ChromaTransformer2DModel)) : architecture Conditional Transformer (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 ([AutoencoderKL](/docs/diffusers/v0.43.0/fr/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des images vers et depuis une représentation latente

text_encoder (`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 (`T5TokenizerFast`) : Second Tokenizer de la classe [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).

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

Référence : https://huggingface.co/lodestones/Chroma1-HD/

#### __appel__[[diffusers.ChromaPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 35, sigmas: list[float] | None = None, guidance_scale: float = 5.0, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = 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.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = 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/v0.43.0/src/diffusers/pipelines/chroma/pipeline_chroma.py#L587)

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

negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passer `negative_prompt_embeds` à la place. Ignoré lorsque le guidage n’est pas utilisé (c’est-à-dire ignoré si `guidance_scale` n’est pas supérieur à `1`).

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 35) : 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 5.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.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`.

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

prompt_attention_mask (torch.Tensor, *facultatif*) : Masque d'attention pour les embeddings du prompt. Utilisé pour masquer les jetons de bourrage dans la séquence du prompt. Chroma exige qu'un seul jeton de bourrage reste non masqué. Veuillez consulter https://huggingface.co/lodestones/Chroma#tldr-masking-t5-padding-tokens-enhanced-fidelity-and-increased-stability-during-training

negative_prompt_attention_mask (torch.Tensor, *facultatif*) : Masque d'attention pour les embeddings du prompt négatif. Utilisé pour masquer les jetons de bourrage dans la séquence du prompt négatif. Chroma exige qu'un seul jeton de bourrage reste non masqué. Veuillez consulter https://huggingface.co/lodestones/Chroma#tldr-masking-t5-padding-tokens-enhanced-fidelity-and-increased-stability-during-training

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.flux.ChromaPipelineOutput` 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.chroma.ChromaPipelineOutput` ou `tuple`

`~pipelines.chroma.ChromaPipelineOutput` 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 ChromaPipeline

>>> model_id = "lodestones/Chroma1-HD"
>>> ckpt_path = "https://huggingface.co/lodestones/Chroma1-HD/blob/main/Chroma1-HD.safetensors"
>>> transformer = ChromaTransformer2DModel.from_single_file(ckpt_path, torch_dtype=torch.bfloat16)
>>> pipe = ChromaPipeline.from_pretrained(
...     model_id,
...     transformer=transformer,
...     torch_dtype=torch.bfloat16,
... )
>>> pipe.enable_model_cpu_offload()
>>> prompt = [
...     "A high-fashion close-up portrait of a blonde woman in clear sunglasses. The image uses a bold teal and red color split for dramatic lighting. The background is a simple teal-green. The photo is sharp and well-composed, and is designed for viewing with anaglyph 3D glasses for optimal effect. It looks professionally done."
... ]
>>> negative_prompt = [
...     "low quality, ugly, unfinished, out of focus, deformed, disfigure, blurry, smudged, restricted palette, flat colors"
... ]
>>> image = pipe(prompt, negative_prompt=negative_prompt).images[0]
>>> image.save("chroma.png")
```

#### encode_prompt[[diffusers.ChromaPipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], negative_prompt: str | list[str] = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, do_classifier_free_guidance: bool = True, max_sequence_length: int = 512, lora_scale: float | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/chroma/pipeline_chroma.py#L264)

**Paramètres :**

prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder

negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passer `negative_prompt_embeds` à la place. Ignoré lorsque la guidance n’est pas utilisée (c’est-à-dire ignoré si `guidance_scale` est inférieur à `1`).

device : (`torch.device`) : appareil torch

num_images_per_prompt (`int`) : nombre d'images à générer par invite

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

lora_scale (`float`, *facultatif*) : Échelle LoRA appliquée à toutes les couches LoRA de l'encodeur de texte si des couches LoRA sont chargées.

## ChromaImg2ImgPipeline[[diffusers.ChromaImg2ImgPipeline]]

#### diffusers.ChromaImg2ImgPipeline[[diffusers.ChromaImg2ImgPipeline]]

```python
diffusers.ChromaImg2ImgPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: T5EncoderModel, tokenizer: T5Tokenizer, transformer: ChromaTransformer2DModel, image_encoder: CLIPVisionModelWithProjection = None, feature_extractor: CLIPImageProcessorPil = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/chroma/pipeline_chroma_img2img.py#L162)

**Paramètres :**

transformer ([ChromaTransformer2DModel](/docs/diffusers/v0.43.0/fr/api/models/chroma_transformer#diffusers.ChromaTransformer2DModel)) : architecture Conditional Transformer (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 ([AutoencoderKL](/docs/diffusers/v0.43.0/fr/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des images vers et depuis une représentation latente

text_encoder (`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 (`T5TokenizerFast`) : Second Tokenizer de la classe [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).

Le pipeline Chroma pour la génération d'image à partir d'image.

Référence : https://huggingface.co/lodestones/Chroma1-HD/

#### __appel__[[diffusers.ChromaImg2ImgPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 35, sigmas: list[float] | None = None, guidance_scale: float = 5.0, strength: float = 0.9, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = 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.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = 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/v0.43.0/src/diffusers/pipelines/chroma/pipeline_chroma_img2img.py#L646)

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

negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passer `negative_prompt_embeds` à la place. Ignoré lorsque le guidage n’est pas utilisé (c’est-à-dire ignoré si `guidance_scale` n’est pas supérieur à `1`).

image (`PipelineImageInput`) : l'entrée d'image pour le pipeline.

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 35) : 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 5.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.

strength (`float, *facultatif*, valeur par défaut 0.9) : Indique conceptuellement dans quelle mesure l'image de référence doit être transformée. Doit être compris entre 0 et 1. image sera utilisée comme point de départ, en y ajoutant d'autant plus de bruit que strength est élevé. Le nombre d'étapes de débruitage dépend de la quantité de bruit initialement ajoutée. Lorsque strength vaut 1, le bruit ajouté sera maximal et le processus de débruitage s'exécutera pendant le nombre complet d'itérations spécifié dans num_inference_steps. Une valeur de 1 ignore donc essentiellement image.

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

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

prompt_attention_mask (torch.Tensor, *facultatif*) : Masque d'attention pour les embeddings du prompt. Utilisé pour masquer les jetons de bourrage dans la séquence du prompt. Chroma exige qu'un seul jeton de bourrage reste non masqué. Veuillez consulter https://huggingface.co/lodestones/Chroma#tldr-masking-t5-padding-tokens-enhanced-fidelity-and-increased-stability-during-training

negative_prompt_attention_mask (torch.Tensor, *facultatif*) : Masque d'attention pour les embeddings du prompt négatif. Utilisé pour masquer les jetons de bourrage dans la séquence du prompt négatif. Chroma exige qu'un seul jeton de bourrage reste non masqué. Veuillez consulter https://huggingface.co/lodestones/Chroma#tldr-masking-t5-padding-tokens-enhanced-fidelity-and-increased-stability-during-training

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.flux.ChromaPipelineOutput` 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.chroma.ChromaPipelineOutput` ou `tuple`

`~pipelines.chroma.ChromaPipelineOutput` 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 ChromaTransformer2DModel, ChromaImg2ImgPipeline

>>> model_id = "lodestones/Chroma1-HD"
>>> ckpt_path = "https://huggingface.co/lodestones/Chroma1-HD/blob/main/Chroma1-HD.safetensors"
>>> pipe = ChromaImg2ImgPipeline.from_pretrained(
...     model_id,
...     transformer=transformer,
...     torch_dtype=torch.bfloat16,
... )
>>> pipe.enable_model_cpu_offload()
>>> init_image = load_image(
...     "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg"
... )
>>> prompt = "a scenic fastasy landscape with a river and mountains in the background, vibrant colors, detailed, high resolution"
>>> negative_prompt = "low quality, ugly, unfinished, out of focus, deformed, disfigure, blurry, smudged, restricted palette, flat colors"
>>> image = pipe(prompt, image=init_image, negative_prompt=negative_prompt).images[0]
>>> image.save("chroma-img2img.png")
```

#### encode_prompt[[diffusers.ChromaImg2ImgPipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], negative_prompt: str | list[str] = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, do_classifier_free_guidance: bool = True, max_sequence_length: int = 512, lora_scale: float | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/chroma/pipeline_chroma_img2img.py#L291)

**Paramètres :**

prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder

negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passer `negative_prompt_embeds` à la place. Ignoré lorsque la guidance n’est pas utilisée (c’est-à-dire ignoré si `guidance_scale` est inférieur à `1`).

device : (`torch.device`) : appareil torch

num_images_per_prompt (`int`) : nombre d'images à générer par invite

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

lora_scale (`float`, *facultatif*) : Échelle LoRA appliquée à toutes les couches LoRA de l'encodeur de texte si des couches LoRA sont chargées.

## ChromaInpaintPipeline[[diffusers.ChromaInpaintPipeline]]

#### diffusers.ChromaInpaintPipeline[[diffusers.ChromaInpaintPipeline]]

```python
diffusers.ChromaInpaintPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKL, text_encoder: T5EncoderModel, tokenizer: T5Tokenizer, transformer: ChromaTransformer2DModel, image_encoder: CLIPVisionModelWithProjection = None, feature_extractor: CLIPImageProcessorPil = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/chroma/pipeline_chroma_inpainting.py#L169)

**Paramètres :**

transformer ([ChromaTransformer2DModel](/docs/diffusers/v0.43.0/fr/api/models/chroma_transformer#diffusers.ChromaTransformer2DModel)) : architecture Conditional Transformer (MMDiT) pour le débruitage des latents d'image encodés.

scheduler ([DDIMScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/ddim#diffusers.DDIMScheduler)) : Un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents d'image encodés.

vae ([AutoencoderKL](/docs/diffusers/v0.43.0/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.ChromaInpaintPipeline.__call__]]

```python
__call__(prompt: typing.Union[str, typing.List[str]] = None, negative_prompt: typing.Union[str, typing.List[str]] = 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: typing.Optional[int] = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, 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: typing.Optional[typing.List[torch.Tensor]] = 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: typing.Optional[typing.List[torch.Tensor]] = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, output_type: str = 'pil', return_dict: bool = True, joint_attention_kwargs: typing.Optional[typing.Dict[str, typing.Any]] = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int, typing.Dict], NoneType]] = None, callback_on_step_end_tensor_inputs: typing.List[str] = ['latents'], max_sequence_length: int = 256, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/chroma/pipeline_chroma_inpainting.py#L764)

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

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 `guidance_scale` n'est pas supérieur à `1`).

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 (`PipelineImageInput`) : l'entrée d'image pour le pipeline.

mask_image (`PipelineImageInput`) : `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.

masked_image_latents (`torch.Tensor`, *facultatif*) : Représentation latente pré-encodée de l'image masquée. Si elle n'est pas fournie, elle sera calculée à partir de `mask_image` et `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.

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'il n'est pas défini, 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.

strength (`float, *facultatif*, valeur par défaut 0.6) : Indique conceptuellement dans quelle mesure l'image de référence doit être transformée. Doit être compris entre 0 et 1. image sera utilisée comme point de départ, en y ajoutant davantage de bruit à mesure que strength augmente. Le nombre d'étapes de débruitage dépend de la quantité de bruit initialement ajoutée. Lorsque strength vaut 1, le bruit ajouté sera maximal et le processus de débruitage s'exécutera pendant le nombre complet d'itérations spécifié dans num_inference_steps. Une valeur de 1 ignore donc essentiellement image.

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

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

prompt_attention_mask (torch.Tensor, *facultatif*) : Masque d'attention pour les embeddings du prompt. Utilisé pour masquer les jetons de bourrage dans la séquence du prompt. Chroma exige qu'un seul jeton de bourrage reste non masqué. Veuillez consulter https://huggingface.co/lodestones/Chroma#tldr-masking-t5-padding-tokens-enhanced-fidelity-and-increased-stability-during-training

negative_prompt_attention_mask (torch.Tensor, *facultatif*) : Masque d'attention pour les embeddings du prompt négatif. Utilisé pour masquer les jetons de bourrage dans la séquence du prompt négatif. Chroma exige qu'un seul jeton de bourrage reste non masqué. Veuillez consulter https://huggingface.co/lodestones/Chroma#tldr-masking-t5-padding-tokens-enhanced-fidelity-and-increased-stability-during-training

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.chroma.ChromaPipelineOutput` 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 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 256) : Longueur maximale de la séquence à utiliser avec le `prompt`.

**Retourne :** `~pipelines.chroma.ChromaPipelineOutput` ou `tuple`

`~pipelines.chroma.ChromaPipelineOutput` 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 ChromaInpaintPipeline
>>> from diffusers.utils import load_image

>>> pipe = ChromaInpaintPipeline.from_pretrained("lodestones/Chroma1-HD", 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("chroma_inpainting.png")
```

#### encode_prompt[[diffusers.ChromaInpaintPipeline.encode_prompt]]

```python
encode_prompt(prompt: typing.Union[str, typing.List[str]], negative_prompt: typing.Union[str, typing.List[str], NoneType] = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, do_classifier_free_guidance: bool = True, max_sequence_length: int = 256, lora_scale: bool | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/chroma/pipeline_chroma_inpainting.py#L293)

**Paramètres :**

prompt (`str` ou `List[str]`, *facultatif*) : invite à encoder

negative_prompt (`str` ou `List[str]`, *facultatif*) : Le prompt à ne pas utiliser pour guider la génération d'image. S'il n'est pas défini, il faut passer `negative_prompt_embeds` à la place. Ignoré lorsque la guidance n'est pas utilisée (c'est-à-dire ignoré si `guidance_scale` est inférieur à `1`).

device : (`torch.device`) : appareil torch

num_images_per_prompt (`int`) : nombre d'images à générer par invite

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

lora_scale (`float`, *facultatif*) : Échelle LoRA appliquée à toutes les couches LoRA de l'encodeur de texte si des couches LoRA sont chargées.