Comment former et utiliser les modèles vidéo LoRA de Hunyuan

Cet article vous montrera comment installer et utiliser un logiciel basé sur Windows qui peut former Modèles vidéo LoRA de Hunyuan, permettant à l'utilisateur de générer des personnalités personnalisées dans le modèle de fondation Hunyuan Video :

Cliquez pour jouer. Exemples de l'explosion récente des LoRA Hunyuan célèbres de la communauté civit.ai.

À l’heure actuelle, les deux méthodes les plus populaires pour générer des modèles Hunyuan LoRA localement sont :

1) La Framework basé sur Docker diffusion-pipe-ui, qui repose sur Sous-système Windows pour Linux (WSL) pour gérer certains processus.

2) Accordeur Musubi, un nouvel ajout à la populaire Kohya ss Architecture de formation par diffusion. Musubi Tuner ne nécessite pas Docker et ne dépend pas de WSL ou d'autres proxys basés sur Linux, mais il peut être difficile de le faire fonctionner sous Windows.

Par conséquent, cette analyse se concentrera sur Musubi Tuner et sur la fourniture d'une solution entièrement locale pour la formation et la génération Hunyuan LoRA, sans l'utilisation de sites Web pilotés par API ou de processus de location de GPU commerciaux tels que Runpod.

Cliquez pour jouer. Exemples de formation LoRA sur Musubi Tuner pour cet article. Toutes les autorisations accordées par la personne représentée, dans le but d'illustrer cet article.

EXIGENCES

L'installation nécessitera au minimum un PC Windows 10 avec une carte NVIDIA série 30+/40+ dotée d'au moins 12 Go de VRAM (bien que 16 Go soient recommandés). L'installation utilisée pour cet article a été testée sur une machine avec 64 Go de Système RAM et une carte graphique NVIDIA 3090 avec 24 Go de VRAM. Le test a été effectué sur un système de test dédié utilisant une nouvelle installation de Windows 10 Professionnel, sur une partition avec plus de 600 Go d'espace disque disponible.

ATTENTION

L'installation de Musubi Tuner et de ses prérequis implique également l'installation de logiciels et de packages destinés aux développeurs directement sur l'installation principale de Windows d'un PC. En prenant en compte l'installation de ComfyUI, pour les étapes finales, ce projet nécessitera environ 400 à 500 gigaoctets d'espace disque. Bien que j'aie testé la procédure sans incident à plusieurs reprises dans des environnements de test Windows 10 nouvellement installés, ni moi ni unite.ai ne sommes responsables des dommages causés aux systèmes suite au suivi de ces instructions. Je vous conseille de sauvegarder toutes les données importantes avant de tenter ce type de procédure d'installation.

Points d’Usage à Anticiper

Cette méthode est-elle toujours valable ?

La scène de l’IA générative évolue très rapidement et nous pouvons nous attendre à des méthodes meilleures et plus rationalisées des cadres Hunyuan Video LoRA cette année.

… ou même cette semaine ! Pendant que j’écrivais cet article, le développeur de Kohya/Musubi a produit interface utilisateur Musubi Tuner, une interface graphique Gradio sophistiquée pour Musubi Tuner :

De toute évidence, une interface utilisateur conviviale est préférable aux fichiers BAT que j'utilise dans cette fonctionnalité – une fois que musubi-tuner-gui fonctionne. Au moment où j'écris ces lignes, il n'est en ligne que depuis cinq jours et je n'ai trouvé aucun témoignage de quelqu'un l'ayant utilisé avec succès.

Selon les publications du référentiel, la nouvelle interface graphique devrait être intégrée directement au projet Musubi Tuner dès que possible, ce qui mettra fin à son existence actuelle en tant que référentiel GitHub autonome.

D'après les instructions d'installation actuelles, la nouvelle interface graphique est clonée directement dans l'environnement virtuel Musubi existant et, malgré de nombreux efforts, je ne parviens pas à l'associer à l'installation Musubi existante. Cela signifie que lorsqu'elle s'exécute, elle se rend compte qu'elle n'a pas de moteur !

Une fois l'interface graphique intégrée à Musubi Tuner, les problèmes de ce type seront sûrement résolus. Bien que l'auteur admet que le nouveau projet est « vraiment difficile », il est optimiste quant à son développement et son intégration directement dans Musubi Tuner.

Compte tenu de ces problèmes (concernant également les chemins par défaut au moment de l'installation et l'utilisation de la Paquet Python UV, ce qui complique certaines procédures dans la nouvelle version), nous devrons probablement attendre un peu pour une expérience de formation Hunyuan Video LoRA plus fluide. Cela dit, cela semble très prometteur !

Mais si vous ne pouvez pas attendre et êtes prêt à retrousser un peu vos manches, vous pouvez obtenir une formation vidéo LoRA Hunyuan exécutée localement dès maintenant.

Commençons.

Pourquoi installer Rien sur Bare Metal ?

