#
# 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 de la Licence.
-->

# EasyAnimate
[EasyAnimate](https://github.com/aigc-apps/EasyAnimate) d'Alibaba PAI.

La description issue de sa page GitHub : *EasyAnimate est un pipeline basé sur l’architecture transformer, conçu pour générer des images et des vidéos par IA, ainsi que pour entraîner des modèles de référence et des modèles Lora pour Diffusion Transformer. Nous prenons en charge la prédiction directe à partir de modèles EasyAnimate pré-entraînés, permettant la génération de vidéos de diverses résolutions, d’une durée d’environ 6 secondes, à 8 fps (EasyAnimateV5.1, de 1 à 49 images). De plus, les utilisateurs peuvent entraîner leurs propres modèles de référence et Lora pour des transformations de style spécifiques.*

Ce pipeline a été contribué par [bubbliiiing](https://github.com/bubbliiiing). La base de code originale peut être trouvée [ici](https://huggingface.co/alibaba-pai). Les poids originaux sont disponibles sous [hf.co/alibaba-pai](https://huggingface.co/alibaba-pai).

Il existe deux points de contrôle officiels EasyAnimate pour la génération de vidéo à partir de texte et la transformation de vidéo en vidéo.

| checkpoints | dtype d'inférence recommandé |
|:---:|:---:|
| [`alibaba-pai/EasyAnimateV5.1-12b-zh`](https://huggingface.co/alibaba-pai/EasyAnimateV5.1-12b-zh) | torch.float16 |
| [`alibaba-pai/EasyAnimateV5.1-12b-zh-InP`](https://huggingface.co/alibaba-pai/EasyAnimateV5.1-12b-zh-InP) | torch.float16 |

Un seul checkpoint officiel EasyAnimate est disponible pour l'image-vers-vidéo et la vidéo-vers-vidéo.

| checkpoints | dtype d'inférence recommandé |
|:---:|:---:|
| [`alibaba-pai/EasyAnimateV5.1-12b-zh-InP`](https://huggingface.co/alibaba-pai/EasyAnimateV5.1-12b-zh-InP) | torch.float16 |

Deux points de contrôle officiels EasyAnimate sont disponibles pour le contrôle vers vidéo.

| checkpoints | dtype d'inférence recommandé |
|:---:|:---:|
| [`alibaba-pai/EasyAnimateV5.1-12b-zh-Control`](https://huggingface.co/alibaba-pai/EasyAnimateV5.1-12b-zh-Control) | torch.float16 |
| [`alibaba-pai/EasyAnimateV5.1-12b-zh-Control-Camera`](https://huggingface.co/alibaba-pai/EasyAnimateV5.1-12b-zh-Control-Camera) | torch.float16 |

Pour la série EasyAnimateV5.1 :
- Le texte-vers-vidéo (T2V) et l'image-vers-vidéo (I2V) fonctionnent à plusieurs résolutions. La largeur et la hauteur peuvent varier de 256 à 1024.
- Les modèles T2V et I2V prennent en charge la génération avec 1 à 49 images et fonctionnent de manière optimale à cette valeur. L’exportation des vidéos à 8 FPS est recommandée.

## 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 [EasyAnimatePipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/easyanimate#diffusers.EasyAnimatePipeline) quantifié pour l’inférence avec bitsandbytes.

```py
import torch
from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig, EasyAnimateTransformer3DModel, EasyAnimatePipeline
from diffusers.utils import export_to_video

quant_config = DiffusersBitsAndBytesConfig(load_in_8bit=True)
transformer_8bit = EasyAnimateTransformer3DModel.from_pretrained(
    "alibaba-pai/EasyAnimateV5.1-12b-zh",
    subfolder="transformer",
    quantization_config=quant_config,
    dtype=torch.float16,
)

pipeline = EasyAnimatePipeline.from_pretrained(
    "alibaba-pai/EasyAnimateV5.1-12b-zh",
    transformer=transformer_8bit,
    dtype=torch.float16,
    device_map="balanced",
)

prompt = "A cat walks on the grass, realistic style."
negative_prompt = "bad detailed"
video = pipeline(prompt=prompt, negative_prompt=negative_prompt, num_frames=49, num_inference_steps=30).frames[0]
export_to_video(video, "cat.mp4", fps=8)
```

## EasyAnimatePipeline[[diffusers.EasyAnimatePipeline]]

#### diffusers.EasyAnimatePipeline[[diffusers.EasyAnimatePipeline]]

```python
diffusers.EasyAnimatePipeline(vae: AutoencoderKLMagvit, text_encoder: transformers.models.qwen2_vl.modeling_qwen2_vl.Qwen2VLForConditionalGeneration | transformers.models.bert.modeling_bert.BertModel, tokenizer: transformers.models.qwen2.tokenization_qwen2.Qwen2Tokenizer | transformers.models.bert.tokenization_bert.BertTokenizer, transformer: EasyAnimateTransformer3DModel, scheduler: FlowMatchEulerDiscreteScheduler)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/easyanimate/pipeline_easyanimate.py#L186)

**Paramètres :**

vae ([AutoencoderKLMagvit](/docs/diffusers/v0.43.0/fr/api/models/autoencoderkl_magvit#diffusers.AutoencoderKLMagvit)) : modèle de Variational Auto-Encoder (VAE) permettant d’encoder et de décoder des vidéos à partir de représentations latentes et inversement.

text_encoder (`~transformers.Qwen2VLForConditionalGeneration`, `~transformers.BertModel` | None) : EasyAnimate utilise [qwen2 vl](https://huggingface.co/Qwen/Qwen2-VL-7B-Instruct) dans la V5.1.

tokenizer (`~transformers.Qwen2Tokenizer`, `~transformers.BertTokenizer` | None) : Un `Qwen2Tokenizer` ou `BertTokenizer` pour tokeniser le texte.

transformer ([EasyAnimateTransformer3DModel](/docs/diffusers/v0.43.0/fr/api/models/easyanimate_transformer3d#diffusers.EasyAnimateTransformer3DModel)) : le modèle EasyAnimate conçu par l'équipe EasyAnimate.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : un planificateur à utiliser en combinaison avec EasyAnimate pour débruyer les latents d'image encodés.

Pipeline pour la génération de texte vers vidéo utilisant EasyAnimate.

Ce modèle hérite de [DiffusionPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/overview#diffusers.DiffusionPipeline). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous les pipelines (téléchargement ou sauvegarde, exécution sur un appareil particulier, etc.).

EasyAnimate utilise un seul encodeur de texte [qwen2 vl](https://huggingface.co/Qwen/Qwen2-VL-7B-Instruct) dans la V5.1.

#### __appel__[[diffusers.EasyAnimatePipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, num_frames: int | None = 49, height: int | None = 512, width: int | None = 512, num_inference_steps: int | None = 50, guidance_scale: float | None = 5.0, negative_prompt: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float | None = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, timesteps: list[int] | 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, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], guidance_rescale: float = 0.0)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/easyanimate/pipeline_easyanimate.py#L524)

**Paramètres :**

prompt (`str` ou `list[str]`, *facultatif*) : Prompts textuels pour guider la génération d'image ou de vidéo. S'ils ne sont pas fournis, utilisez `prompt_embeds` à la place.

num_frames (`int`, *facultatif*) : Longueur de la vidéo générée (en images).

height (`int`, *facultatif*) : Hauteur de l'image générée en pixels.

width (`int`, *facultatif*) : Largeur de l'image générée en pixels.

num_inference_steps (`int`, *facultatif*, valeur par défaut 50) : Nombre d'étapes de débruitage lors de la génération. Un nombre plus élevé d'étapes produit généralement des images de meilleure qualité, mais ralentit l'inférence.

guidance_scale (`float`, *facultatif*, valeur par défaut 5.0) : Encourage le modèle à aligner les sorties avec les invites. Une valeur plus élevée peut diminuer la qualité de l'image.

negative_prompt (`str` ou `list[str]`, *facultatif*) : Prompts indiquant ce qu'il faut exclure de la génération. Si non spécifié, utilisez `negative_prompt_embeds`.

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

eta (`float`, *facultatif*, valeur par défaut 0.0) : S'applique à la planification DDIM. Contrôlé par le paramètre eta de la littérature associée.

generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Un générateur pour assurer la reproductibilité dans la génération d'images.

latents (`torch.Tensor`, *facultatif*) : Tenseurs latents prédéfinis pour conditionner la génération.

prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pour les invites. Remplace les entrées de chaînes de caractères des invites pour plus de flexibilité.

negative_prompt_embeds (`torch.Tensor`, *facultatif*) : Embeddings pour les prompts négatifs. Remplace les entrées de type chaîne si défini.

prompt_attention_mask (`torch.Tensor`, *facultatif*) : Masque d'attention pour les embeddings du prompt principal.

negative_prompt_attention_mask (`torch.Tensor`, *facultatif*) : Masque d'attention pour les embeddings du prompt négatif.

output_type (`str`, *facultatif*, par défaut "latent") : Format de la sortie générée, soit en tant qu'image PIL, soit en tant que tableau NumPy.

return_dict (`bool`, *facultatif*, par défaut `True`) : Si `True`, renvoie une sortie structurée. Sinon, renvoie un simple tuple.

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

callback_on_step_end_tensor_inputs (`list[str]`, *facultatif*) : Noms des tenseurs à inclure dans les appels de la fonction de rappel.

guidance_rescale (`float`, *facultatif*, valeur par défaut 0.0) : Ajuste les niveaux de bruit en fonction de l'échelle de guidage.

timesteps (`list[int]`, *facultatif*) : Étapes de temps personnalisées à utiliser pour le processus de débruitage. Si non définies, l'agenda par défaut du planificateur pour `num_inference_steps` est utilisé.

**Retourne :** [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/fr/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) ou `tuple`

Si `return_dict` est `True`, [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/fr/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) est renvoyé, sinon un `tuple` est renvoyé dont le premier élément est une liste des images générées et le deuxième élément est une liste de `bool` indiquant si l'image générée correspondante contient du contenu « not-safe-for-work » (nsfw).

Génère des images ou des vidéos à l'aide du pipeline EasyAnimate sur la base des prompts fournis.

Exemples :
```python
>>> import torch
>>> from diffusers import EasyAnimatePipeline
>>> from diffusers.utils import export_to_video

>>> # Models: "alibaba-pai/EasyAnimateV5.1-12b-zh"
>>> pipe = EasyAnimatePipeline.from_pretrained(
...     "alibaba-pai/EasyAnimateV5.1-7b-zh-diffusers", torch_dtype=torch.float16
... ).to("cuda")
>>> prompt = (
...     "A panda, dressed in a small, red jacket and a tiny hat, sits on a wooden stool in a serene bamboo forest. "
...     "The panda's fluffy paws strum a miniature acoustic guitar, producing soft, melodic tunes. Nearby, a few other "
...     "pandas gather, watching curiously and some clapping in rhythm. Sunlight filters through the tall bamboo, "
...     "casting a gentle glow on the scene. The panda's face is expressive, showing concentration and joy as it plays. "
...     "The background includes a small, flowing stream and vibrant green foliage, enhancing the peaceful and magical "
...     "atmosphere of this unique musical performance."
... )
>>> sample_size = (512, 512)
>>> video = pipe(
...     prompt=prompt,
...     guidance_scale=6,
...     negative_prompt="bad detailed",
...     height=sample_size[0],
...     width=sample_size[1],
...     num_inference_steps=50,
... ).frames[0]
>>> export_to_video(video, "output.mp4", fps=8)
```

#### encode_prompt[[diffusers.EasyAnimatePipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], num_images_per_prompt: int = 1, do_classifier_free_guidance: bool = True, negative_prompt: str | list[str] | None = None, 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, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None, max_sequence_length: int = 256)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/easyanimate/pipeline_easyanimate.py#L241)

**Paramètres :**

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

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

dtype (`torch.dtype`) : dtype torch

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

do_classifier_free_guidance (`bool`) : indique s'il faut utiliser le guidage sans classifieur ou non

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` est inférieur à `1`).

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*) : 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 le prompt. Obligatoire lorsque `prompt_embeds` est transmis directement.

negative_prompt_attention_mask (`torch.Tensor`, *facultatif*) : Masque d'attention pour le prompt négatif. Requis lorsque `negative_prompt_embeds` est passé directement.

max_sequence_length (`int`, *facultatif*) : longueur maximale de la séquence à utiliser pour le prompt.

Encode le prompt dans les états cachés de l'encodeur de texte.

## EasyAnimatePipelineOutput[[diffusers.pipelines.easyanimate.pipeline_output.EasyAnimatePipelineOutput]]

#### diffusers.pipelines.easyanimate.pipeline_output.EasyAnimatePipelineOutput[[diffusers.pipelines.easyanimate.pipeline_output.EasyAnimatePipelineOutput]]

```python
diffusers.pipelines.easyanimate.pipeline_output.EasyAnimatePipelineOutput(frames: Tensor)
```

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

**Paramètres :**

frames (`torch.Tensor`, `np.ndarray` ou list[list[PIL.Image.Image]]) : liste de sorties vidéo - Il peut s'agir d'une liste imbriquée de longueur `batch_size,` où chaque sous-liste contient des séquences d'images PIL débruitées de longueur `num_frames.` Il peut également s'agir d'un tableau NumPy ou d'un tenseur Torch de forme `(batch_size, num_frames, channels, height, width)`.

Classe de sortie pour les pipelines EasyAnimate.