# MiniMax-H3

  
    
  

MiniMax-H3 génère la vidéo et sa bande-son simultanément. Un seul transformer débruite une séquence compacte contenant le conditionnement textuel, les médias de conditionnement, ainsi que les latents de la vidéo et de l'audio cibles. Il n'y a ni vocoder séparé ni passe de post-traitement audio : la vidéo et l'audio sortent de la même boucle de débruitage.

Vous pouvez trouver les points de contrôle originaux de MiniMax-H3 sous l'organisation [MiniMaxAI](https://huggingface.co/MiniMaxAI).

MiniMax-H3 est intégré uniquement sous forme de blocs [Modular Diffusers](../../modular_diffusers/overview), de la même manière qu'[Anima](./anima) : les blocs et leur [MiniMaxH3ModularPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/minimax_h3#diffusers.MiniMaxH3ModularPipeline) constituent l'intégralité de l'intégration, et il n'existe pas de moitié `DiffusionPipeline`.

## Disposition du point de contrôle

MiniMax-H3 a été publié sous forme de deux partitions de points de contrôle qui partagent tous les composants, à l'exception du transformeur, de sorte que la conversion diffusers les place toutes deux dans **un seul dépôt** :

| Sous-dossier | Flux de travail |
|---|---|
| `transformer/` | `t2va` (texte uniquement), `fl2va` (première et/ou dernière image clé) |
| `transformer_ref/` | `ref2va` (un mélange ordonné de références d'image, de vidéo et d'audio) |

Tout, à l'exception du transformer, c'est-à-dire le VAE vidéo, le VAE audio, le conditionneur Qwen3-VL, son tokenizer et son processeur, ainsi que les deux schedulers, est partagé et stocké une seule fois.

Le conditionneur est un `Qwen3VLForConditionalGeneration`, et MiniMax-H3 lit l'état caché *non normalisé* après sa 50e couche décodeur plutôt que la dernière, de sorte que le point de contrôle complet publié est utilisé avec sa tête de modèle de langage inutilisée.

