Pipeline local Qwen Image 2.1 et MiniMax H3

Vous savez peut-être déjà produire de bonnes première et dernière images avec Qwen. Le vrai problème est de savoir si H3 peut les relier dans un seul plan continu, sans changer le sujet, ajouter une coupe non demandée ou qualifier de « local » un parcours 2K dépendant d’API. Ce guide propose un chemin par défaut : valider d’abord la chaîne 768p entièrement locale, passer au 2K hybride seulement si la livraison l’exige et comparer H3 local et hébergé avec des entrées identiques.

Commencez ici : choisissez le 768p local sauf besoin réel de 2K

Si votre objectif est de valider le passage entre modèles, de garder les fichiers sur votre machine ou de diagnostiquer des coupes indésirables, commencez par le 768p entièrement local. Choisissez le 2K hybride uniquement si la livraison impose le 2K et si les appels distants à H3-Context-IR et H3-Regenerate-2K sont acceptables.

Votre objectif	Commencez par	Pourquoi	Quand la recommandation change
Prouver que toute la chaîne fonctionne	768p entièrement local	Moins de variables, donc les problèmes Qwen et H3 sont plus faciles à séparer	Passez à la suite quand le 768p est stable et que la livraison exige réellement le 2K
Garder les fichiers sur votre machine	768p entièrement local	Les images Qwen et H3-Base peuvent rester en local	Si le 2K est obligatoire mais les API distantes interdites, le parcours complet documenté ne répond pas au besoin ; il faut une autre solution 2K locale
Livrer la vidéo finale en 2K	2K hybride	Le parcours officiel complet dépend encore de deux modules hébergés	Revenez au 768p ou changez de solution si les fichiers ne peuvent pas être envoyés à distance
Choisir entre H3 local et hébergé	Validez d’abord le 768p local, puis faites un test apparié	Sinon les erreurs de déploiement se mélangent à la qualité du modèle	Fixez le choix à long terme après répétition sur plusieurs types de plans

Ne promettez pas la compatibilité d’après le seul nom du GPU. L’exemple SGLang de MiniMax utilise quatre GPU et l’exécution publique un DGX Spark ; aucun ne donne de VRAM minimale ni ne prouve le fonctionnement sur un GPU grand public ordinaire.

Ce qui peut réellement rester sur votre machine

La création des images avec Qwen et la génération H3-Base en 768p peuvent rester locales ; le parcours officiel complet en 2K ne le peut pas.

Étape	Exécution locale ?	Limite documentée
Générer et modifier les première et dernière images avec Qwen Image 2.1	Oui	Le dépôt officiel fournit `QwenImage21Pipeline`, des exemples Diffusers locaux, des tailles 2K natives et jusqu’à 10 images de référence
Transformer les deux images en audio-vidéo avec MiniMax H3-Base	Oui	Le checkpoint ouvert `FL2VA` accepte zéro, une ou deux images ; deux images activent le mode première/dernière image, avec validation locale en 768p
H3-Context-IR	Pas comme implémentation officielle complète en local	MiniMax le décrit comme un système hébergé de prétraitement et d’orchestration, absent de la version ouverte ; utilisez l’API ou construisez un préprocesseur à partir du guide de prompting
H3-Regenerate-2K	Pas avec les composants ouverts actuels	Le module n’est pas open source ; le workflow 2K officiel l’appelle par API
Comparaison avec H3 hébergé	Non	Une exécution web/API est distante par définition et sert seulement de contrôle apparié

MiniMax documente aussi une sortie de 4 à 15 secondes, 24 FPS, un son stéréo à 32 kHz et un petit côté de 768 pixels par défaut ; le 2K est produit par H3-Regenerate-2K. Ce sont des limites du modèle, pas la garantie que chaque configuration tiendra sur votre matériel.

Un test public prouve la faisabilité, pas un gagnant universel

Utilisez ce cas comme protocole de comparaison, pas comme verdict selon lequel H3 local serait toujours meilleur.

Le réalisateur Sam Wasserman a publié une exécution locale « idée → image → vidéo » sur DGX Spark avec Qwen Image 2.1 et MiniMax H3. La vidéo jointe dure environ huit secondes. Il indique ensuite avoir repris le même prompt, les mêmes spécifications et les mêmes première/dernière images dans le H3 Web payant. Selon son observation, la version web a ajouté une coupe indésirable, alors que la version locale a conservé la séquence voulue.

