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

# Mochi 1 Preview

  

> [!TIP]
> Seule une version de prévisualisation de recherche des poids du modèle est disponible pour le moment.

[Mochi 1](https://huggingface.co/genmo/mochi-1-preview) est un modèle de génération de vidéos de Genmo, axé sur le respect des prompts et la qualité du mouvement. Le modèle repose sur une architecture Asmmetric Diffusion Transformer (AsymmDiT) de 10 milliards de paramètres et utilise des couches de projection QKV et de sortie non carrées afin de réduire les besoins en mémoire lors de l'inférence. Un unique modèle T5-XXL est utilisé pour encoder les prompts.

*Mochi 1 preview est un modèle de génération de vidéo open source de pointe, offrant un mouvement haute fidélité et une forte adhérence aux prompts lors des évaluations préliminaires. Ce modèle réduit considérablement l'écart entre les systèmes de génération de vidéo fermés et ouverts. Le modèle est publié sous la licence permissive Apache 2.0.*

> [!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.

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

```py
import torch
from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig, MochiTransformer3DModel, MochiPipeline
from diffusers.utils import export_to_video
from transformers import BitsAndBytesConfig as BitsAndBytesConfig, T5EncoderModel

quant_config = BitsAndBytesConfig(load_in_8bit=True)
text_encoder_8bit = T5EncoderModel.from_pretrained(
    "genmo/mochi-1-preview",
    subfolder="text_encoder",
    quantization_config=quant_config,
    dtype=torch.float16,
)

quant_config = DiffusersBitsAndBytesConfig(load_in_8bit=True)
transformer_8bit = MochiTransformer3DModel.from_pretrained(
    "genmo/mochi-1-preview",
    subfolder="transformer",
    quantization_config=quant_config,
    dtype=torch.float16,
)

pipeline = MochiPipeline.from_pretrained(
    "genmo/mochi-1-preview",
    text_encoder=text_encoder_8bit,
    transformer=transformer_8bit,
    dtype=torch.float16,
    device_map="balanced",
)

video = pipeline(
  "Close-up of a cats eye, with the galaxy reflected in the cats eye. Ultra high resolution 4k.",
  num_inference_steps=28,
  guidance_scale=3.5
).frames[0]
export_to_video(video, "cat.mp4")
```

## Générer des vidéos avec Mochi-1 Preview

L’exemple suivant téléchargera les poids pleine précision de `mochi-1-preview` et produira des résultats de la plus haute qualité, mais nécessitera au moins 42 Go de VRAM pour s’exécuter.

```python
import torch
from diffusers import MochiPipeline
from diffusers.utils import export_to_video

pipe = MochiPipeline.from_pretrained("genmo/mochi-1-preview")

# Enable memory savings
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()

prompt = "Close-up of a chameleon's eye, with its scaly skin changing color. Ultra high resolution 4k."

with torch.autocast("cuda", torch.bfloat16, cache_enabled=False):
      frames = pipe(prompt, num_frames=85).frames[0]

export_to_video(frames, "mochi.mp4", fps=30)
```

## Utiliser une variante à précision inférieure pour économiser de la mémoire

L’exemple suivant utilise la variante `bfloat16` du modèle et nécessite 22 Go de VRAM pour s’exécuter. Il en résulte une légère baisse de la qualité de la vidéo générée.

```python
import torch
from diffusers import MochiPipeline
from diffusers.utils import export_to_video

pipe = MochiPipeline.from_pretrained("genmo/mochi-1-preview", variant="bf16", dtype=torch.bfloat16)

# Enable memory savings
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()

prompt = "Close-up of a chameleon's eye, with its scaly skin changing color. Ultra high resolution 4k."
frames = pipe(prompt, num_frames=85).frames[0]

export_to_video(frames, "mochi.mp4", fps=30)
```

## Reproduire les résultats du dépôt Genmo Mochi

L'[implémentation Genmo Mochi](https://github.com/genmoai/mochi/tree/main) utilise des valeurs de précision différentes pour chaque étape du processus d'inférence. L'encodeur de texte et le VAE utilisent `torch.float32`, tandis que le DiT utilise `torch.bfloat16` avec le [noyau d'attention](https://pytorch.org/docs/stable/generated/torch.nn.attention.sdpa_kernel.html#torch.nn.attention.sdpa_kernel) défini sur `EFFICIENT_ATTENTION`. Les pipelines Diffusers ne prennent actuellement pas en charge la configuration de `dtypes` différents pour les différentes étapes du pipeline. Afin d'exécuter l'inférence de la même manière que l'implémentation originale, veuillez vous référer à l'exemple suivant.

> [!TIP]
> L'implémentation originale de Mochi met à zéro les prompts vides. Toutefois, activer cette option et placer l'ensemble du pipeline sous autocast peut entraîner des débordements numériques avec l'encodeur de texte T5.
>
> Lors de l’activation de `force_zeros_for_empty_prompt`, il est recommandé d’exécuter l’étape d’encodage du texte en dehors du contexte autocast, en pleine précision.

> [!TIP]
> Le décodage des latents en pleine précision est très gourmand en mémoire. Il faut au moins 70 Go de VRAM pour générer les 163 images de cet exemple. Pour réduire la mémoire, réduisez le nombre d’images ou exécutez l’étape de décodage en `torch.bfloat16`.

```python
import torch
from torch.nn.attention import SDPBackend, sdpa_kernel

from diffusers import MochiPipeline
from diffusers.utils import export_to_video
from diffusers.video_processor import VideoProcessor

pipe = MochiPipeline.from_pretrained("genmo/mochi-1-preview", force_zeros_for_empty_prompt=True)
pipe.vae.enable_tiling()
pipe.enable_model_cpu_offload()

prompt =  "An aerial shot of a parade of elephants walking across the African savannah. The camera showcases the herd and the surrounding landscape."

with torch.no_grad():
    prompt_embeds, prompt_attention_mask, negative_prompt_embeds, negative_prompt_attention_mask = (
        pipe.encode_prompt(prompt=prompt)
    )

with torch.autocast("cuda", torch.bfloat16):
    with sdpa_kernel(SDPBackend.EFFICIENT_ATTENTION):
        frames = pipe(
            prompt_embeds=prompt_embeds,
            prompt_attention_mask=prompt_attention_mask,
            negative_prompt_embeds=negative_prompt_embeds,
            negative_prompt_attention_mask=negative_prompt_attention_mask,
            guidance_scale=4.5,
            num_inference_steps=64,
            height=480,
            width=848,
            num_frames=163,
            generator=torch.Generator("cuda").manual_seed(0),
            output_type="latent",
            return_dict=False,
        )[0]

video_processor = VideoProcessor(vae_scale_factor=8)
has_latents_mean = hasattr(pipe.vae.config, "latents_mean") and pipe.vae.config.latents_mean is not None
has_latents_std = hasattr(pipe.vae.config, "latents_std") and pipe.vae.config.latents_std is not None
if has_latents_mean and has_latents_std:
    latents_mean = (
        torch.tensor(pipe.vae.config.latents_mean).view(1, 12, 1, 1, 1).to(frames.device, frames.dtype)
    )
    latents_std = (
        torch.tensor(pipe.vae.config.latents_std).view(1, 12, 1, 1, 1).to(frames.device, frames.dtype)
    )
    frames = frames * latents_std / pipe.vae.config.scaling_factor + latents_mean
else:
    frames = frames / pipe.vae.config.scaling_factor

with torch.no_grad():
    video = pipe.vae.decode(frames.to(pipe.vae.dtype), return_dict=False)[0]

video = video_processor.postprocess_video(video)[0]
export_to_video(video, "mochi.mp4", fps=30)
```

## Exécution de l'inférence sur plusieurs GPU

Il est possible de répartir le grand transformeur Mochi sur plusieurs GPU à l'aide des options `device_map` et `max_memory` dans `from_pretrained`. Dans l'exemple suivant, nous répartissons le modèle sur deux GPU, chacun disposant de 24 Go de VRAM.

```python
import torch
from diffusers import MochiPipeline, MochiTransformer3DModel
from diffusers.utils import export_to_video

model_id = "genmo/mochi-1-preview"
transformer = MochiTransformer3DModel.from_pretrained(
    model_id,
    subfolder="transformer",
    device_map="auto",
    max_memory={0: "24GB", 1: "24GB"}
)

pipe = MochiPipeline.from_pretrained(model_id,  transformer=transformer)
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()

with torch.autocast(device_type="cuda", dtype=torch.bfloat16, cache_enabled=False):
    frames = pipe(
        prompt="Close-up of a chameleon's eye, with its scaly skin changing color. Ultra high resolution 4k.",
        negative_prompt="",
        height=480,
        width=848,
        num_frames=85,
        num_inference_steps=50,
        guidance_scale=4.5,
        num_videos_per_prompt=1,
        generator=torch.Generator(device="cuda").manual_seed(0),  # or "mps", "xpu", "cpu"
        max_sequence_length=256,
        output_type="pil",
    ).frames[0]

export_to_video(frames, "output.mp4", fps=30)
```

## Utilisation du chargement en fichier unique avec le Mochi Transformer

Vous pouvez utiliser `from_single_file` pour charger le transformer Mochi dans son format d'origine.

> [!TIP]
> Diffusers ne prend actuellement pas en charge l'utilisation des versions FP8 à échelle des points de contrôle de fichier unique de Mochi.

```python
import torch
from diffusers import MochiPipeline, MochiTransformer3DModel
from diffusers.utils import export_to_video

model_id = "genmo/mochi-1-preview"

ckpt_path = "https://huggingface.co/Comfy-Org/mochi_preview_repackaged/blob/main/split_files/diffusion_models/mochi_preview_bf16.safetensors"

transformer = MochiTransformer3DModel.from_pretrained(ckpt_path, dtype=torch.bfloat16)

pipe = MochiPipeline.from_pretrained(model_id,  transformer=transformer)
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()

with torch.autocast(device_type="cuda", dtype=torch.bfloat16, cache_enabled=False):
    frames = pipe(
        prompt="Close-up of a chameleon's eye, with its scaly skin changing color. Ultra high resolution 4k.",
        negative_prompt="",
        height=480,
        width=848,
        num_frames=85,
        num_inference_steps=50,
        guidance_scale=4.5,
        num_videos_per_prompt=1,
        generator=torch.Generator(device="cuda").manual_seed(0),  # or "mps", "xpu", "cpu"
        max_sequence_length=256,
        output_type="pil",
    ).frames[0]

export_to_video(frames, "output.mp4", fps=30)
```

## MochiPipeline[[diffusers.MochiPipeline]]

#### diffusers.MochiPipeline[[diffusers.MochiPipeline]]

```python
diffusers.MochiPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLMochi, text_encoder: T5EncoderModel, tokenizer: T5Tokenizer, transformer: MochiTransformer3DModel, force_zeros_for_empty_prompt: bool = False)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/mochi/pipeline_mochi.py#L138)

**Paramètres :**

transformer ([MochiTransformer3DModel](/docs/diffusers/v0.43.0/fr/api/models/mochi_transformer3d#diffusers.MochiTransformer3DModel)) : architecture Transformer conditionnelle pour le débruitage des latents vidéo 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 ([AutoencoderKLMochi](/docs/diffusers/v0.43.0/fr/api/models/autoencoderkl_mochi#diffusers.AutoencoderKLMochi)) : modèle Variational Auto-Encoder (VAE) permettant d’encoder et de décoder des vidéos vers et depuis des représentations latentes.

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

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

Le pipeline mochi pour la génération de texte vers vidéo.

Référence : https://github.com/genmoai/models

#### __appel__[[diffusers.MochiPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int | None = None, width: int | None = None, num_frames: int = 19, num_inference_steps: int = 64, timesteps: list[int] = None, guidance_scale: float = 4.5, num_videos_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, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_attention_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], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 256)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/mochi/pipeline_mochi.py#L444)

**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é (`guidance_scale < 1`).

height (`int`, *facultatif*, par défaut `self.default_height`) : La hauteur en pixels de l'image générée. Par défaut, cette valeur est fixée à 480 pour obtenir les meilleurs résultats.

width (`int`, *facultatif*, par défaut `self.default_width`) : La largeur en pixels de l'image générée. Cette valeur est fixée à 848 par défaut pour obtenir les meilleurs résultats.

num_frames (`int`, par défaut `19`) : Le nombre de frames vidéo à générer

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.

timesteps (`list[int]`, *facultatif*) : Étapes de temps personnalisées à utiliser pour le processus de débruitage avec les planificateurs qui prennent en charge un argument `timesteps` 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é. Doit être dans l'ordre décroissant.

guidance_scale (`float`, par défaut `4.5`) : É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_videos_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre de vidéos à 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`.

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

negative_prompt_embeds (`torch.FloatTensor`, *facultatif*) : Embeddings de texte négatif pré-générés. Pour PixArt-Sigma, ce prompt négatif doit être "". S'il n'est pas fourni, negative_prompt_embeds sera généré à partir de l'argument d'entrée `negative_prompt`.

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

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

**Retourne :** `~pipelines.mochi.MochiPipelineOutput` ou `tuple`

Si `return_dict` est `True`, `~pipelines.mochi.MochiPipelineOutput` est retourné, sinon un `tuple` est retourné 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 MochiPipeline
>>> from diffusers.utils import export_to_video

>>> pipe = MochiPipeline.from_pretrained("genmo/mochi-1-preview", torch_dtype=torch.bfloat16)
>>> pipe.enable_model_cpu_offload()
>>> pipe.vae.enable_tiling()
>>> prompt = "Close-up of a chameleon's eye, with its scaly skin changing color. Ultra high resolution 4k."
>>> frames = pipe(prompt, num_inference_steps=28, guidance_scale=3.5).frames[0]
>>> export_to_video(frames, "mochi.mp4")
```

#### encode_prompt[[diffusers.MochiPipeline.encode_prompt]]

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

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/mochi/pipeline_mochi.py#L254)

**Paramètres :**

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

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

do_classifier_free_guidance (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut utiliser le guidage sans classifieur ou non.

num_videos_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Nombre de vidéos à générer par invite. Appareil torch sur lequel placer les embeddings résultants

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

device : (`torch.device`, *facultatif*) : appareil torch

dtype : (`torch.dtype`, *facultatif*) : torch dtype

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

## MochiPipelineOutput[[diffusers.pipelines.mochi.pipeline_output.MochiPipelineOutput]]

#### diffusers.pipelines.mochi.pipeline_output.MochiPipelineOutput[[diffusers.pipelines.mochi.pipeline_output.MochiPipelineOutput]]

```python
diffusers.pipelines.mochi.pipeline_output.MochiPipelineOutput(frames: Tensor)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/mochi/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 Mochi.