(Sautez ce paragraphe si vous n'êtes pas un utilisateur avancé)
Les utilisateurs avancés se demanderont pourquoi j'ai choisi d'installer autant de logiciels sur l'installation Windows 10 bare metal plutôt que dans un environnement virtuel. La raison est que le port Windows essentiel du système d'exploitation basé sur Linux Forfait Triton Il est beaucoup plus difficile de faire fonctionner le système dans un environnement virtuel. Toutes les autres installations bare-metal du didacticiel ne peuvent pas être installées dans un environnement virtuel, car elles doivent s'interfacer directement avec le matériel local.

Installation des packages et programmes prérequis

Pour les programmes et packages à installer initialement, l'ordre d'installation est important. Commençons.

1 : Télécharger le redistribuable Microsoft

Téléchargez et installez le package redistribuable Microsoft à partir de https://aka.ms/vs/17/release/vc_redist.x64.exe.

Il s'agit d'une installation simple et rapide.

2 : Installer Visual Studio 2022

Téléchargez l'édition communautaire de Microsoft Visual Studio 2022 à partir de https://visualstudio.microsoft.com/downloads/?cid=learn-onpage-download-install-visual-studio-page-cta

Démarrez le programme d’installation téléchargé :

Nous n'avons pas besoin de tous les packages disponibles, ce qui représenterait une installation longue et fastidieuse. Charges de travail page qui s'ouvre, cochez Développement de bureau avec C++ (voir l'image ci-dessous).

Maintenant, cliquez sur le Composants individuels Cliquez sur l'onglet en haut à gauche de l'interface et utilisez le champ de recherche pour trouver « Windows SDK ».

Par défaut, seul le SDK Windows 11 est cochée. Si vous êtes sous Windows 10 (cette procédure d'installation n'a pas été testée par mes soins sous Windows 11), cochez la dernière version de Windows 10, indiquée dans l'image ci-dessus.

Recherchez « C++ CMake » et vérifiez que Outils C++ CMake pour Windows est vérifié.

Cette installation prendra au moins 13 Go d'espace.

Une fois Visual Studio installé, il tentera de s'exécuter sur votre ordinateur. Laissez-le s'ouvrir complètement. Lorsque l'interface plein écran de Visual Studio est enfin visible, fermez le programme.

3 : Installer Visual Studio 2019

Certains des packages ultérieurs pour Musubi attendent une ancienne version de Microsoft Visual Studio, tandis que d'autres ont besoin d'une version plus récente.

Téléchargez donc également l'édition communautaire gratuite de Visual Studio 19 auprès de Microsoft (https://visualstudio.microsoft.com/vs/older-downloads/ – compte requis) ou Techspot (https://www.techspot.com/downloads/7241-visual-studio-2019.html).

Installez-le avec les mêmes options que pour Visual Studio 2022 (voir la procédure ci-dessus, sauf que SDK windows est déjà cochée dans le programme d'installation de Visual Studio 2019).

Vous verrez que le programme d'installation de Visual Studio 2019 est déjà conscient de la nouvelle version lors de son installation :

Une fois l'installation terminée et que vous avez ouvert et fermé l'application Visual Studio 2019 installée, ouvrez une invite de commande Windows (tapez CMD (dans Démarrer la recherche) et saisissez :

where cl

Le résultat devrait correspondre aux emplacements connus des deux éditions de Visual Studio installées.

Si vous obtenez plutôt INFO: Could not find files for the given pattern(s), voir le Vérifier le chemin section de cet article ci-dessous et utilisez ces instructions pour ajouter les chemins Visual Studio pertinents à l'environnement Windows.

Enregistrez toutes les modifications apportées conformément aux Vérifier les chemins section ci-dessous, puis essayez à nouveau la commande where cl.

4 : Installer les boîtes à outils CUDA 11 + 12

Les différents packages installés dans Musubi nécessitent des versions différentes de NVIDIA CUDA, qui accélère et optimise la formation sur les cartes graphiques NVIDIA.

La raison pour laquelle nous avons installé les versions de Visual Studio premier c'est que les installateurs NVIDIA CUDA recherchent et s'intègrent à toutes les installations Visual Studio existantes.

Téléchargez un package d'installation CUDA série 11+ à partir de :

https://developer.nvidia.com/cuda-11-8-0-download-archive?target_os=Windows&target_arch=x86_64&target_version=11&target_type=exe_local (télécharger 'exe (local') )

Téléchargez un package d'installation de la série 12+ CUDA Toolkit à partir de :

https://developer.nvidia.com/cuda-downloads?target_os=Windows&target_arch=x86_64

Le processus d'installation est identique pour les deux programmes d'installation. Ignorez les avertissements concernant l'existence ou la non-existence de chemins d'installation dans les variables d'environnement Windows. Nous nous en occuperons manuellement plus tard.

Installer NVIDIA CUDA Toolkit V11+

Démarrez le programme d’installation de la boîte à outils CUDA série 11+.

At Options d'installation, choisissez Personnalisé (avancé) et continuez.

Décochez l'option NVIDIA GeForce Experience et cliquez sur Suivant.

Quitter Sélectionnez l'emplacement d'installation par défaut (c'est important) :

Cliquez Suivant et laissez l'installation se terminer.

Ignorez tout avertissement ou remarque que l'installateur donne à ce sujet. Nsight Visual Studio intégration, qui n'est pas nécessaire pour notre cas d'utilisation.

Installer NVIDIA CUDA Toolkit V12+

Répétez l'ensemble du processus pour le programme d'installation distinct du kit d'outils NVIDIA 12+ que vous avez téléchargé :

Le processus d'installation de cette version est identique à celui indiqué ci-dessus (version 11+), à l'exception d'un avertissement concernant les chemins d'environnement, que vous pouvez ignorer :

Une fois l'installation de la version 12+ CUDA terminée, ouvrez une invite de commande dans Windows et tapez et entrez :

nvcc --version

Cela devrait confirmer les informations sur la version du pilote installé :

Pour vérifier que votre carte est reconnue, tapez et entrez :

nvidia-smi

5 : Installer GIT

GIT se chargera de l'installation du dépôt Musubi sur votre machine locale. Téléchargez l'installateur GIT à l'adresse suivante :

https://git-scm.com/downloads/win (« Installation de Git 64 bits pour Windows »)

Exécutez le programme d'installation:

Utiliser les paramètres par défaut pour Sélectionnez les composants:

Laissez l'éditeur par défaut à Vim:

Laissez GIT décider des noms de branches :

Utilisez les paramètres recommandés pour le Chemin Environnement:

Utilisez les paramètres recommandés pour SSH :

Utilisez les paramètres recommandés pour Backend de transport HTTPS:

Utilisez les paramètres recommandés pour les conversions de fin de ligne :

Choisissez la console Windows par défaut comme émulateur de terminal :

Utiliser les paramètres par défaut (Avance rapide ou fusion) pour Git Pull :

Utilisez Git-Credential Manager (le paramètre par défaut) pour Credential Helper :

In Configuration des options supplémentaires, quitter Activer la mise en cache du système de fichiers coché, et Activer les liens symboliques décoché (sauf si vous êtes un utilisateur avancé qui utilise des liens physiques pour un référentiel de modèles centralisé).

Terminez l'installation et testez que Git est correctement installé en ouvrant une fenêtre CMD et en tapant et en entrant :

git --version

Connexion GitHub

Plus tard, lorsque vous tenterez de cloner des dépôts GitHub, il se peut que vous soyez invité à fournir vos informations d'identification GitHub. Pour éviter cela, connectez-vous à votre compte GitHub (créez-en un, si nécessaire) sur n'importe quel navigateur installé sur votre système Windows. De cette façon, la méthode d'authentification 0Auth (une fenêtre contextuelle) devrait prendre le moins de temps possible.

Après ce défi initial, vous devriez rester authentifié automatiquement.

6 : Installer CMake

CMake 3.21 ou une version plus récente est nécessaire pour certaines parties du processus d'installation de Musubi. CMake est une architecture de développement multiplateforme capable d'orchestrer divers compilateurs et de compiler des logiciels à partir du code source.

Téléchargez-le sur :

https://cmake.org/download/  (« Installateur Windows x64 »)

Lancez le programme d'installation :

Qu'on Assure Ajoutez Cmake à la variable d'environnement PATH est vérifié.

Presse Suivant.

Tapez et entrez cette commande dans une invite de commande Windows :

cmake --version

Si CMake est installé avec succès, il affichera quelque chose comme :

cmake version 3.31.4
CMake suite maintained and supported by Kitware (kitware.com/cmake).

7 : Installer Python 3.10

L'interpréteur Python est au cœur de ce projet. Téléchargez la version 3.10 (le meilleur compromis entre les différentes exigences des packages Musubi) à l'adresse suivante :

https://www.python.org/downloads/release/python-3100/ (« Installateur Windows (64 bits) »)

Exécutez le programme d'installation de téléchargement et laissez les paramètres par défaut :

À la fin du processus d'installation, cliquez sur Désactiver la limite de longueur du chemin (nécessite la confirmation de l'administrateur UAC) :

Dans une invite de commande Windows, tapez et entrez :

python --version

Cela devrait aboutir à Python 3.10.0

Vérifier les chemins

Le clonage et l'installation des frameworks Musubi, ainsi que son fonctionnement normal après l'installation, nécessitent que ses composants connaissent le chemin vers plusieurs composants externes importants dans Windows, notamment CUDA.

Nous devons donc ouvrir l’environnement path et vérifier que tous les prérequis s’y trouvent.

Un moyen rapide d'accéder aux commandes de l'environnement Windows consiste à taper Editer les variables d'environnement du système dans la barre de recherche Windows.

En cliquant dessus, vous ouvrirez le Propriétés système panneau de contrôle. Dans le coin inférieur droit de Propriétés système, clique le Variables d'environnement bouton et une fenêtre appelée Variables d'environnement s'ouvre. Dans le Variables système panneau dans la moitié inférieure de cette fenêtre, faites défiler vers le bas jusqu'à Chemin et double-cliquez dessus. Cela ouvre une fenêtre appelée Modifier les variables d'environnementFaites glisser la largeur de cette fenêtre pour pouvoir voir le chemin complet des variables :

Voici les entrées importantes :

C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.6\bin
C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.6\libnvvp
C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.8\bin
C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.8\libnvvp
C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.29.30133\bin\Hostx64\x64
C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.42.34433\bin\Hostx64\x64
C:\Program Files\Git\cmd
C:\Program Files\CMake\bin

Dans la plupart des cas, les variables de chemin correctes devraient déjà être présentes.

Ajoutez tous les chemins manquants en cliquant NOUVEAU à gauche du Modifier la variable d'environnement fenêtre et coller dans le bon chemin :

NE copiez PAS et ne collez PAS simplement les chemins répertoriés ci-dessus ; vérifiez que chaque chemin équivalent existe dans votre propre installation Windows.

S'il existe des variations mineures de chemin (en particulier avec les installations de Visual Studio), utilisez les chemins répertoriés ci-dessus pour trouver les dossiers cibles corrects (c'est-à-dire, x64 in Hôte64 dans votre propre installation. Collez ensuite ceux chemins vers le Modifier la variable d'environnement fenêtre.

Après cela, redémarrez l'ordinateur.

Installation de Musubi

Mise à niveau PIP

L'utilisation de la dernière version du programme d'installation PIP peut faciliter certaines étapes de l'installation. Dans une invite de commande Windows avec des privilèges d'administrateur (voir Élévation, ci-dessous), tapez et entrez :

pip install --upgrade pip

Élévation

Certaines commandes peuvent nécessiter des privilèges élevés (c'est-à-dire être exécutées en tant qu'administrateur). Si vous recevez des messages d'erreur concernant les autorisations dans les étapes suivantes, fermez la fenêtre d'invite de commande et rouvrez-la en mode administrateur en saisissant CMD dans la zone de recherche Windows, en cliquant avec le bouton droit sur Invite de commandes et la sélection Exécuter en tant qu'administrateur:

Pour les étapes suivantes, nous allons utiliser Windows Powershell au lieu de l'invite de commande Windows. Vous pouvez le trouver en entrant Powershell dans la zone de recherche Windows et (si nécessaire) en cliquant dessus avec le bouton droit de la souris pour Exécuter en tant qu'administrateur:

Installer la torche

Dans Powershell, tapez et entrez :

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

Soyez patient pendant que les nombreux packages s'installent.

Une fois terminé, vous pouvez vérifier une installation PyTorch compatible GPU en tapant et en entrant :

python -c "import torch; print(torch.cuda.is_available())"

Cela devrait aboutir à :

C:\WINDOWS\system32>python -c "import torch;
print(torch.cuda.is_available())"
True

Installer Triton pour Windows

Ensuite, l'installation du Triton pour Windows composant. Dans Powershell avec privilèges élevés, saisissez (sur une seule ligne) :

pip install https://github.com/woct0rdho/triton-windows/releases/download/v3.1.0-windows.post8/triton-3.1.0-cp310-cp310-win_amd64.whl

(L'installateur triton-3.1.0-cp310-cp310-win_amd64.whl fonctionne à la fois pour les processeurs Intel et AMD à condition que l'architecture soit 64 bits et que l'environnement corresponde à la version Python)

Après l'exécution, cela devrait donner :

Successfully installed triton-3.1.0

Nous pouvons vérifier si Triton fonctionne en l'important dans Python. Entrez cette commande :

python -c "import triton; print('Triton is working')"

Cela devrait afficher :

Triton is working

Pour vérifier que Triton est compatible GPU, entrez :

python -c "import torch; print(torch.cuda.is_available())"

Cela devrait aboutir à True:

Créer l'environnement virtuel pour Musubi

À partir de maintenant, nous installerons tout autre logiciel dans un Environnement virtuel Python (ou venv). Cela signifie que tout ce que vous aurez à faire pour désinstaller tous les logiciels suivants est de faire glisser le dossier d'installation de venv vers la corbeille.

Créons ce dossier d'installation : créez un dossier appelé Musubi sur votre bureau. Les exemples suivants supposent que ce dossier existe : C:\Users\[Your Profile Name]\Desktop\Musubi\.

Dans Powershell, accédez à ce dossier en saisissant :

cd C:\Users\[Your Profile Name]\Desktop\Musubi

Nous voulons que l'environnement virtuel ait accès à ce que nous avons déjà installé (en particulier Triton), nous allons donc utiliser le --system-site-packages drapeau. Entrez ceci :

python -m venv --system-site-packages musubi

Attendez que l'environnement soit créé, puis activez-le en entrant :

.\musubi\Scripts\activate

À partir de ce point, vous pouvez dire que vous êtes dans l'environnement virtuel activé par le fait que (musubi) apparaît au début de toutes vos invites.

Cloner le référentiel

Accédez au fichier nouvellement créé musubi dossier (qui se trouve à l'intérieur du Musubi dossier sur votre bureau) :

cd musubi

Maintenant que nous sommes au bon endroit, entrez la commande suivante :

git clone https://github.com/kohya-ss/musubi-tuner.git

Attendez que le clonage soit terminé (cela ne prendra pas longtemps).

Configuration requise pour l'installation

Accédez au dossier d’installation :

cd musubi-tuner

Entrée:

pip install -r requirements.txt

Attendez que les nombreuses installations soient terminées (cela prendra plus de temps).

Automatisation de l'accès au Hunyuan Video Venv

Pour activer et accéder facilement au nouveau venv pour les sessions futures, collez ce qui suit dans le Bloc-notes et enregistrez-le sous le nom activer.bat, en le sauvegardant avec Tous les fichiers option (voir image ci-dessous).

@echo off

call C:\Users\[Your Profile Name]\Desktop\Musubi\musubi\Scripts\activate

cd C:\Users\[Your Profile Name]\Desktop\Musubi\musubi\musubi-tuner

cmd

(Remplacer [Your Profile Name]avec le vrai nom de votre profil utilisateur Windows)

L'emplacement où vous enregistrez ce fichier n'a pas d'importance.

A partir de maintenant, vous pouvez double-cliquer activer.bat et commencer à travailler immédiatement.

Utilisation de Musubi Tuner

Téléchargement des modèles

Le processus de formation Hunyuan Video LoRA nécessite le téléchargement d'au moins sept modèles afin de prendre en charge toutes les options d'optimisation possibles pour la pré-mise en cache et la formation d'une vidéo Hunyuan LoRA. Ensemble, ces modèles pèsent plus de 60 Go.

Les instructions actuelles pour les télécharger peuvent être trouvées à l'adresse suivante https://github.com/kohya-ss/musubi-tuner?tab=readme-ov-file#model-download

Cependant, voici les instructions de téléchargement au moment de la rédaction :

clip_l.safetensors
llava_llama3_fp16.safetensors que le béton ey
llava_llama3_fp8_scaled.safetensors
peut être téléchargé sur :
https://huggingface.co/Comfy-Org/HunyuanVideo_repackaged/tree/main/split_files/text_encoders

mp_rank_00_model_states.pt
mp_rank_00_model_states_fp8.pt que le béton ey
mp_rank_00_model_states_fp8_map.pt
peut être téléchargé sur :
https://huggingface.co/tencent/HunyuanVideo/tree/main/hunyuan-video-t2v-720p/transformers

pytorch_model.pt
peut être téléchargé sur :
https://huggingface.co/tencent/HunyuanVideo/tree/main/hunyuan-video-t2v-720p/vae

Bien que vous puissiez les placer dans n'importe quel répertoire de votre choix, pour des raisons de cohérence avec les scripts ultérieurs, plaçons-les dans :

C:\Users\[Your Profile Name]\Desktop\Musubi\musubi\musubi-tuner\models\

Ceci est cohérent avec l'organisation des répertoires antérieure. Toutes les commandes ou instructions ultérieures supposeront que c'est là que se trouvent les modèles ; n'oubliez pas de remplacer [Nom de votre profil] par le nom réel de votre dossier de profil Windows.

Préparation du jeu de données

Sans tenir compte de la controverse au sein de la communauté sur ce point, il est raisonnable de dire qu'il vous faudra entre 10 et 100 photos pour un jeu de données d'entraînement pour votre LoRA Hunyuan. De très bons résultats peuvent être obtenus même avec 15 images, à condition qu'elles soient bien équilibrées et de bonne qualité.

Un Hunyuan LoRA peut être formé à la fois sur des images ou sur des clips vidéo très courts et à faible résolution, ou même sur un mélange des deux – bien que l'utilisation de clips vidéo comme données de formation soit difficile, même pour une carte de 24 Go.

Cependant, les clips vidéo ne sont vraiment utiles que si votre personnage se déplace d'une manière si inhabituelle que le modèle de la fondation Hunyuan Video pourrait ne pas le savoir, ou être capable de deviner.

Les exemples incluraient Roger Rabbit, un xénomorphe, The Mask, Spider-Man ou d'autres personnalités qui possèdent SÉJOUR MÉMORABLE mouvement caractéristique.

Puisque Hunyuan Video connaît déjà les mouvements des hommes et des femmes ordinaires, des clips vidéo ne sont pas nécessaires pour obtenir un personnage de type humain convaincant. Nous utiliserons donc des images statiques.

Préparation de l'image

The Bucket List

La version TLDR :

Il est préférable d'utiliser des images qui ont toutes la même taille pour votre ensemble de données ou d'utiliser une répartition 50/50 entre deux tailles différentes, c'est-à-dire 10 images de 512x768px et 10 de 768x512px.

La formation pourrait bien se dérouler même si vous ne le faites pas – les LoRA vidéo Hunyuan peuvent être étonnamment indulgents.

La version longue

Comme avec les LoRA Kohya-ss pour les systèmes génératifs statiques tels que la diffusion stable, seaux est utilisé pour répartir la charge de travail sur des images de tailles différentes, permettant d'utiliser des images plus grandes sans provoquer d'erreurs de mémoire insuffisante au moment de la formation (c'est-à-dire que le bucketing « découpe » les images en morceaux que le GPU peut gérer, tout en préservant l'intégrité sémantique de l'image entière).

Pour chaque taille d'image incluse dans votre jeu de données d'entraînement (par exemple, 512 x 768 px), un compartiment, ou « sous-tâche », est créé pour cette taille. Ainsi, si vous avez la distribution d'images suivante, l'attention portée à chaque compartiment est déséquilibrée et certaines photos risquent d'être davantage prises en compte lors de l'entraînement :

2 images de 512x768px
7 images de 768x512px
1 image de 1000x600px
3 images de 400x800px

Nous pouvons voir que l'attention du bucket est divisée de manière inégale entre ces images :

Il faut donc soit s'en tenir à un seul format, soit essayer de maintenir une répartition relativement égale des différentes tailles.

Dans les deux cas, évitez les images très grandes, car cela risque de ralentir la formation, pour un bénéfice négligeable.

Pour plus de simplicité, j'ai utilisé 512x768px pour toutes les photos de mon ensemble de données.

Avis de non-responsabilité : Le modèle (personne) utilisé dans l'ensemble de données m'a donné la pleine permission d'utiliser ces images à cette fin et a approuvé toutes les sorties basées sur l'IA représentant son image présentée dans cet article.

Mon ensemble de données se compose de 40 images, au format PNG (bien que le format JPG soit également acceptable). Mes images ont été stockées dans C:\Users\Martin\Desktop\DATASETS_HUNYUAN\examplewoman

Vous devez créer un cachette dossier à l'intérieur du dossier d'images de formation :

Créons maintenant un fichier spécial qui configurera la formation.

Fichiers TOML

Les processus de formation et de pré-mise en cache de Hunyuan Video LoRAs obtiennent les chemins de fichiers à partir d'un fichier texte plat avec le .toml extension.

Pour mon test, le TOML est situé dans C:\Users\Martin\Desktop\DATASETS_HUNYUAN\training.toml

Le contenu de ma formation TOML ressemble à ceci :

[general]

resolution = [512, 768]

caption_extension = ".txt"

batch_size = 1

enable_bucket = true

bucket_no_upscale = false

[[datasets]]

image_directory = "C:\\Users\\Martin\\Desktop\\DATASETS_HUNYUAN\\examplewoman"

cache_directory = "C:\\Users\\Martin\\Desktop\\DATASETS_HUNYUAN\\examplewoman\\cache"

num_repeats = 1

(Les doubles barres obliques inverses pour les répertoires d'images et de cache ne sont pas toujours nécessaires, mais elles peuvent aider à éviter les erreurs dans les cas où il y a un espace dans le chemin. J'ai formé des modèles avec des fichiers .toml qui utilisaient des barres obliques simples vers l'avant et vers l'arrière)

Nous pouvons voir dans le resolution section dans laquelle deux résolutions seront prises en compte – 512 px et 768 px. Vous pouvez également laisser cette valeur à 512 et obtenir tout de même de bons résultats.

Légendes

Hunyuan Video est un texte+modèle de base de vision, nous avons donc besoin de légendes descriptives pour ces images, qui seront prises en compte lors de la formation. Le processus de formation échouera sans légendes.

Il existe un certain multitude des systèmes de sous-titrage open source que nous pourrions utiliser pour cette tâche, mais restons simples et utilisons le taggui système. Bien qu'il soit stocké sur GitHub et qu'il télécharge des modèles d'apprentissage profond très lourds lors de la première exécution, il se présente sous la forme d'un simple exécutable Windows qui charge des bibliothèques Python et une interface graphique simple.

Après avoir démarré Taggui, utilisez Fichier > Charger le répertoire pour accéder à votre ensemble de données d'image et éventuellement mettre un identifiant de jeton (dans ce cas, femme-exemple) qui sera ajouté à toutes les légendes :

(Assurez-vous d'éteindre Charger en 4 bits lorsque Taggui s'ouvre pour la première fois, il générera des erreurs lors du sous-titrage si cette option est laissée activée)

Sélectionnez une image dans la colonne d'aperçu de gauche et appuyez sur CTRL+A pour sélectionner toutes les images. Appuyez ensuite sur le bouton Démarrer le sous-titrage automatique à droite :

Vous verrez Taggui télécharger des modèles dans la petite CLI dans la colonne de droite, mais seulement si c'est la première fois que vous exécutez le sous-titreur. Sinon, vous verrez un aperçu des sous-titres.

Désormais, chaque photo a une légende .txt correspondante avec une description du contenu de son image :

Vous pouvez cliquer options avancées en taggui pour augmenter la longueur et le style des légendes, mais cela dépasse le cadre de cette présentation.

Quittez Taggui et passons à…

Pré-cache latent

Pour éviter une charge GPU excessive au moment de la formation, il est nécessaire de créer deux types de fichiers pré-mis en cache : l'un pour représenter l'image latente dérivée des images elles-mêmes, et l'autre pour évaluer un codage de texte relatif au contenu de la légende.

Pour simplifier les trois processus (2x cache + formation), vous pouvez utiliser des fichiers .BAT interactifs qui vous poseront des questions et entreprendront les processus lorsque vous aurez donné les informations nécessaires.

Pour la pré-mise en cache latente, copiez le texte suivant dans le Bloc-notes et enregistrez-le sous forme de fichier .BAT (c'est-à-dire, nommez-le quelque chose comme latent-precache.bat), comme précédemment, en s'assurant que le type de fichier dans le menu déroulant de la Enregistrer sous le dialogue est Tous les fichiers (voir image ci-dessous) :

@echo off

REM Activate the virtual environment

call C:\Users\[Your Profile Name]\Desktop\Musubi\musubi\Scripts\activate.bat

REM Get user input

set /p IMAGE_PATH=Enter the path to the image directory:

set /p CACHE_PATH=Enter the path to the cache directory:

set /p TOML_PATH=Enter the path to the TOML file:

echo You entered:

echo Image path: %IMAGE_PATH%

echo Cache path: %CACHE_PATH%

echo TOML file path: %TOML_PATH%

set /p CONFIRM=Do you want to proceed with latent pre-caching (y/n)?

if /i "%CONFIRM%"=="y" (

REM Run the latent pre-caching script

python C:\Users\[Your Profile Name]\Desktop\Musubi\musubi\musubi-tuner\cache_latents.py --dataset_config %TOML_PATH% --vae C:\Users\[Your Profile Name]\Desktop\Musubi\musubi\musubi-tuner\models\pytorch_model.pt --vae_chunk_size 32 --vae_tiling

) else (

echo Operation canceled.

)

REM Keep the window open

pause

(Assurez-vous de remplacer [Votre nom de profil] avec votre vrai nom de dossier de profil Windows)

Vous pouvez maintenant exécuter le fichier .BAT pour la mise en cache latente automatique :

Lorsque vous y êtes invité par les différentes questions du fichier BAT, collez ou saisissez le chemin d'accès à votre ensemble de données, aux dossiers de cache et au fichier TOML.

Pré-mise en cache du texte

Nous allons créer un deuxième fichier BAT, cette fois pour la pré-mise en cache du texte.

@echo off

REM Activate the virtual environment

call C:\Users\[Your Profile Name]\Desktop\Musubi\musubi\Scripts\activate.bat

REM Get user input

set /p IMAGE_PATH=Enter the path to the image directory:

set /p CACHE_PATH=Enter the path to the cache directory:

set /p TOML_PATH=Enter the path to the TOML file:

echo You entered:

echo Image path: %IMAGE_PATH%

echo Cache path: %CACHE_PATH%

echo TOML file path: %TOML_PATH%

set /p CONFIRM=Do you want to proceed with text encoder output pre-caching (y/n)?

if /i "%CONFIRM%"=="y" (

REM Use the python executable from the virtual environment

python C:\Users\[Your Profile Name]\Desktop\Musubi\musubi\musubi-tuner\cache_text_encoder_outputs.py --dataset_config %TOML_PATH% --text_encoder1 C:\Users\[Your Profile Name]\Desktop\Musubi\musubi\musubi-tuner\models\llava_llama3_fp16.safetensors --text_encoder2 C:\Users\[Your Profile Name]\Desktop\Musubi\musubi\musubi-tuner\models\clip_l.safetensors --batch_size 16

) else (

echo Operation canceled.

)

REM Keep the window open

pause

Remplacez le nom de votre profil Windows et enregistrez-le sous cache-texte.bat (ou tout autre nom de votre choix), à n’importe quel endroit pratique, conformément à la procédure du fichier BAT précédent.

Exécutez ce nouveau fichier BAT, suivez les instructions et les fichiers texte codés nécessaires apparaîtront dans le cachette dossier:

Entraînement du Hunyuan Vidéo Lora

La formation du LoRA réel prendra beaucoup plus de temps que ces deux processus préparatoires.

Bien qu'il existe également de nombreuses variables dont nous pourrions nous soucier (telles que la taille du lot, les répétitions, les époques et l'utilisation de modèles complets ou quantifiés, entre autres), nous garderons ces considérations pour un autre jour et un examen plus approfondi des subtilités de la création LoRA.

Pour l'instant, minimisons un peu les choix et formons un LoRA sur des paramètres « médians ».

Nous allons créer un troisième fichier BAT, cette fois pour lancer l'entraînement. Collez-le dans le Bloc-notes et enregistrez-le comme fichier BAT, comme précédemment, sous le nom formation.bat (ou n'importe quel nom que vous voulez) :

@echo off

REM Activate the virtual environment

call C:\Users\[Your Profile Name]\Desktop\Musubi\musubi\Scripts\activate.bat

REM Get user input

set /p DATASET_CONFIG=Enter the path to the dataset configuration file:

set /p EPOCHS=Enter the number of epochs to train:

set /p OUTPUT_NAME=Enter the output model name (e.g., example0001):

set /p LEARNING_RATE=Choose learning rate (1 for 1e-3, 2 for 5e-3, default 1e-3):

if "%LEARNING_RATE%"=="1" set LR=1e-3

if "%LEARNING_RATE%"=="2" set LR=5e-3

if "%LEARNING_RATE%"=="" set LR=1e-3

set /p SAVE_STEPS=How often (in steps) to save preview images:

set /p SAMPLE_PROMPTS=What is the location of the text-prompt file for training previews?

echo You entered:

echo Dataset configuration file: %DATASET_CONFIG%

echo Number of epochs: %EPOCHS%

echo Output name: %OUTPUT_NAME%

echo Learning rate: %LR%

echo Save preview images every %SAVE_STEPS% steps.

echo Text-prompt file: %SAMPLE_PROMPTS%

REM Prepare the command

set CMD=accelerate launch --num_cpu_threads_per_process 1 --mixed_precision bf16 ^

C:\Users\[Your Profile Name]\Desktop\Musubi\musubi\musubi-tuner\hv_train_network.py ^

--dit C:\Users\[Your Profile Name]\Desktop\Musubi\musubi\musubi-tuner\models\mp_rank_00_model_states.pt ^

--dataset_config %DATASET_CONFIG% ^

--sdpa ^

--mixed_precision bf16 ^

--fp8_base ^

--optimizer_type adamw8bit ^

--learning_rate %LR% ^

--gradient_checkpointing ^

--max_data_loader_n_workers 2 ^

--persistent_data_loader_workers ^

--network_module=networks.lora ^

--network_dim=32 ^

--timestep_sampling sigmoid ^

--discrete_flow_shift 1.0 ^

--max_train_epochs %EPOCHS% ^

--save_every_n_epochs=1 ^

--seed 42 ^

--output_dir "C:\Users\[Your Profile Name]\Desktop\Musubi\Output Models" ^

--output_name %OUTPUT_NAME% ^

--vae C:/Users/[Your Profile Name]/Desktop/Musubi/musubi/musubi-tuner/models/pytorch_model.pt ^

--vae_chunk_size 32 ^

--vae_spatial_tile_sample_min_size 128 ^

--text_encoder1 C:/Users/[Your Profile Name]/Desktop/Musubi/musubi/musubi-tuner/models/llava_llama3_fp16.safetensors ^

--text_encoder2 C:/Users/[Your Profile Name]/Desktop/Musubi/musubi/musubi-tuner/models/clip_l.safetensors ^

--sample_prompts %SAMPLE_PROMPTS% ^

--sample_every_n_steps %SAVE_STEPS% ^

--sample_at_first

echo The following command will be executed:

echo %CMD%

set /p CONFIRM=Do you want to proceed with training (y/n)?

if /i "%CONFIRM%"=="y" (

%CMD%

) else (

echo Operation canceled.

)

REM Keep the window open

cmd /k

Comme d'habitude, assurez-vous de remplacer toutes les instances of [Votre nom de profil] avec votre nom de profil Windows correct.

Assurez-vous que le répertoire C:\Users\[Your Profile Name]\Desktop\Musubi\Output Models\ existe, et créez-le à cet endroit si ce n'est pas le cas.

Aperçus de formation

Il existe une fonctionnalité d'aperçu de formation très basique récemment activée pour Musubi Trainer, qui vous permet de forcer le modèle de formation à s'arrêter et de générer des images en fonction des invites que vous avez enregistrées. Celles-ci sont enregistrées dans un dossier créé automatiquement appelé Échantillon, dans le même répertoire que celui dans lequel les modèles formés sont enregistrés.

Pour activer cette fonction, vous devrez enregistrer au moins une invite dans un fichier texte. Le BAT de formation que nous avons créé vous demandera de saisir l'emplacement de ce fichier. Vous pouvez donc nommer le fichier d'invite comme vous le souhaitez et l'enregistrer où vous le souhaitez.

Voici quelques exemples d'invite pour un fichier qui générera trois images différentes lorsque demandé par la routine d'entraînement :

Comme vous pouvez le voir dans l'exemple ci-dessus, vous pouvez placer des indicateurs à la fin de l'invite qui affecteront les images :

–w est largeur (la valeur par défaut est 256 px si elle n'est pas définie, selon les docs)
-son la taille (la valeur par défaut est 256 px si elle n’est pas définie)
–f est le nombre de cadres. Si la valeur est définie sur 1, une image est produite ; si elle est définie sur plus d'une, une vidéo.
–d est la graine. Si elle n'est pas définie, elle est aléatoire ; mais vous devez la définir pour voir une invite évoluer.
–s est le nombre d’étapes de génération, la valeur par défaut étant 20.

Voir la documentation officielle pour des drapeaux supplémentaires.

Bien que les aperçus de formation puissent rapidement révéler certains problèmes qui pourraient vous amener à annuler la formation et à reconsidérer les données ou la configuration, économisant ainsi du temps, n'oubliez pas que chaque invite supplémentaire ralentit un peu plus la formation.

De plus, plus la largeur et la hauteur de l'image d'aperçu de l'entraînement sont grandes (comme défini dans les indicateurs répertoriés ci-dessus), plus cela ralentira l'entraînement.

Lancez votre fichier BAT de formation.

Question #1 'Entrez le chemin d'accès à la configuration du jeu de données. Collez ou saisissez le chemin d'accès correct à votre fichier TOML.

Question #2 Indiquez le nombre d'époques à entraîner. Cette variable est une variable d'essai-erreur, car elle est affectée par la quantité et la qualité des images, ainsi que par les légendes et d'autres facteurs. En général, il est préférable de la définir trop haut que trop bas, car vous pouvez toujours arrêter l'entraînement avec Ctrl+C dans la fenêtre d'entraînement si vous estimez que le modèle est suffisamment avancé. Définissez-la sur 100 dans un premier temps et observez l'évolution.

Question #3 « Entrez le nom du modèle de sortie ». Nommez votre modèle ! Il est préférable de choisir un nom court et simple.

Question #4 « Choisir le taux d'apprentissage », dont la valeur par défaut est 1e-3 (option 1). C'est un bon point de départ, en attendant plus d'expérience.

Question #5 est « À quelle fréquence (en étapes) enregistrer les images d'aperçu ». Si vous définissez cette valeur trop bas, vous verrez peu de progrès entre les enregistrements d'images d'aperçu, ce qui ralentira l'entraînement.

Question #6 « Quel est l'emplacement du fichier d'invite de texte pour les aperçus d'entraînement ? » Collez ou saisissez le chemin d'accès à votre fichier d'invite.

Le BAT vous montre ensuite la commande qu'il va envoyer au modèle Hunyuan et vous demande si vous souhaitez continuer, o/n.

Allez-y et commencez la formation :

Pendant ce temps, si vous vérifiez la section GPU de l'onglet Performances du Gestionnaire des tâches de Windows, vous verrez que le processus prend environ 16 Go de VRAM.

Ce chiffre n’est peut-être pas arbitraire, car il s’agit de la quantité de VRAM disponible sur un certain nombre de cartes graphiques NVIDIA, et le code en amont a peut-être été optimisé pour adapter les tâches à 16 Go au profit de ceux qui possèdent de telles cartes.

Cela dit, il est très facile d’augmenter cette utilisation, en envoyant des drapeaux plus exorbitants à la commande de formation.

Pendant la formation, vous verrez dans le coin inférieur droit de la fenêtre CMD un chiffre indiquant le temps écoulé depuis le début de la formation et une estimation du temps total de formation (qui varie considérablement en fonction des indicateurs définis, du nombre d'images de formation, du nombre d'images d'aperçu de formation et de plusieurs autres facteurs).

Le temps de formation typique est d'environ 3 à 4 heures avec des paramètres médians, en fonction du matériel disponible, du nombre d'images, des paramètres d'indicateur et d'autres facteurs.

Utilisation de vos modèles LoRA formés dans Hunyuan Video

Choisir les points de contrôle

Une fois la formation terminée, vous disposerez d’un point de contrôle modèle pour chaque époque de formation.

Cette fréquence d'enregistrement peut être modifiée par l'utilisateur pour enregistrer plus ou moins fréquemment, selon ses souhaits, en modifiant le --save_every_n_epochs [N] nombre dans le fichier BAT de formation. Si vous avez ajouté un nombre faible de sauvegardes par étape lors de la configuration de la formation avec le BAT, il y aura un nombre élevé de fichiers de points de contrôle enregistrés.

Quel point de contrôle choisir ?

Comme mentionné précédemment, les premiers modèles formés seront les plus flexibles, tandis que les points de contrôle ultérieurs peuvent offrir le plus de détails. La seule façon de tester ces facteurs est d'exécuter certains des LoRA et de générer quelques vidéos. De cette façon, vous pouvez savoir quels points de contrôle sont les plus productifs et représentent le meilleur équilibre entre flexibilité et fidélité.

Interface utilisateur confortable

L'environnement le plus populaire (mais pas le seul) pour l'utilisation des LoRA Hunyuan Video, à l'heure actuelle, est Interface utilisateur confortable, un éditeur basé sur des nœuds avec une interface Gradio élaborée qui s'exécute dans votre navigateur Web.

Source : https://github.com/comfyanonymous/ComfyUI

Les instructions d'installation sont simples et disponible sur le dépôt officiel GitHub (des modèles supplémentaires devront être téléchargés).

Conversion de modèles pour ComfyUI

Vos modèles entraînés sont enregistrés dans un format (diffusers) incompatible avec la plupart des implémentations de ComfyUI. Musubi permet de convertir un modèle dans un format compatible avec ComfyUI. Configurons un fichier BAT pour implémenter cette fonctionnalité.

Avant d'exécuter ce BAT, créez le C:\Users\[Your Profile Name]\Desktop\Musubi\CONVERTED\ dossier que le script attend.

@echo off

REM Activate the virtual environment

call C:\Users\[Your Profile Name]\Desktop\Musubi\musubi\Scripts\activate.bat

:START

REM Get user input

set /p INPUT_PATH=Enter the path to the input Musubi safetensors file (or type "exit" to quit):

REM Exit if the user types "exit"

if /i "%INPUT_PATH%"=="exit" goto END

REM Extract the file name from the input path and append 'converted' to it

for %%F in ("%INPUT_PATH%") do set FILENAME=%%~nF

set OUTPUT_PATH=C:\Users\[Your Profile Name]\Desktop\Musubi\Output Models\CONVERTED\%FILENAME%_converted.safetensors

set TARGET=other

echo You entered:

echo Input file: %INPUT_PATH%

echo Output file: %OUTPUT_PATH%

echo Target format: %TARGET%

set /p CONFIRM=Do you want to proceed with the conversion (y/n)?

if /i "%CONFIRM%"=="y" (

REM Run the conversion script with correctly quoted paths

python C:\Users\[Your Profile Name]\Desktop\Musubi\musubi\musubi-tuner\convert_lora.py --input "%INPUT_PATH%" --output "%OUTPUT_PATH%" --target %TARGET%

echo Conversion complete.

) else (

echo Operation canceled.

)

REM Return to start for another file

goto START

:END

REM Keep the window open

echo Exiting the script.

pause

Comme pour les fichiers BAT précédents, enregistrez le script sous « Tous les fichiers » à partir du Bloc-notes, en le nommant convertir.bat (ou ce que vous voulez).

Une fois enregistré, double-cliquez sur le nouveau fichier BAT, qui vous demandera l'emplacement d'un fichier à convertir.

Collez ou saisissez le chemin d'accès au fichier formé que vous souhaitez convertir, cliquez sur y, et appuyez sur Entrée.

Après avoir enregistré le LoRA converti dans le CONVERTI dossier, le script vous demandera si vous souhaitez convertir un autre fichier. Si vous souhaitez tester plusieurs points de contrôle dans ComfyUI, convertissez une sélection de modèles.

Lorsque vous avez converti suffisamment de points de contrôle, fermez la fenêtre de commande BAT.

Vous pouvez maintenant copier vos modèles convertis dans le dossier models\loras de votre installation ComfyUI.

En général, l'emplacement correct ressemble à ceci :

C:\Users\[Your Profile Name]\Desktop\ComfyUI\models\loras\

Création de LoRA vidéo Hunyuan dans ComfyUI

Bien que les workflows de ComfyUI basés sur les nœuds puissent paraître complexes au premier abord, les paramètres d'autres utilisateurs plus expérimentés peuvent être chargés en faisant glisser une image (créée avec l'interface ComfyUI de l'autre utilisateur) directement dans la fenêtre ComfyUI. Les workflows peuvent également être exportés sous forme de fichiers JSON, importés manuellement ou glissés dans une fenêtre ComfyUI.

Certains workflows importés auront des dépendances qui peuvent ne pas exister dans votre installation. Par conséquent, installez Gestionnaire ComfyUI, qui peut récupérer automatiquement les modules manquants.

Source : https://github.com/ltdrdata/ComfyUI-Manager

Pour charger l'un des workflows utilisés pour générer des vidéos à partir des modèles de ce didacticiel, téléchargez ce fichier JSON et faites-le glisser dans votre fenêtre ComfyUI (bien qu'il existe de bien meilleurs exemples de flux de travail disponibles dans les différentes communautés Reddit et Discord qui ont adopté Hunyuan Video, et le mien est adapté de l'une d'entre elles).

Ce n’est pas le lieu pour un tutoriel détaillé sur l’utilisation de ComfyUI, mais il convient de mentionner quelques-uns des paramètres cruciaux qui affecteront votre sortie si vous téléchargez et utilisez la mise en page JSON à laquelle j’ai fait un lien ci-dessus.

1) Largeur et hauteur

Plus votre image est grande, plus la génération prendra du temps et plus le risque d'erreur de manque de mémoire (OOM) sera élevé.

2) longueur

Il s'agit de la valeur numérique du nombre d'images. Le nombre de secondes que cela représente dépend de la fréquence d'images (définie sur 30 ips dans cette disposition). Vous pouvez convertir les secondes en images en fonction des ips chez Omnicalculator.

3) Taille du lot

Plus la taille du lot est élevée, plus le résultat peut être rapide, mais plus la charge de la VRAM est importante. Si vous définissez cette valeur trop haut, vous risquez d'obtenir un OOM.

4) Contrôle après génération

Ceci contrôle la graine aléatoire. Les options pour ce sous-nœud sont fixé, incrément, décrémenter que le béton ey randomiser. Si vous le laissez à fixé et ne modifiez pas l'invite de texte, vous obtiendrez la même image à chaque fois. Si vous modifiez l'invite de texte, l'image changera dans une certaine mesure. incrément que le béton ey décrémenter les paramètres vous permettent d'explorer les valeurs de semences à proximité, tandis que randomiser vous donne une interprétation totalement nouvelle de l'invite.

5) Nom de Lora

Vous devrez sélectionner votre propre modèle installé ici, avant de tenter de générer.

6) Jeton

Si vous avez entraîné votre modèle à déclencher le concept avec un jeton (par exemple « personne-exemple »), placez ce mot déclencheur dans votre invite.

7) Étapes