C’est une preuve de faisabilité utile et un bon protocole de comparaison. Ce n’est pas la preuve que H3 local est généralement supérieur. Les publications ne donnent ni commandes d’installation, ni pic mémoire, ni durée de calcul, ni traitement audio, ni seed, ni essais échoués. Le suivi reste l’évaluation du même auteur sur une seule entrée, pas une réplication indépendante.

Étape 1 : réduire l’idée à un seul plan continu

Demandez un décor, une chaîne d’actions et un état final. Écrivez-les sous forme de contrat de plan : une spécification courte permettant de vérifier l’instruction et le résultat.

Champ	À définir
Sujet et décor	Personnes, objets, vêtements, arrière-plan et traits d’identité qui doivent rester stables
État initial	Position, pose, regard, distance caméra, composition et lumière de la première image
État final	Seulement le changement autorisé à la fin ; évitez de changer en même temps sujet, lieu et position caméra
Trajectoire	Mouvement du sujet, éventuel mouvement caméra et ordre des actions
Contraintes de continuité	Formulations explicites : « un seul plan continu », « aucune coupe », « aucune téléportation »
Spécification de sortie	Durée, ratio et besoin de dialogue, ambiance ou musique
Contraintes négatives	Personnages, sous-titres, changements de scène, remplacement de fond ou actions non souhaitées

Si le test cherche des coupes imprévues, ne demandez pas plusieurs lieux, périodes ou un montage dans le même prompt. Sinon, la coupe peut être une interprétation raisonnable de l’instruction plutôt qu’une erreur.

Par exemple, « marcher de la porte à la table, prendre la tasse, sans coupe » convient à un test première/dernière image. « Passer de la rue au bureau, puis montrer un souvenir d’enfance » exige naturellement plusieurs scènes et ne permet pas de mesurer proprement les coupes indésirables.

Étape 2 : générer la première image, puis la modifier pour créer la dernière

Créez la dernière image en modifiant la première plutôt qu’en générant deux images indépendantes. Il devient plus facile de préserver identité, vêtements, composition et décor avant même le lancement de H3.

L’ID officiel est Qwen/Qwen-Image-2.1. Qwen documente un composant visuel de 7B paramètres, Diffusers en local, génération et édition, 2K natif et jusqu’à 10 images de référence.

pip install "torch>=2.4.0" "transformers>=5.17" accelerate pillow
pip install git+https://github.com/huggingface/diffusers

from pathlib import Path

import torch
from diffusers import QwenImage21Pipeline

first_prompt = Path("first_prompt.txt").read_text(encoding="utf-8").strip()
last_edit_prompt = Path("last_edit_prompt.txt").read_text(encoding="utf-8").strip()

pipe = QwenImage21Pipeline.from_pretrained(
    "Qwen/Qwen-Image-2.1",
    torch_dtype=torch.bfloat16,
).to("cuda")

first = pipe(
    prompt=first_prompt,
    width=2752,
    height=1536,
    num_inference_steps=40,
    generator=torch.Generator("cuda").manual_seed(42),
).images[0]
first.convert("RGB").save("first.png")

last = pipe(
    prompt=last_edit_prompt,
    image=first,
    width=2752,
    height=1536,
    num_inference_steps=40,
    generator=torch.Generator("cuda").manual_seed(43),
).images[0]
last.convert("RGB").save("last.png")

Le code combine les interfaces officielles de génération et d’édition d’une image ; vous fournissez first_prompt et last_edit_prompt. Il utilise la taille 16:9 documentée 2752 × 1536, 40 étapes et des PNG RGB opaques. La documentation publique de H3 ne précise pas le traitement du canal alpha dans ce passage ; des images opaques retirent donc une variable sauf validation RGBA séparée.

Consignez au minimum :

ID du modèle, version du framework, prompt initial et prompt de modification finale ;
les deux seeds, largeur, hauteur, nombre d’étapes et liste des références ;
SHA-256, dimensions et mode couleur des deux fichiers ;
stabilité de l’identité, des vêtements, de la composition, de la lumière et du décor ;
le fait que la dernière image montre seulement l’état final, pas toute la séquence de mouvement.

