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

# Anima

Anima est un modèle de texte vers image qui réutilise le [CosmosTransformer3DModel](/docs/diffusers/main/fr/api/models/cosmos_transformer3d#diffusers.CosmosTransformer3DModel) avec un encodeur de texte Qwen3, un conditionneur de texte T5-token et le VAE [AutoencoderKLQwenImage](/docs/diffusers/main/fr/api/models/autoencoderkl_qwenimage#diffusers.AutoencoderKLQwenImage).

```python
import torch
from diffusers import ModularPipeline

pipe = ModularPipeline.from_pretrained("circlestone-labs/Anima-Base-v1.0-Diffusers")
pipe.load_components(dtype=torch.bfloat16)
pipe.to("cuda")  # or "mps", "xpu", "cpu"

image = pipe(prompt="masterpiece, best quality, 1girl, solo, city lights").images[0]
```

## AnimaModularPipeline[[diffusers.AnimaModularPipeline]]

#### diffusers.AnimaModularPipeline[[diffusers.AnimaModularPipeline]]

```python
diffusers.AnimaModularPipeline(blocks: diffusers.modular_pipelines.modular_pipeline.ModularPipelineBlocks | None = None, pretrained_model_name_or_path: str | os.PathLike | None = None, components_manager: diffusers.modular_pipelines.components_manager.ComponentsManager | None = None, collection: str | None = None, workflow: str | None = None, modular_config_dict: dict[str, typing.Any] | None = None, config_dict: dict[str, typing.Any] | None = None, **kwargs)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/anima/modular_pipeline.py#L19)

Un ModularPipeline pour Anima.

## AnimaAutoBlocks[[diffusers.AnimaAutoBlocks]]

#### diffusers.AnimaAutoBlocks[[diffusers.AnimaAutoBlocks]]

```python
diffusers.AnimaAutoBlocks()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/anima/modular_blocks_anima.py#L312)

Pipeline Auto modulaire pour la génération d'images à partir de texte et d'images à partir d'images à l'aide d'Anima.

Workflows pris en charge :
- `text2image` : nécessite `prompt`
- `img2img` : nécessite `image`, `prompt`

Composants : text_encoder (`Qwen3Model`) tokenizer (`Qwen2Tokenizer`) t5_tokenizer (`T5Tokenizer`) guider (`ClassifierFreeGuidance`) vae (`AutoencoderKLQwenImage`) image_processor (`VaeImageProcessor`) text_conditioner (`AnimaTextConditioner`) transformer (`CosmosTransformer3DModel`) scheduler (`FlowMatchEulerDiscreteScheduler`)

Entrées : prompt (`str`) : Le prompt ou les prompts pour guider la génération d'image. negative_prompt (`str`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d'image. max_sequence_length (`int`, *facultatif*, par défaut 512) : Longueur de séquence maximale pour l'encodage du prompt. image (`Image | list`, *facultatif*) : Image(s) de référence pour le débruitage. Peut être une image unique ou une liste d'images. 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. generator (`Generator`, *facultatif*) : Générateur Torch pour une génération déterministe. num_images_per_prompt (`int`, *facultatif*, par défaut 1) : Le nombre d'images à générer par prompt. image_latents (`Tensor`, *facultatif*) : Latents d'image utilisés pour guider la génération d'image. Peut être généré à partir de l'étape vae_encoder. num_inference_steps (`int`) : Le nombre d'étapes de débruitage. sigmas (`list`, *facultatif*) : Sigmas personnalisés pour le processus de débruitage. strength (`float`, *facultatif*, par défaut 0.9) : Intensité pour img2img/inpainting. latents (`Tensor`) : Latents bruités pré-générés pour la génération d'image. **denoiser_input_fields (`None`, *facultatif*) : Entrées du modèle conditionnel pour le débruiteur Anima. output_type (`str`, *facultatif*, par défaut pil) : Format de sortie : 'pil', 'np', 'pt'.

Sorties : images (`list`) : Images générées.

## AnimaTextConditioner[[diffusers.AnimaTextConditioner]]

#### diffusers.AnimaTextConditioner[[diffusers.AnimaTextConditioner]]

```python
diffusers.AnimaTextConditioner(source_dim: int = 1024, target_dim: int = 1024, model_dim: int = 1024, num_layers: int = 6, num_attention_heads: int = 16, mlp_ratio: float = 4.0, target_vocab_size: int = 32128, use_self_attention: bool = True, use_layer_norm: bool = False, min_sequence_length: int = 512)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/condition_embedders/condition_embedder_anima.py#L229)

Conditionneur de texte utilisé par Anima pour mapper les états cachés de Qwen3 et les identifiants de jetons T5 vers les embeddings de texte Cosmos.

Anima réutilise le DiT de Cosmos Predict2. Le seul module de conditionnement spécifique au modèle est cet adaptateur LLM, qui effectue une attention croisée depuis les embeddings de jetons T5 appris vers les états cachés de l'encodeur de texte Qwen3 avant la boucle de diffusion. `target_dim` est la dimension de sortie du conditionneur et doit correspondre à `text_embed_dim` du transformeur.

#### forward[[diffusers.AnimaTextConditioner.forward]]

```python
forward(source_hidden_states: Tensor, target_input_ids: Tensor, target_attention_mask: typing.Optional[torch.Tensor] = None, source_attention_mask: typing.Optional[torch.Tensor] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/condition_embedders/condition_embedder_anima.py#L285)

**Paramètres :**

source_hidden_states (`torch.Tensor` de forme `(batch_size, source_sequence_length, source_dim)`) : états cachés de l'encodeur de texte Qwen3 sur lesquels conditionner.

target_input_ids (`torch.Tensor` de forme `(batch_size, target_sequence_length)`) : identifiants de jetons T5 utilisés comme jetons de requête appris.

target_attention_mask (`torch.Tensor`, *facultatif*) : Masque d'attention pour les identifiants de jetons T5 cibles.

source_attention_mask (`torch.Tensor`, *facultatif*) : Masque d'attention pour les états cachés source de Qwen3.

**Retourne :** `torch.Tensor`

Embeddings de conditionnement de texte pour le transformer Cosmos.