Les trois tâches sont des flux de travail du [MiniMaxH3Blocks](/docs/diffusers/v0.43.0/fr/api/pipelines/minimax_h3#diffusers.MiniMaxH3Blocks) unique, et le dépôt contient un `modular_model_index.json` qui nomme chaque composant avec sa propre spécification de chargement. Pour servir une tâche unique, passez le flux de travail à `from_pretrained` : il ne conserve que les blocs de ce flux de travail, de sorte que la signature du pipeline (`pipe.doc`) documente exactement les entrées de cette tâche, seuls les composants de cette tâche sont déclarés, et `load_components` récupère exactement leurs sous-dossiers — un pipeline `t2va` / `fl2va` ne touche jamais à `transformer_ref/`, un pipeline `ref2va` ne touche jamais à `transformer/`.

```py
import torch
from diffusers import ModularPipeline

pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3", workflow="ref2va")
pipe.load_components(dtype=torch.bfloat16)
```

> [!TIP]
> `pipe.doc` affiche ce que le pipeline devant vous reçoit et renvoie — chaque entrée avec sa valeur par défaut, les composants qu’il attend et les sorties qu’il produit. Réduit à un seul flux de travail, il décrit exactement cette tâche, ce qui est le moyen le plus rapide de voir ce qu’une requête nécessite avant de l’envoyer.

Pour conserver tous les flux de travail disponibles sur un seul pipeline, omettez plutôt l'argument `workflow` : le pipeline choisit alors le flux de travail à chaque appel en fonction des entrées qui lui sont transmises.

```py
pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3")
```

Le *chargement* peut toujours se faire un flux de travail à la fois. Cet unique appel récupère `transformer/` ainsi que tous les composants partagés, qui servent à la fois `t2va` et `fl2va` :

```py
pipe.load_components(workflow="t2va", dtype=torch.bfloat16)
```

Un simple `load_components()` sans `workflow=` charge **les deux** partitions de transformeur de 61,7 Go, ce qui permet à un seul pipeline de servir les trois workflows sans un nouvel appel de chargement. Associez-le à un [ComponentsManager](/docs/diffusers/v0.43.0/fr/api/modular_diffusers/pipeline_components#diffusers.ComponentsManager) et au déchargement automatique : les poids résident en RAM hôte et le manager transfère sur l'accélérateur uniquement ce dont chaque étape a besoin, de sorte que lorsque le débruiteur `ref2va` demande le périphérique, la stratégie décharge ce qui libère suffisamment d'espace. Consultez [Mémoire](#memory) pour les recettes.

## Deux planificateurs

Les latents vidéo et audio suivent deux calendriers distincts au sein d'un seul appel de transformateur par étape, c'est pourquoi les blocs s'attendent à deux instances de [MiniMaxH3Scheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/minimax_h3#diffusers.MiniMaxH3Scheduler) : `scheduler` pour les latents vidéo (`shift=12.0` dans les points de contrôle publiés) et `audio_scheduler` pour les latents audio (`shift=3.0`).

Les deux partitions transformer sont distillées par guidage, ce qui s’applique à tous les flux de travail : le guidage est intégré aux poids, il n’y a ni guideur, ni `negative_prompt`, ni `guidance_scale`, et chaque étape exécute exactement un passage avant.

## Contraintes de génération

- **24 images par seconde, 5 à 15 secondes.** `num_frames` est arrondi à la valeur supérieure de la forme `17 * n + 5` que le VAE vidéo peut décoder, et la durée résultante doit rester dans cette plage.
- **Un côté court de 768 pixels.** `height` et `width` sont par défaut réglés sur le canevas propre à MiniMax-H3 pour le ratio d'aspect de la première image clé (ou 16:9 en l'absence de celle-ci) et doivent être des multiples de 32.
- **Un générateur, trois tirages.** Une requête tire d’abord le bruit de conditionnement de la clé d’image ou de référence, puis le bruit vidéo, puis le bruit audio, tous issus du `generator` qui lui est transmis, de sorte que deux exécutions à partir du même état du générateur renvoient la même vidéo et la même bande-son. Transmettre `latents` ou `audio_latents` remplace le tirage correspondant.
- **`num_inference_steps` compte les points de la grille sigma**, le terminal `0` inclus, ce qui réduit d'une évaluation le nombre d'appels au modèle.

## Mémoire

Le transformer seul pèse 61,7 Go en bfloat16 et le conditionneur Qwen3-VL ajoute 62,1 Go, de sorte que la méthode de chargement dépend du matériel. Les toiles plus petites sont le principal levier de vitesse sur toute configuration : `height` et `width` n'ont besoin d'être que des multiples de 32, et 960x544 est environ 2,3 fois plus rapide par étape que la résolution d'entraînement 1344x768.

Sur une carte de 80 Go, enregistrez les composants dans un [ComponentsManager](/docs/diffusers/v0.43.0/fr/api/modular_diffusers/pipeline_components#diffusers.ComponentsManager) et laissez-le les déplacer sur et hors de l'accélérateur :

```py
import torch
from diffusers import ComponentsManager, ModularPipeline

manager = ComponentsManager()
pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3", components_manager=manager)
pipe.load_components(workflow="t2va", dtype=torch.bfloat16)
manager.enable_auto_cpu_offload(device="cuda", memory_reserve_margin="12GB")  # or "mps", "xpu", "cpu"
pipe.transformer.set_attention_backend("_flash_3_hub")  # Hopper, roughly 3x faster; kernels fetched from the Hub
```

Sur une carte grand public (24 à 32 Go), quantifiez les deux grands composants en int8 au moment du chargement et faites défiler les blocs du transformateur depuis la RAM CPU. Tout ce qui suit n'utilise que des chargeurs pris en charge, sans correctifs, et fonctionne directement à partir du point de contrôle bfloat16 :

```py
import torch
from diffusers import MiniMaxH3Transformer3DModel, ModularPipeline, TorchAoConfig
from diffusers.hooks import apply_group_offloading
from transformers import Qwen3VLForConditionalGeneration
from transformers import TorchAoConfig as TransformersTorchAoConfig
from torchao.quantization import Int8WeightOnlyConfig

pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3")
pipe.update_components(
    transformer=MiniMaxH3Transformer3DModel.from_pretrained(
        "MiniMaxAI/MiniMax-H3", subfolder="transformer", dtype=torch.bfloat16,
        quantization_config=TorchAoConfig(
            Int8WeightOnlyConfig(version=2),
            modules_to_not_convert=[
                "proj_in", "audio_proj_in", "context_embedder", "time_embedder", "time_proj",
                "token_refiner", "norm_out", "proj_out", "audio_proj_out",
            ],
        ),
        low_cpu_mem_usage=False,
    ),
    text_encoder=Qwen3VLForConditionalGeneration.from_pretrained(
        "MiniMaxAI/MiniMax-H3", subfolder="text_encoder", dtype=torch.bfloat16,
        quantization_config=TransformersTorchAoConfig(
            Int8WeightOnlyConfig(version=2),
            modules_to_not_convert=["model.visual", "model.language_model.embed_tokens", "model.language_model.norm", "lm_head"],
        ),
    ),
)
pipe.load_components(workflow="t2va", dtype=torch.bfloat16)

# version=2 int8 tensors are pinnable, which streamed offload needs, and freezing removes the one autograd
# path the quantized tensors cannot serve.
pipe.transformer.requires_grad_(False)
pipe.text_encoder.requires_grad_(False)

offload = dict(onload_device=torch.device("cuda"), offload_device=torch.device("cpu"), use_stream=True)
pipe.transformer.enable_group_offload(offload_type="block_level", num_blocks_per_group=1, **offload)
apply_group_offloading(pipe.text_encoder.model, offload_type="leaf_level", **offload)
pipe.vae.to("cuda")  # or "mps", "xpu", "cpu"
pipe.audio_vae.to("cuda")
```

Sur 12 à 16 Go, la même recette fonctionne avec le groupe VAE vidéo également déchargé (`offload_type="leaf_level"`, sans flux) et un petit canevas tel que 960x544. Attendez-vous à ce que les poids résident en RAM hôte : environ 75 Go à int8.

Avec deux cartes, il n'est pas nécessaire de décharger quoi que ce soit : divisez le pipeline en deux et placez chaque moitié sur son propre appareil.

```py
import torch
from diffusers import ComponentsManager, ModularPipeline

workflow = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3").blocks.get_workflow("t2va")

text_manager = ComponentsManager()
text_manager.enable_auto_cpu_offload(device="cuda:1")
conditioner = workflow.sub_blocks.pop("text_encoder").init_pipeline(
    "MiniMaxAI/MiniMax-H3", components_manager=text_manager
)
conditioner.load_components(dtype=torch.bfloat16)

manager = ComponentsManager()
manager.enable_auto_cpu_offload(device="cuda:0")
rest = workflow.init_pipeline("MiniMaxAI/MiniMax-H3", components_manager=manager)
rest.load_components(dtype=torch.bfloat16)

prompt = "A red fox trotting through a snowy pine forest, snow crunching underfoot"
state = conditioner(prompt=prompt)
results = rest(
    state=state,
    num_frames=124,
    generator=torch.Generator().manual_seed(42),
    output=["videos", "audio", "sampling_rate"],
)
```

Deux cartes de 80 Go exécutent le bfloat16 complet de cette manière : chaque moitié tient sur sa propre carte, de sorte que rien n’est évacué vers la mémoire hôte une fois résident. Deux cartes de 48 Go font de même avec le chargement int8 ci-dessus sur les deux composants.

## Texte et images clés

[MiniMaxH3Blocks](/docs/diffusers/v0.43.0/fr/api/pipelines/minimax_h3#diffusers.MiniMaxH3Blocks) covers text-to-video-and-audio and keyframe conditioning. A keyframe can be the frame the video starts from (`image`), the frame it ends on (`last_image`), or both.

```py
import torch
from diffusers import ComponentsManager, ModularPipeline
from diffusers.utils import load_image
from diffusers.utils.export_utils import encode_video

# 61.7GB of transformer and 62.1GB of conditioner do not sit on one accelerator, so the components are
# registered in a manager that moves each one on and off as the blocks reach it. See [Memory](#memory).
manager = ComponentsManager()
manager.enable_auto_cpu_offload(device="cuda")  # or "mps", "xpu", "cpu"

pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3", components_manager=manager)
pipe.load_components(workflow="fl2va", dtype=torch.bfloat16)

prompt = "A red fox trotting through a snowy pine forest, snow crunching underfoot"
# `output=` returns exactly the named outputs instead of the whole pipeline state.
outputs = ["videos", "audio", "sampling_rate"]

# Text to video + audio.
results = pipe(prompt=prompt, num_frames=124, generator=torch.Generator().manual_seed(42), output=outputs)

# First frame (and optionally last frame) to video + audio. The canvas follows the first keyframe.
image = load_image(
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg"
)
results = pipe(prompt=prompt, image=image, num_frames=124, generator=torch.Generator().manual_seed(42), output=outputs)

encode_video(
    results["videos"][0],
    fps=24,
    output_path="minimax_h3_fl2va.mp4",
    audio=results["audio"][0],
    audio_sample_rate=results["sampling_rate"],
)
```

La vidéo et l’audio sont générés conjointement et sortent de l’appel sous forme de sorties distinctes, `videos` et `audio`, à côté du `sampling_rate` que porte la bande-son ; leur multiplexage dans un fichier unique est laissé à l’appelant, par exemple avec [encode_video()](/docs/diffusers/v0.43.0/fr/api/utilities#diffusers.utils.encode_video).

## Références omni

Le workflow `ref2va` conditionne sur une liste ordonnée de références : jusqu’à 9 images, 3 vidéos et 3 clips audio, soit 12 au total. L’ordre est sémantique. Il étiquette les références dans la présentation du prompt (`"<Picture 1>"`, `"<Audio 1>"`, `"<Video 1>"`) et fait avancer l’horloge rotative audio/vidéo partagée, de sorte que réordonner les mêmes références constitue une requête différente.

Contrairement aux images clés ci-dessus, les références ne contraignent pas la géométrie générée : elles sont encodées à leur propre résolution et le canevas cible est par défaut au format 16:9 de MiniMax-H3.

Il existe une classe de référence par modalité, chacune contenant les médias en mémoire et le taux auquel les médias sont transmis :

| référence | media | le taux qu'il déclare |
| --- | --- | --- |
| [MiniMaxH3ImageReference](/docs/diffusers/v0.43.0/fr/api/pipelines/minimax_h3#diffusers.modular_pipelines.minimax_h3.MiniMaxH3ImageReference) | `image` | — |
| [MiniMaxH3VideoReference](/docs/diffusers/v0.43.0/fr/api/pipelines/minimax_h3#diffusers.modular_pipelines.minimax_h3.MiniMaxH3VideoReference) | `frames`, et `audio` pour sa propre bande-son | `fps`, par défaut 24,0 pour MiniMax-H3, et `sample_rate` |
| [MiniMaxH3AudioReference](/docs/diffusers/v0.43.0/fr/api/pipelines/minimax_h3#diffusers.modular_pipelines.minimax_h3.MiniMaxH3AudioReference) | `audio` | `sample_rate`, par défaut celui du VAE audio |

Les taux sont la référence à partir de laquelle tout est rééchantillonné : les images sont ramenées aux 24 fps propres à MiniMax-H3 en supprimant et en dupliquant des images entières, et le signal audio est adapté au taux d’échantillonnage du VAE audio. Les médias aux taux propres à MiniMax-H3 passent sans modification, si bien que seules les données produites à un autre taux doivent le signaler.

Une référence est construite de l’une des deux manières suivantes : décodée depuis un fichier média via la méthode de classe `from_file` de la classe, ou assemblée directement à partir des médias que la requête détient déjà en mémoire — c’est ainsi qu’une génération précédente est réinjectée (voir [Une génération en tant que référence](#a-generation-as-a-reference)).

Les blocs n’ouvrent jamais de fichier média — le décodage d’un chemin est la responsabilité de l’appelant, comme partout ailleurs dans la bibliothèque. Chaque classe de référence le fait via sa méthode de classe `from_file`, qui prend un chemin ou une URL (vidéo et audio via [PyAV](https://github.com/PyAV-Org/PyAV)) et renvoie une référence portant les taux signalés par le conteneur — une vidéo apporte son taux d’images et sa bande-son. Privilégiez `from_file` par rapport à [load_video()](/docs/diffusers/v0.43.0/fr/api/utilities#diffusers.utils.load_video), qui abandonne le taux d’images : une référence construite à partir d’images dont le taux réel a été perdu est conditionnée à la mauvaise vitesse, et rien ne lève d’exception.

```py
import torch
from diffusers import ComponentsManager, ModularPipeline
from diffusers.modular_pipelines.minimax_h3 import (
    MiniMaxH3AudioReference,
    MiniMaxH3ImageReference,
    MiniMaxH3VideoReference,
)
from diffusers.utils import load_video
from diffusers.utils.export_utils import encode_video

# `ref2va` is a workflow of the one MiniMax-H3 pipeline; selecting it loads only the `transformer_ref/`
# checkpoint partition, and the manager moves each component on and off the accelerator in turn.
manager = ComponentsManager()
manager.enable_auto_cpu_offload(device="cuda")  # or "mps", "xpu", "cpu"

pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3", workflow="ref2va", components_manager=manager)
pipe.load_components(dtype=torch.bfloat16)

subject = MiniMaxH3ImageReference.from_file(
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg"
)

# Decoding a file brings its rates along: the video its own frame rate and its soundtrack, the clip its sample rate.
results = pipe(
    prompt="The character speaks in time with the reference recording, natural lip movement",
    references=[
        subject,
        MiniMaxH3VideoReference.from_file(
            "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/hiker.mp4"
        ),
        MiniMaxH3AudioReference.from_file("voice.wav"),
    ],
    num_frames=124,
    output=["videos", "audio", "sampling_rate"],
)

# Frames a request already holds declare the rate they carry — `load_video` does not preserve it.
motion = load_video("motion_ref.mp4")
results = pipe(
    prompt="The subject walks toward camera, matching the reference video's shot rhythm",
    references=[subject, MiniMaxH3VideoReference(frames=motion, fps=30.0)],
    num_frames=124,
    output=["videos", "audio", "sampling_rate"],
)

encode_video(
    results["videos"][0],
    fps=24,
    output_path="minimax_h3_ref2va.mp4",
    audio=results["audio"][0],
    audio_sample_rate=results["sampling_rate"],
)
```

`num_frames` est requis pour `ref2va`. Pour générer une vidéo dont la durée correspond exactement à celle d’une piste audio de référence, calculez cette valeur à partir du clip — `round(samples / sample_rate * 24)` — ; elle est ensuite arrondie à la valeur supérieure de la forme `17 * n + 5`, que le VAE vidéo peut décoder. La durée résultante doit rester comprise entre 5 et 15 secondes, la plage générée par MiniMax-H3.

### Une génération en tant que référence

Comme les flux de travail partagent un même pipeline, une génération `t2va` peut être réinjectée directement comme référence `ref2va` — et le constructeur en mémoire est conçu précisément pour ce transfert. Les médias générés sont déjà aux taux propres de MiniMax-H3 (images à 24 i/s, bande-son au taux d’échantillonnage du VAE audio), la référence n’a donc besoin d’aucun argument de taux et rien n’est réencodé via un conteneur avec perte en cours de route :

```py
import torch
from diffusers import ComponentsManager, ModularPipeline
from diffusers.modular_pipelines.minimax_h3 import MiniMaxH3VideoReference

manager = ComponentsManager()
manager.enable_auto_cpu_offload(device="cuda")  # or "mps", "xpu", "cpu"

# The full pipeline holds every workflow and picks one per call from the inputs. Loading without a
# `workflow=` brings both transformer partitions in one call, so the `ref2va` request that follows the
# `t2va` generation needs no further loading.
pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3", components_manager=manager)
pipe.load_components(dtype=torch.bfloat16)

results = pipe(
    prompt="An astronaut hiking through the mountains, humming a tune",
    num_frames=124,
    output=["videos", "audio", "sampling_rate"],
)

reference = MiniMaxH3VideoReference(
    frames=results["videos"][0],
    audio=results["audio"][0],
    sample_rate=results["sampling_rate"],
)
results = pipe(
    prompt="The same astronaut now walks along a beach at sunset, humming the same tune",
    references=[reference],
    num_frames=124,
    output=["videos", "audio", "sampling_rate"],
)
```

## MiniMaxH3ModularPipeline[[diffusers.MiniMaxH3ModularPipeline]]

#### diffusers.MiniMaxH3ModularPipeline[[diffusers.MiniMaxH3ModularPipeline]]

```python
diffusers.MiniMaxH3ModularPipeline(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/v0.43.0/src/diffusers/modular_pipelines/minimax_h3/modular_pipeline.py#L150)

A ModularPipeline for joint video + audio generation with MiniMax-H3: the `t2va` (text only) and `fl2va` (first and/or last keyframe) workflows against the `transformer/` checkpoint partition, and the `ref2va` (omni-reference) workflow against `transformer_ref/`. One repository holds both partitions, and selecting a workflow loads only its

propre :

```py
pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3", workflow="ref2va")
```

MiniMax-H3 débruite **une séquence empaquetée** qui contient à la fois le conditionnement texte, les latents de conditionnement des images clés, les latents audio et les latents vidéo, ce qui explique pourquoi les blocs transmettent une disposition par ligne plutôt que des tenseurs par modalité, et pourquoi le pipeline utilise deux planificateurs (`shift = 12.0` pour la vidéo, `shift = 3.0` pour l'audio) qui sont exécutés au sein d'un seul appel au transformeur.

Le point de contrôle est distillé par guidage : le guidage est intégré dans les poids, il n’y a donc ni guideur, ni `negative_prompt` ni `guidance_scale`, et chaque étape exécute exactement un passage avant.

MiniMax-H3 est uniquement modulaire : ce pipeline et ses blocs constituent l'intégralité de l'intégration, il n'existe pas de moitié `DiffusionPipeline`. Ce module porte les faits du modèle sur lesquels chaque bloc s'appuie — la géométrie dérivée de la configuration sous forme de propriétés, l'arithmétique du canevas et du nombre de frames sous forme de fonctions — tandis que les contrats de conditionnement, d'encodage et de bruit résident sur les blocs eux-mêmes.

```py
import torch
from diffusers import ModularPipeline

pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3")
pipe.load_components(dtype=torch.bfloat16)
```

## MiniMaxH3Blocks[[diffusers.MiniMaxH3Blocks]]

#### diffusers.MiniMaxH3Blocks[[diffusers.MiniMaxH3Blocks]]

```python
diffusers.MiniMaxH3Blocks()
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/minimax_h3/modular_blocks_minimax_h3.py#L659)

Blocs de pipeline Auto Modular pour la génération conjointe vidéo + audio avec MiniMax-H3 : les workflows `t2va` (texte uniquement), `fl2va` (image clé de début et/ou de fin) et `ref2va` (référence omnidirectionnelle), sélectionnés en fonction des entrées `references` et des images clés. En l'absence de `workflow=`, le chargement des composants récupère **les deux** partitions du transformateur de 61,7 Go — passez-en une pour ne charger que ce dont la tâche a besoin.

Workflows pris en charge :
- `t2va` : nécessite `prompt`
- `fl2va` : nécessite `prompt`, `image` ou `prompt`, `last_image`
- `ref2va` : nécessite `prompt`, `references`

Composants : image_processor (`VaeImageProcessor`) text_encoder (`Qwen3VLForConditionalGeneration`) tokenizer (`Qwen2Tokenizer`) processor (`Qwen3VLProcessor`) vae (`AutoencoderKLMiniMaxH3`) audio_vae (`AutoencoderKLMiniMaxH3Audio`) scheduler (`MiniMaxH3Scheduler`) audio_scheduler (`MiniMaxH3Scheduler`) transformer_ref (`MiniMaxH3Transformer3DModel`) transformer (`MiniMaxH3Transformer3DModel`) video_processor (`VideoProcessor`)

Configurations : canvas_short_edge (par défaut : 768) canvas_max_pixels (par défaut : 1032192) reference_image_short_edge (par défaut : 2048)

Inputs: references (`list`, *optional*): The references to condition on, **in the order the model should read them**: the order labels them in the prompt presentation and lays them out on the shared rotary clock, so a different order is a different request. One dataclass per modality, all holding in-memory media — a `MiniMaxH3ImageReference` (at most 9), a `MiniMaxH3VideoReference` at its own `fps` (at most 3, whose `audio` soundtrack is conditioned on as well), or a `MiniMaxH3AudioReference` at its own `sample_rate` (at most 3) — for at most 12 references in total, and audio references cannot be the only ones. These blocks never open a media file: decode with each class's `from_file` classmethod, which brings the rates along. height (`int`, *optional*): Height of the generated video in pixels, a multiple of 32. width (`int`, *optional*): Width of the generated video in pixels, a multiple of 32. num_frames (`int`, *optional*): Number of frames to generate, at the fixed 24 fps. Snapped up to the next `17 * n + 5` the video VAE can decode; the resulting duration must stay between 5 and 15 seconds. To generate a video as long as a reference soundtrack, pass `round(samples / sample_rate * 24)`. image (`Image`, *optional*): Keyframe the video starts from. It is *stretched* onto the target canvas, which by default is derived from its own aspect ratio. last_image (`Image`, *optional*): Keyframe the video ends on. Can be passed on its own to generate *up to* a frame. Combined with `image` it is the follower of the two and is cover-cropped onto the canvas. prompt (`str`): The prompt to guide generation, a single string. normalized_references (`list`, *optional*): The references normalized by the setup step, in packed order. keyframes (`list`, *optional*): The keyframes put onto the target canvas, in packed order. condition_latents (`list`, *optional*): The encoded video conditioning latents, one per image and video reference in packed order. Their shape is where every reference block's geometry comes from. audio_condition_latents (`list`, *optional*): The encoded audio conditioning rows, one per audio-bearing reference in packed order. generator (`Generator`, *optional*): The generator of the request. The conditioning noise is drawn from it first, one draw per condition, before the noise of the generated rows. latents (`Tensor`): Pre-generated video noise of shape `(1, 24, num_latent_frames, latent_height, latent_width)`, used instead of the draw. audio_latents (`Tensor`): Pre-generated audio noise of shape `(2, 32, num_audio_latents)`. num_inference_steps (`int`, *optional*, defaults to 50): The number of denoising steps. **denoiser_input_fields (`None`, *optional*): The structural description of the packed sequence the transformer reads by name: `token_tags`, `position_ids` and the three row-index tensors. attention_kwargs (`dict`, *optional*): Additional kwargs for attention processors. keyframe_anchors (`tuple`, *optional*, defaults to ()): Which end of the video every keyframe is anchored to, in packed order. output_type (`str`, *optional*, defaults to pil): Output format: 'pil', 'np' or 'pt'.

Sorties : vidéos (`list`) : la vidéo générée. audio (`Tensor`) : la bande-son générée, de forme `(1, 2, num_samples)`. sampling_rate (`int`) : fréquence d'échantillonnage de la bande-son générée, en Hz.

## MiniMaxH3ImageReference[[diffusers.modular_pipelines.minimax_h3.MiniMaxH3ImageReference]]

#### diffusers.modular_pipelines.minimax_h3.MiniMaxH3ImageReference[[diffusers.modular_pipelines.minimax_h3.MiniMaxH3ImageReference]]

```python
diffusers.modular_pipelines.minimax_h3.MiniMaxH3ImageReference(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor])
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/minimax_h3/references.py#L82)

**Paramètres :**

image (`PIL.Image.Image`, `np.ndarray` ou `torch.Tensor`) : L'image de référence : une image, un tableau de forme `(height, width, 3)` ou un tenseur de forme `(3, height, width)`, en `uint8` ou en virgule flottante sur `[0, 1]`. Elle ne lie jamais la géométrie générée — elle est encodée sur son propre côté court, 2048 pour le point de contrôle publié, quelle que soit la toile générée par la requête.

Une référence de sujet, de style ou de scène : au maximum 9 par requête.

#### from_file[[diffusers.modular_pipelines.minimax_h3.MiniMaxH3ImageReference.from_file]]

```python
from_file(media)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/minimax_h3/references.py#L98)

**Paramètres :**

media (`str` ou `os.PathLike`) : Chemin ou URL de l'image.

Chargez un fichier image dans un `MiniMaxH3ImageReference`, via [load_image()](/docs/diffusers/v0.43.0/fr/api/utilities#diffusers.utils.load_image).

## MiniMaxH3VideoReference[[diffusers.modular_pipelines.minimax_h3.MiniMaxH3VideoReference]]

#### diffusers.modular_pipelines.minimax_h3.MiniMaxH3VideoReference[[diffusers.modular_pipelines.minimax_h3.MiniMaxH3VideoReference]]

```python
diffusers.modular_pipelines.minimax_h3.MiniMaxH3VideoReference(frames: typing.Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor], fps: float | None = None, audio: typing.Optional[torch.Tensor] = None, sample_rate: int | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/minimax_h3/references.py#L110)

**Paramètres :**

frames (`list[PIL.Image.Image]`, `np.ndarray` ou `torch.Tensor`) : Les images de référence : une liste d'images, un tableau `(num_frames, height, width, 3)` ou un tenseur `(num_frames, 3, height, width)`, `uint8` ou à virgule flottante sur `[0, 1]`.

fps (`float`, *facultatif*, valeur par défaut 24.0) : La fréquence d'images `frames` transporte, ce qui positionne les blocs visuels de la référence sur la grille 2 fps du conditionneur. L'horloge propre à MiniMax-H3 est de 24 fps, donc toute autre fréquence est rééchantillonnée dessus en supprimant et en dupliquant des images entières — ce qui en fait le champ à régler correctement lorsque les images proviennent d'un fichier.

audio (`torch.Tensor` de forme `(channels, num_samples)`, *facultatif*) : La bande-son de cette vidéo, mono ou stéréo, conditionnée en tant que référence elle-même plutôt que comme référence d’elle-même. Si omise, la référence se conditionne uniquement sur le mouvement.

sample_rate (`int`, *facultatif*) : Le taux auquel `audio` transporte ses échantillons. S'il est omis, le taux propre à la VAE audio est utilisé, ce qui laisse les échantillons inchangés ; tout autre taux entraîne un rééchantillonnage vers celui-ci.

Référence de mouvement et de caméra : au maximum 3 par requête, conditionnées ensemble avec leur propre bande-son.

#### from_file[[diffusers.modular_pipelines.minimax_h3.MiniMaxH3VideoReference.from_file]]

```python
from_file(media)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/minimax_h3/references.py#L146)

**Paramètres :**

media (`str` ou `os.PathLike`) : Chemin ou URL de la vidéo.

**Retourne :** `MiniMaxH3VideoReference`

les images `(num_frames, height, width, 3)` `uint8` à la fréquence d'images déclarée par le conteneur, accompagnées de sa piste audio et du taux d'échantillonnage de cette piste lorsqu'un flux audio est présent.

Décoder un fichier vidéo en `MiniMaxH3VideoReference`, à la résolution, à la fréquence d’images et avec la piste audio qu’il contient.

Les taux sont appliqués à la référence, ce qui est l’objectif de décoder de cette manière plutôt qu’avec [load_video()](/docs/diffusers/v0.43.0/fr/api/utilities#diffusers.utils.load_video) : MiniMax-H3 rééchantillonne une référence sur son propre 24 fps, de sorte qu’un taux de perte en entrée est une requête conditionnée à la mauvaise vitesse, sans aucun avertissement. Un conteneur dont les métadonnées sont incorrectes est corrigé en écrasant `fps` ou `sample_rate` sur la référence renvoyée.

Nécessite [PyAV](https://github.com/PyAV-Org/PyAV).

## MiniMaxH3AudioReference[[diffusers.modular_pipelines.minimax_h3.MiniMaxH3AudioReference]]

#### diffusers.modular_pipelines.minimax_h3.MiniMaxH3AudioReference[[diffusers.modular_pipelines.minimax_h3.MiniMaxH3AudioReference]]

```python
diffusers.modular_pipelines.minimax_h3.MiniMaxH3AudioReference(audio: Tensor, sample_rate: int | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/minimax_h3/references.py#L172)

**Paramètres :**

audio (`torch.Tensor` de forme `(channels, num_samples)`) : La forme d'onde de référence, mono ou stéréo.

sample_rate (`int`, *facultatif*) : Le taux auquel `audio` transporte ses échantillons. S'il est omis, le taux propre à la VAE audio est utilisé, ce qui laisse les échantillons inchangés ; tout autre taux entraîne un rééchantillonnage vers celui-ci.

Référence vocale ou musicale : au maximum 3 par requête, et jamais seule — une référence audio doit être associée à au moins une référence image ou vidéo. Elle n’atteint jamais le conditionneur et est encodée uniquement par le VAE audio.

#### from_file[[diffusers.modular_pipelines.minimax_h3.MiniMaxH3AudioReference.from_file]]

```python
from_file(media)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/modular_pipelines/minimax_h3/references.py#L191)

**Paramètres :**

media (`str` ou `os.PathLike`) : Chemin ou URL de l'audio, ou d'une vidéo dont la bande-son est extraite.

**Retourne :** `MiniMaxH3AudioReference`

le signal audio flottant 32 bits de forme `(channels, num_samples)` à la fréquence d'échantillonnage déclarée par le conteneur.

Décoder un fichier audio en `MiniMaxH3AudioReference`, au taux d'échantillonnage qu'il contient.

Nécessite [PyAV](https://github.com/PyAV-Org/PyAV).