Qwen documente aussi enable_model_cpu_offload() pour les GPU à mémoire limitée. Cela prouve l’existence d’un offload CPU, mais ne fixe ni VRAM minimale ni vitesse garantie pour ce pipeline.

Étape 3 : faire lire les mêmes entrées à H3 local et hébergé

Ne ressaisissez pas les paramètres de mémoire dans deux interfaces. Regroupez images, prompt et réglages de sortie dans un seul manifeste ; un seed, une durée ou un prompt réécrit peuvent invalider toute la comparaison.

experiment_id: "qwen-h3-001"
qwen_model: "Qwen/Qwen-Image-2.1"
h3_model: "MiniMaxAI/MiniMax-H3"
h3_variant: "fl2va"
prompt_file: "prompt.txt"
first_frame: "first.png"
last_frame: "last.png"
prompt_sha256: "<sha256>"
first_frame_sha256: "<sha256>"
last_frame_sha256: "<sha256>"
duration_seconds: "<same value>"
aspect_ratio: "<same value>"
local_seed: "<record if exposed>"
hosted_seed: "<record or not_exposed>"

Les exécutions locale et hébergée doivent lire ce manifeste. Si l’interface hébergée masque le seed, réécrit le prompt ou limite la durée, notez not_exposed ou conservez le prompt réécrit. Ne prétendez pas que les paramètres sont identiques lorsqu’ils ne sont pas vérifiables : les écarts de résultat ne s’interprètent qu’après contrôle des entrées visibles.

Étape 4 : faire fonctionner d’abord H3-Base local en 768p

Validez d’abord le résultat 768p et pensez au 2K ensuite. Des images Qwen en 2K ne transforment pas la vidéo locale H3-Base en 2K.

MiniMax publie deux checkpoints spécialisés. Ici, MiniMax-H3 Base FL2VA génère de l’audio-vidéo depuis du texte, la première image, la dernière ou les deux en BF16. Les commandes officielles de téléchargement et de service SGLang sont :

hf download MiniMaxAI/MiniMax-H3 \
  --include "FL2VA/*" \
  --local-dir MiniMax-H3

sglang serve \
  --model-path MiniMaxAI/MiniMax-H3 \
  --num-gpus 4 \
  --ulysses-degree 4 \
  --performance-mode speed \
  --host 0.0.0.0 \
  --port 30010 \
  --model-variant fl2va

La deuxième commande est l’exemple MiniMax à quatre GPU. Ce n’est ni la configuration DGX Spark publiée par Wasserman, ni une exigence minimale. Ajustez-la uniquement avec la documentation du framework et consignez toute modification ; ne la présentez pas comme garantie pour toutes les machines.

Rendez les deux images visibles par le processus SGLang

FL2VA accepte une ou deux conditions image avec role: "keyframe". Le guide officiel H3 de SGLang définit frame_index: 0 comme première image, frame_index: -1 comme dernière, et [0, -1] comme l’ensemble des deux extrémités. Le script reproductible de MiniMax montre le cas de la première image seule ; la requête ci-dessous emploie les mêmes champs avec les deux images.

L’URI file:// est résolue par le processus serveur SGLang, pas par le terminal qui exécute curl. Si les deux tournent sur le même hôte, les chemins absolus fournis par realpath conviennent. Si SGLang est dans un conteneur ou sur une autre machine, montez ou copiez les deux fichiers dans cet environnement, puis remplacez FIRST_URI et LAST_URI par des chemins lisibles par le serveur.

Enregistrez le contrat de plan dans prompt.txt. En 768p entièrement local, il peut contenir votre propre prompt structuré. Dans le parcours 2K hybride, placez le résultat de H3-Context-IR dans le même champ prompt, puis envoyez la sortie H3-Base à H3-Regenerate-2K.

Envoyez FL2VA, attendez la fin et enregistrez le MP4

Le script suit le cycle asynchrone documenté : il crée la tâche avec POST /v1/videos et lit .id, interroge GET /v1/videos/{id}, puis n’appelle GET /v1/videos/{id}/content qu’une fois status égal à completed. Le cookbook officiel traite failed comme un échec terminal ; tout autre état non vide reste dans la boucle d’attente.

set -euo pipefail