Cela représente le nombre d'étapes que le système appliquera au processus de diffusion. Des étapes plus élevées peuvent permettre d'obtenir de meilleurs détails, mais il existe un plafond à l'efficacité de cette approche, et ce seuil peut être difficile à trouver. La plage courante d'étapes se situe autour de 20 à 30.

8) Taille des tuiles

Ce paramètre définit la quantité d'informations traitées simultanément lors de la génération. Par défaut, cette valeur est fixée à 256. Augmenter cette valeur peut accélérer la génération, mais une valeur trop élevée peut engendrer une expérience OOM particulièrement frustrante, car elle intervient à la toute fin d'un long processus.

9) Chevauchement temporel

La génération de vidéos Hunyuan peut entraîner des effets fantômes, ou des mouvements peu convaincants, si ce paramètre est réglé trop bas. En général, il est conseillé de régler ce paramètre sur une valeur supérieure au nombre d'images pour obtenir de meilleurs mouvements.

Conclusion

Bien qu'une exploration plus approfondie de l'utilisation de ComfyUI dépasse le cadre de cet article, l'expérience de la communauté sur Reddit et Discords peut faciliter la courbe d'apprentissage, et il existe plusieurs guides en ligne qui introduisent les bases.

Première publication le jeudi 23 janvier 2025