BASE_URL="${BASE_URL:-http://127.0.0.1:30010}"
FIRST_URI="${FIRST_URI:-file://$(realpath first.png)}"
LAST_URI="${LAST_URI:-file://$(realpath last.png)}"
PROMPT_FILE="${PROMPT_FILE:-prompt.txt}"
OUTPUT_FILE="${OUTPUT_FILE:-fl2va.mp4}"

payload=$(
  jq -n \
    --rawfile prompt "$PROMPT_FILE" \
    --arg first "$FIRST_URI" \
    --arg last "$LAST_URI" \
    '{
      model: "MiniMaxAI/MiniMax-H3",
      task: "fl2va",
      prompt: $prompt,
      seconds: 8,
      conditions: [
        {
          type: "image",
          uri: $first,
          role: "keyframe",
          frame_index: 0
        },
        {
          type: "image",
          uri: $last,
          role: "keyframe",
          frame_index: -1
        }
      ],
      target: {
        short_edge: 768,
        aspect_ratio: "auto",
        duration_seconds: 8
      },
      seed: 0
    }'
)

response=$(
  curl --fail-with-body --silent --show-error \
    --request POST \
    --url "$BASE_URL/v1/videos" \
    --header 'Content-Type: application/json' \
    --data-binary "$payload"
)

video_id=$(printf '%s\n' "$response" | jq -er '.id')
printf 'video_id=%s\n' "$video_id"

while true; do
  task_json=$(
    curl --fail-with-body --silent --show-error \
      --request GET \
      --url "$BASE_URL/v1/videos/$video_id"
  )
  status=$(printf '%s\n' "$task_json" | jq -er '.status')
  printf 'status=%s\n' "$status"

  case "$status" in
    completed)
      break
      ;;
    failed)
      printf '%s\n' "$task_json" | jq .
      exit 1
      ;;
    *)
      sleep 1
      ;;
  esac
done

curl --fail-with-body --silent --show-error --location \
  --request GET \
  --url "$BASE_URL/v1/videos/$video_id/content" \
  --output "$OUTPUT_FILE"

test -s "$OUTPUT_FILE"

if command -v ffprobe >/dev/null 2>&1; then
  ffprobe -v error \
    -show_entries stream=codec_type,codec_name,r_frame_rate,sample_rate,channels \
    -of default=noprint_wrappers=1 \
    "$OUTPUT_FILE"
fi

printf 'saved=%s\n' "$OUTPUT_FILE"

curl --fail-with-body s’arrête sur une réponse hors 2xx, et jq -e échoue si .id ou .status manque. Avec failed, le script affiche le JSON complet de la tâche puis quitte avec un code non nul ; le parcours de succès exige aussi un téléchargement réussi et un MP4 non vide.

Si ffprobe est installé, le script affiche les flux du fichier. Le contrat documenté par SGLang est un MP4 contenant de la vidéo H.264 à 24 FPS et une piste AAC stéréo à 32 kHz. Si la tâche indique completed mais que le fichier est vide, illisible ou possède des propriétés inattendues, ne passez pas au contrôle hébergé : vérifiez d’abord les journaux SGLang, les URI visibles par le serveur et le JSON envoyé.

Les champs et endpoints proviennent du script FL2VA reproductible officiel de MiniMax, du cookbook MiniMax-H3 de SGLang et du guide de l’API vidéo SGLang. Le parcours entièrement local se termine ici par un MP4 H3-Base en 768p ; le 2K complet reste le parcours hybride décrit plus haut.

Étape 5 : comparer avec H3 hébergé seulement après stabilisation du local

Ne comparez pas la qualité tant que la chaîne locale échoue encore. Sinon, erreurs de déploiement, différences d’entrée et comportement du modèle deviennent impossibles à séparer. Ne changez que le lieu d’exécution :

Téléversez exactement les mêmes octets pour les deux images et vérifiez leurs hash.
Réutilisez prompt, durée, ratio, langue et intention audio.
Notez si le web/API réécrit le prompt, expose un seed ou appelle H3-Context-IR.
Conservez les sorties originales ; ne montez, ne réencodez et n’ajoutez pas de musique avant comparaison.
Masquez l’origine des fichiers et évaluez à l’aveugle pour réduire le biais « le local doit être meilleur » ou « le payant doit être meilleur ».

Pour comparer les coûts, relevez votre facture API, le temps d’occupation de la machine et l’électricité. Les étiquettes « local » et « web payant » ne suffisent pas à dire quelle route coûte moins cher pour votre charge.

Étape 6 : choisir la meilleure route pour vos plans avec une seule grille

Vérifiez d’abord si la vidéo remplit la tâche créative, puis comparez temps et matériel. Une sortie plus définie qui ajoute sans cesse des coupes peut rester le mauvais choix de production.

Critère	Comment vérifier	À consigner
Fidélité à la première image	Le début conserve-t-il sujet, composition et objets, ou les remplace-t-il immédiatement ?	Écart et timecode
Arrivée à la dernière image	La vidéo atteint-elle naturellement l’état final ou bascule-t-elle brusquement ?	État final et qualité de transition
Continuité du plan	Y a-t-il des coupes, téléportations, substitutions de scène ou sauts temporels non demandés ?	Timecodes et captures avant/après
Stabilité identité/décor	Visage, vêtements, mains, accessoires et géométrie du fond restent-ils stables ?	Élément affecté et durée
Trajectoire	Sujet et caméra suivent-ils l’ordre et la direction convenus ?	Mauvaise direction, accélération ou arrêt
Audio	Si demandé, la piste existe-t-elle, est-elle synchronisée et sans clics ni contenu étranger ?	Propriétés, décalage et segment anormal
Spécification	Durée, ratio, FPS et résolution correspondent-ils aux réglages ?	Métadonnées réelles
Ressources	Temps mural, pic mémoire accélérateur, RAM et relances	Journaux bruts de chaque exécution, pas d’estimation
Répétabilité	Le problème réapparaît-il avec la même entrée contrôlée ?	Résultats répétés et paramètres aléatoires visibles

MiniMax indique que H3 peut générer un son stéréo à 32 kHz. Les publications de Wasserman ne précisent pas si l’audio a été activé, conservé ou post-traité. Vous pouvez inspecter votre sortie, mais pas citer cet exemple comme validation audio.

Corriger la couche amont au lieu de tout relancer

Une mauvaise première image se corrige dans Qwen, un problème de continuité dans H3 et un écart de résolution commence par le choix entre 768p local et 2K hybride. Le diagnostic par couche fait gagner du temps par rapport au changement simultané de tous les paramètres.

Symptôme	Vérifier d’abord	Action
La première image est déjà incorrecte	Étape Qwen	Corrigez prompt, références et seed au lieu de réparer une mauvaise composition dans H3
L’identité ou le fond change à la fin	Actif Qwen transmis	Modifiez depuis la première image, réduisez les changements et réutilisez des références stables
Une coupe inattendue apparaît	Prompt H3 et contraintes	Exigez un plan continu, retirez le langage de montage/multiples scènes et relancez avec les mêmes hash
La vidéo n’atteint pas la fin	Durée ou plan de mouvement	Raccourcissez les actions et définissez début–processus–fin
Audio absent ou incohérent	Variante H3, client et conteneur	Confirmez checkpoint et chemin audio-vidéo ; marquez les exécutions sans audio comparable comme non comparables
Qwen manque de mémoire	Déploiement image	Essayez le CPU offload documenté et mesurez l’impact ; n’inférez pas une VRAM minimale universelle
H3 ne démarre pas	Déploiement H3	Suivez le guide du framework ; l’exemple officiel emploie quatre GPU, sans garantie pour le matériel grand public
Le local reste en 768p et le 2K exige l’API	Limite du workflow	C’est l’architecture documentée, pas une panne ; acceptez 768p ou choisissez le 2K hybride
Local et hébergé divergent fortement	Entrées et prétraitement	Vérifiez réécriture, Context-IR, seed, durée, ratio et réencodage avant d’accuser le modèle

Comment choisir H3 local ou hébergé pour un usage durable

Décidez avec votre ensemble de plans, pas avec la meilleure image isolée. Couvrez caméra statique, action humaine, transformation d’objet, dialogue et ambiance, en conservant réussites et échecs ; séparez les mesures suivantes :

durée du clip, par exemple les huit secondes environ du cas public ;
temps de génération, entre l’envoi et le fichier terminé, non publié dans ce cas ;
spécifications du modèle, issues de la documentation fournisseur ;
usage matériel réel, mesuré sur votre système plutôt que déduit du nom de l’appareil ;
un jugement visuel, valable pour cette exécution et non convertible directement en taux global de victoire.

Si les fichiers ne doivent pas quitter votre machine, gardez le 768p local par défaut. Si la livraison finale exige le 2K et que les API distantes sont acceptables, choisissez le 2K hybride. Si la continuité prime, évaluez à l’aveugle H3 local et hébergé sur le même ensemble de plans et privilégiez la route qui passe votre grille le plus régulièrement. Le cas public montre que le local fonctionne et a évité une coupe dans un test à entrée identique ; il ne remplace pas vos répétitions.

Vérifiez ces huit points avant l’exécution

L’exécution est étiquetée « 768p entièrement local » ou « 2K hybride », sans mélange.
Modèle Qwen, prompts, seeds, dimensions et références sont consignés pour les deux images.
Images et prompt sont hashés, et les deux exécutions H3 utilisent les mêmes entrées.
L’exécution locale utilise fl2va et est d’abord acceptée comme résultat H3-Base 768p.
Les réécritures et paramètres masqués de l’hébergé sont documentés honnêtement.
Les vidéos originales restent intactes et utilisent la même grille de continuité, coupes, audio et spécifications.
Temps, pic mémoire, relances et échecs proviennent des journaux.
Les conclusions sont limitées aux échantillons, au matériel et à la date vérifiés.

Conclusion

La recommandation par défaut est claire : créez localement les première et dernière images avec Qwen Image 2.1, puis validez le 768p local avec MiniMax H3-Base fl2va. Passez à H3-Context-IR → H3-Base local → H3-Regenerate-2K uniquement si le 2K est obligatoire et les API distantes acceptables.

Dans les deux cas, figez images, prompt, durée et ratio, puis comparez continuité, coupes indésirables, audio, temps et usage matériel avec les mêmes entrées. Une belle démonstration devient ainsi un flux que vous pouvez auditer, comparer et adopter en connaissance de cause.

Références

Faits vérifiés le 26 septembre 2026.

Fonctionnement des récompenses

Qwen Image 2.1 + MiniMax H3 : pipeline vidéo local avec première et dernière image

Commencez ici : choisissez le 768p local sauf besoin réel de 2K

Ce qui peut réellement rester sur votre machine

Un test public prouve la faisabilité, pas un gagnant universel

Étape 1 : réduire l’idée à un seul plan continu

Étape 2 : générer la première image, puis la modifier pour créer la dernière

Étape 3 : faire lire les mêmes entrées à H3 local et hébergé

Étape 4 : faire fonctionner d’abord H3-Base local en 768p

Rendez les deux images visibles par le processus SGLang

Envoyez FL2VA, attendez la fin et enregistrez le MP4

Étape 5 : comparer avec H3 hébergé seulement après stabilisation du local

Étape 6 : choisir la meilleure route pour vos plans avec une seule grille

Corriger la couche amont au lieu de tout relancer

Comment choisir H3 local ou hébergé pour un usage durable

Vérifiez ces huit points avant l’exécution

Conclusion

Références

Prêt à optimiser votre workflow LLM ?

Commencez ici : choisissez le 768p local sauf besoin réel de 2K

Ce qui peut réellement rester sur votre machine

Un test public prouve la faisabilité, pas un gagnant universel

Étape 1 : réduire l’idée à un seul plan continu

Étape 2 : générer la première image, puis la modifier pour créer la dernière

Étape 3 : faire lire les mêmes entrées à H3 local et hébergé

Étape 4 : faire fonctionner d’abord H3-Base local en 768p

Rendez les deux images visibles par le processus SGLang

Envoyez FL2VA, attendez la fin et enregistrez le MP4

Étape 5 : comparer avec H3 hébergé seulement après stabilisation du local

Étape 6 : choisir la meilleure route pour vos plans avec une seule grille

Corriger la couche amont au lieu de tout relancer

Comment choisir H3 local ou hébergé pour un usage durable

Vérifiez ces huit points avant l’exécution

Conclusion

Références

Tous les articles

Prêt à optimiser votre workflow LLM ?