Comment former et utiliser des modèles LoRA Hunyuan Video

Cet article vous montrera comment installer et utiliser des logiciels basés sur Windows qui peuvent former des modèles LoRA Hunyuan Video, permettant à l’utilisateur de générer des personnalités personnalisées dans le modèle de base de vidéo Hunyuan.

[vidéo largeur = “1200” hauteur = “900” mp4 = “https://www.unite.ai/wp-content/uploads/2025/01/loras-hunyuan-AE2.mp4” [/vidéo]

Cliquez pour jouer. Exemples de l’explosion récente de célébrités Hunyuan LoRA de la communauté civit.ai.

Actuellement, les deux moyens les plus populaires de générer des modèles LoRA Hunyuan localement sont:

1) Le framework diffusion-pipe-ui basé sur Docker, qui repose sur Windows Subsystem pour Linux (WSL) pour gérer certaines des processus.

2) Musubi Tuner, un nouvel ajout à l’architecture de formation de diffusion populaire Kohya ss. Musubi Tuner n’a pas besoin de Docker et ne dépend pas de WSL ou de proxys Linux – mais il peut être difficile à exécuter sur Windows.

Par conséquent, ce tutoriel se concentrera sur Musubi Tuner, et sur la fourniture d’une solution complètement locale pour la formation et la génération de LoRA Hunyuan, sans l’utilisation de sites Web basés sur API ou de processus de location de GPU commerciaux tels que Runpod.

[vidéo largeur = “1200” hauteur = “674” mp4 = “https://www.unite.ai/wp-content/uploads/2025/01/example-woman-hunyuan-loras.mp4” boucle = “true” [/vidéo]

Cliquez pour jouer. Échantillons de formation de LoRA sur Musubi Tuner pour cet article. Toutes les autorisations ont été accordées par la personne représentée, aux fins d’illustrer cet article.

EXIGENCES

L’installation nécessitera au minimum un PC Windows 10 avec une carte NVIDIA de série 30+/40+ ayant au moins 12 Go de VRAM (bien que 16 Go soit recommandé). L’installation utilisée pour cet article a été testée sur une machine avec 64 Go de mémoire système et une carte graphique NVIDIA 3090 avec 24 Go de VRAM. Il a été testé sur un système de test dédié à l’aide d’une installation fraîche de Windows 10 Professional, sur une partition avec plus de 600 Go d’espace disque disponible.

AVERTISSEMENT

L’installation de Musubi Tuner et de ses prérequis implique également l’installation de logiciels et de packages axés sur les développeurs directement sur l’installation principale de Windows d’un PC. En tenant compte de l’installation de ComfyUI pour les dernières étapes, 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 fraîchement installés Windows 10, ni moi ni unite.ai ne sommes responsables de tout dommage causé aux systèmes en suivant ces instructions. Je vous conseille de sauvegarder toutes les données importantes avant d’essayer ce type de procédure d’installation.

CONSIDÉRATIONS

Est-ce que cette méthode est toujours valable?

Le scène de l’intelligence artificielle générative évolue très rapidement, et nous pouvons nous attendre à de meilleures et plus fluides méthodes de formation de frameworks LoRA Hunyuan Video cette année.

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

Il est clair qu’une interface utilisateur conviviale est préférable aux fichiers BAT que j’utilise dans cette fonctionnalité – une fois que musubi-tuner-gui fonctionne. Alors que j’écris, il n’y a pas encore cinq jours qu’il est en ligne, et je ne peux trouver aucun compte de quelqu’un ayant réussi à l’utiliser.

Selon les publications dans le référentiel, la nouvelle interface utilisateur est destinée à être intégrée directement dans le projet Musubi Tuner dès que possible, ce qui mettra fin à son existence en tant que référentiel GitHub autonome.

Sur la base des instructions d’installation actuelles, la nouvelle interface utilisateur 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’il s’exécute, il constatera qu’il n’a pas de moteur!

Une fois que l’interface utilisateur est intégrée à Musubi Tuner, des problèmes de ce type seront certainement résolus. Bien que l’auteur reconnaisse que le nouveau projet est ‘vraiment brut’, il est optimiste quant à son développement et à son intégration directe dans Musubi Tuner.

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

Mais si vous ne pouvez pas attendre et que vous êtes prêt à vous salir les mains un peu, vous pouvez faire fonctionner la formation de LoRA Hunyuan localement dès maintenant.

Commençons.

Pourquoi installer quelque chose sur du métal nu?

(Sauter ce paragraphe si vous n’êtes pas un utilisateur avancé)
Les utilisateurs avancés se demanderont pourquoi j’ai choisi d’installer tant de logiciels sur l’installation Windows 10 métal nu au lieu de dans un environnement virtuel. La raison est que le port Windows essentiel du package Linux Triton est beaucoup plus difficile à faire fonctionner dans un environnement virtuel. Toutes les autres installations de métal nu dans le tutoriel ne pouvaient pas être installées dans un environnement virtuel, car elles doivent interfacer directement avec le matériel local.

INSTALLATION DES PAQUETS ET PROGRAMMES PRÉREQUIS

Pour les programmes et les packages qui doivent être installés initialement, l’ordre d’installation est important. Commençons.

1: Télécharger Microsoft Redistributable

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

Ceci est une installation simple et rapide.

2: Installer Visual Studio 2022

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

Démarrez l’installateur téléchargé:

Nous n’avons pas besoin de tous les packages disponibles, ce qui serait une installation lourde et longue. À la page Workloads initiale qui s’ouvre, cochez Desktop Development with C++ (voir image ci-dessous).

Maintenant, cliquez sur l’onglet Individual Components en haut à gauche de l’interface et utilisez la zone de recherche pour trouver ‘Windows SDK’.

Par défaut, seul le Windows 11 SDK est coché. Si vous êtes sur Windows 10 (cette procédure d’installation n’a pas été testée par moi sur Windows 11), cochez la version la plus récente de Windows 10, indiquée dans l’image ci-dessus.

Recherchez ‘C++ CMake’ et vérifiez que C++ CMake tools for Windows est coché.

Cette installation prendra au moins 13 Go d’espace.

Une fois que Visual Studio est 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 finalement visible, fermez le programme.

3: Installer Visual Studio 2019

Certains des packages suivants pour Musubi s’attendent à une version plus ancienne de Microsoft Visual Studio, tandis que d’autres ont besoin d’une version plus récente.

Par conséquent, téléchargez également la version Community gratuite de Visual Studio 19 soit à partir de Microsoft (https://visualstudio.microsoft.com/vs/older-downloads/ – compte requis) soit à partir de Techspot (https://www.techspot.com/downloads/7241-visual-studio-2019.html).

Installez-le avec les mêmes options que pour Visual Studio 2022 (voir procédure ci-dessus, à l’exception que Windows SDK est déjà coché dans l’installateur de Visual Studio 2019).

Vous verrez que l’installateur de Visual Studio 2019 est déjà conscient de la version plus récente lorsqu’il s’installe:

Lorsque l’installation est terminée et que vous avez ouvert et fermé l’application Visual Studio 2019 installée, ouvrez une invite de commandes Windows (tapez CMD dans la zone de recherche) et tapez et entrez:

where cl

Le résultat devrait être les emplacements connus des deux éditions de Visual Studio installées.

Si vous obtenez à la place INFO: Could not find files for the given pattern(s), consultez la section Check Path 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 à la section Check Paths ci-dessous, puis essayez la commande where cl à nouveau.

4: Installer CUDA 11 + 12 Toolkits

Les différents packages installés dans Musubi nécessitent différentes versions 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 en premier est que les installateurs de NVIDIA CUDA recherchent et s’intègrent avec les installations de Visual Studio existantes.

Téléchargez un package d’installation CUDA de 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échargez ‘exe (local)’ )

Téléchargez un package d’installation de toolkit CUDA de série 12 à partir de:

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

Le processus d’installation est identique pour les deux installateurs. Ignorez tout avertissement concernant l’existence ou l’absence de chemins d’installation dans les variables d’environnement Windows – nous allons nous en occuper manuellement plus tard.

Installer NVIDIA CUDA Toolkit V11+

Démarrez l’installateur de la version 11+ de CUDA Toolkit.

À Installation Options, choisissez Custom (Advanced) et procédez.

Décochez l’option NVIDIA GeForce Experience et cliquez sur Next.

Laissez Select Installation Location aux valeurs par défaut (ceci est important):

Cliquez sur Next et laissez l’installation se terminer.

Ignorez tout avertissement ou note que l’installateur donne concernant Nsight Visual Studio integration, qui n’est pas nécessaire pour notre cas d’utilisation.

Installer NVIDIA CUDA Toolkit V12+

Répétez l’ensemble du processus pour l’installateur de toolkit CUDA de série 12+ que vous avez téléchargé:

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

Lorsque l’installation de la version 12+ de CUDA est terminée, ouvrez une invite de commandes Windows et tapez et entrez:

nvcc --version

Ceci devrait confirmer des informations sur la version du pilote installé:

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

nvidia-smi

5: Installer GIT

GIT gérera l’installation du référentiel Musubi sur votre machine locale. Téléchargez l’installateur de GIT à:

https://git-scm.com/downloads/win (’64-bit Git for Windows Setup’)

Exécutez l’installateur:

Utilisez les paramètres par défaut pour Select Components:

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

Laissez GIT décider des noms de branche:

Utilisez les paramètres recommandés pour le Path Environment:

Utilisez les paramètres recommandés pour SSH:

Utilisez les paramètres recommandés pour HTTPS Transport backend:

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

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

Utilisez les paramètres par défaut (Fast-forward or merge) pour Git Pull:

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

Dans Configuring extra options, laissez Enable file system caching coché et Enable symbolic links décoché (à moins que vous ne soyez un utilisateur avancé qui utilise des liens durs pour un référentiel de modèles centralisé).

Concluez l’installation et testez que GIT est installé correctement en ouvrant une fenêtre CMD et en tapant et en entrant:

git --version

Connexion GitHub

Plus tard, lorsque vous essayerez de cloner des référentiels GitHub, vous pourriez être invité à entrer vos informations d’identification GitHub. Pour anticiper 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 plus récent est requis 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 de code source.

Téléchargez-le à:

https://cmake.org/download/ (‘Windows x64 Installer’)

Lancez l’installateur:

Assurez-vous que Add Cmake to the PATH environment variable est coché.

Appuyez sur Next.

Tapez et entrez cette commande dans une invite de commandes 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 central dans ce projet. Téléchargez la version 3.10 (le meilleur compromis entre les différentes exigences des packages Musubi) à:

https://www.python.org/downloads/release/python-3100/ (‘Windows installer (64-bit)’)

Exécutez l’installateur de téléchargement et laissez les paramètres par défaut:

À la fin du processus d’installation, cliquez sur Disable path length limit (requiert une confirmation d’administrateur UAC):

Dans une invite de commandes Windows, tapez et entrez:

python --version

Ceci devrait donner le résultat Python 3.10.0

VÉRIFIER LES CHEMINS

Le clonage et l’installation des frameworks Musubi, ainsi que leur fonctionnement normal après installation, nécessitent que leurs composants connaissent le chemin d’accès à plusieurs composants externes importants dans Windows, en particulier CUDA.

Il nous faut donc ouvrir le chemin d’environnement et vérifier que tous les éléments requis sont présents.

Un moyen rapide d’accéder aux contrôles de l’environnement Windows est de taper Éditer les variables d’environnement du système dans la barre de recherche Windows.

Ceci ouvrira le panneau de configuration System Properties. Dans le coin inférieur droit de System Properties, cliquez sur le bouton Environment Variables, et une fenêtre appelée Environment Variables s’ouvre. Dans le panneau System Variables dans la moitié inférieure de cette fenêtre, faites défiler vers le bas jusqu’à Path et double-cliquez dessus. Cela ouvre une fenêtre appelée Edit environment variables. Faites glisser la largeur de cette fenêtre pour que vous puissiez voir le chemin complet des variables:

Ici, les entrées importantes sont:

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 tout chemin manquant en cliquant sur New à gauche de la fenêtre Edit environment variable et en collant le chemin correct:

Ne copiez-collez pas simplement à partir des chemins répertoriés ci-dessus; vérifiez que chaque chemin équivalent existe dans votre propre installation Windows.

Si vous y avez des variations de chemin mineures (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 dans Host64 dans votre propre installation. Ensuite, collez ces chemins dans la fenêtre Edit environment variable.

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

INSTALLATION DE MUSUBI

Mettre à jour PIP

L’utilisation de la dernière version de l’installateur PIP peut faciliter certaines des étapes d’installation. Dans une invite de commandes Windows avec des privilèges d’administrateur (voir Elevation ci-dessous), tapez et entrez:

pip install --upgrade pip

Elevation

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 de commande et rouvrez-la en mode administrateur en tapant CMD dans la zone de recherche Windows, en faisant un clic droit sur Command Prompt et en sélectionnant Exécuter en tant qu’administrateur:

Pour les prochaines étapes, nous allons utiliser Windows Powershell au lieu de l’invite de commandes Windows. Vous pouvez le trouver en tapant Powershell dans la zone de recherche Windows et, si nécessaire, en faisant un clic droit dessus pour Exécuter en tant qu’administrateur:

Installer Torch

Dans Powershell, tapez et entrez:

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

Soyez patient pendant l’installation de nombreux packages.

Lorsque cela est terminé, vous pouvez vérifier une installation PyTorch compatible GPU en tapant et en entrant:

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

Ceci devrait donner le résultat:

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

Installer Triton pour Windows

Ensuite, l’installation du composant Triton for Windows. Dans Powershell élevé, entrez (sur une 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, tant que l’architecture est 64 bits et que l’environnement correspond à la version de Python)

Après avoir exécuté, cela devrait donner le résultat:

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')"

Ceci devrait afficher:

Triton is working

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

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

Ceci devrait donner le résultat True:

Créer l’environnement virtuel pour Musubi

À partir de maintenant, nous allons installer tout autre logiciel dans un environnement virtuel Python (ou venv). Cela signifie que tout ce que vous aurez à faire pour désinstaller tout le logiciel suivant est de glisser le dossier d’installation du venv vers la corbeille.

Créons le 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, naviguez jusqu’à ce dossier en entrant:

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

Nous voulons que l’environnement virtuel ait accès à ce que nous avons installé jusqu’à présent (en particulier Triton), nous allons donc utiliser le drapeau --system-site-packages. 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 maintenant, vous pouvez dire que vous êtes dans l’environnement virtuel activé en fonction du fait que (musubi) apparaît au début de toutes vos invites.

Cloner le référentiel

Naviguez jusqu’au dossier musubi qui se trouve à l’intérieur du dossier Musubi 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é (ce ne prendra pas longtemps).

Installer les exigences

Naviguez jusqu’au dossier d’installation:

cd musubi-tuner

Entrez:

pip install -r requirements.txt

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

Automatiser l’accès à l’environnement virtuel Hunyuan Video

Pour accéder facilement et activer l’environnement virtuel pour les futures sessions, collez le texte suivant dans Notepad et enregistrez-le avec le nom activate.bat, en l’enregistrant avec l’option Tous les fichiers (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

(Remplacez [Your Profile Name] par le nom réel de votre profil d’utilisateur Windows)

Cela n’a pas d’importance dans quelle localisation vous enregistrez ce fichier.

À partir de maintenant, vous pouvez double-cliquer sur activate.bat et commencer à travailler immédiatement.

UTILISER MUSUBI TUNER

Télécharger les modèles

Le processus de formation de LoRA Hunyuan Video nécessite le téléchargement d’au moins sept modèles pour prendre en charge toutes les options de pré-caching et de formation d’un LoRA Hunyuan Video, qui pèsent ensemble plus de 60 Go.

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

Cependant, ce sont les instructions de téléchargement au moment de la rédaction de cet article:

clip_l.safetensors
llava_llama3_fp16.safetensors et
llava_llama3_fp8_scaled.safetensors
peuvent être téléchargés à:
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 et
mp_rank_00_model_states_fp8_map.pt
peuvent être téléchargés à:
https://huggingface.co/tencent/HunyuanVideo/tree/main/hunyuan-video-t2v-720p/transformers

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

Bien que vous puissiez les placer dans n’importe quel répertoire que vous choisissez, pour la 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’agencement de répertoire jusqu’à ce point. N’oubliez pas de remplacer [Your Profile Name] par le nom réel de votre dossier de profil Windows.

PRÉPARATION DU JEU DE DONNÉES

En ignorant la controverse communautaire sur ce point, il est raisonnable de dire que vous aurez besoin de quelque part entre 10 et 100 photos pour un jeu de données de formation pour votre LoRA Hunyuan. De très bons résultats peuvent être obtenus même avec 15 images, tant que les images sont équilibrées et de bonne qualité.

Un LoRA Hunyuan peut être formé à la fois sur des images ou de très courtes et basses résolutions de clips vidéo, ou même 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 inhabituelle que le modèle de base de vidéo Hunyuan pourrait ne pas connaître, ou être capable de deviner.

Des exemples incluent Roger Rabbit, un xenomorphe, Le Masque, Spider-Man ou d’autres personnalités qui possèdent des caractéristiques de mouvement uniques.

Puisque Hunyuan Video sait déjà comment les hommes et les femmes ordinaires bougent, les clips vidéo ne sont pas nécessaires pour obtenir un LoRA Hunyuan Video convaincant de type humain. Nous allons donc utiliser des images statiques.

PRÉPARATION D’IMAGE

La liste des seaux

La version TLDR:

Il est préférable d’utiliser des images de la même taille pour votre jeu de données ou d’utiliser un répartiteur 50/50 entre deux tailles différentes, par exemple 10 images qui sont 512x768px et 10 qui sont 768x512px.

La formation peut aller bien même si vous ne le faites pas – les LoRAs Hunyuan Video peuvent être étonnamment pardonnables.

La version plus longue

Comme pour les LoRAs Kohya-ss pour les systèmes génératifs statiques tels que Stable Diffusion, bucketing est utilisé pour répartir la charge de travail sur des images de tailles différentes, permettant l’utilisation d’images plus grandes sans provoquer d’erreurs de mémoire au moment de la formation (c’est-à-dire que le bucketing ‘coupe’ les images en morceaux que la GPU peut gérer, tout en maintenant l’intégrité sémantique de l’image entière).

Pour chaque taille d’image que vous incluez dans votre jeu de données de formation (par exemple 512x768px), un seau ou une ‘sous-tâche’ sera créé pour cette taille. Donc si vous avez la répartition suivante d’images:

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

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

Par conséquent, soit restez sur un format de taille, soit essayez de maintenir la répartition des différentes tailles relativement égale.

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

Pour la simplicité, j’ai utilisé 512x768px pour toutes les photos de mon jeu de données.

Avertissement: Le modèle (personne) utilisé dans le jeu de données m’a donné la pleine autorisation d’utiliser ces images à cette fin, et a approuvé toutes les sorties AI basées sur sa ressemblance présentées dans cet article.

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

Vous devez créer un dossier cache à l’intérieur du dossier d’image de formation:

Maintenant, créons un fichier spécial qui configurera la formation.

Fichiers TOML

Les processus de formation et de pré-caching de LoRAs Hunyuan Video obtiennent les chemins de fichiers à partir d’un fichier texte plat avec l’extension .toml.

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

Le contenu de mon fichier TOML de formation 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 barres obliques inverses doubles pour les répertoires d’images et de cache ne sont pas toujours nécessaires, mais elles peuvent aider à éviter des 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 inverses et des barres obliques avant.)

Nous pouvons voir dans la section resolution que deux résolutions seront prises en compte – 512px et 768px. Vous pouvez également la laisser à 512 et toujours obtenir de bons résultats.

Captions

Hunyuan Video est un texte+vision modèle de base, nous devons donc avoir des 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 une multitude de systèmes de légendage open source que nous pourrions utiliser pour cette tâche, mais gardons les choses simples et utilisons le système taggui. Bien qu’il soit stocké sur GitHub et qu’il télécharge des modèles d’apprentissage automatique lourds sur la première exécution, il se présente sous la forme d’un exécutable Windows simple qui charge des bibliothèques Python et une interface utilisateur simple.

Après avoir démarré Taggui, utilisez File > Load Directory pour naviguer jusqu’à votre dossier de jeu de données d’images et, facultativement, placez un identifiant de jeton (dans ce cas, examplewoman) qui sera ajouté à toutes les légendes:

(Assurez-vous de désactiver Load in 4-bit lorsque Taggui s’ouvre pour la première fois – cela lancera des erreurs pendant le légendage si cela est laissé sur)

Sélectionnez une image dans la colonne d’aperçu de gauche et appuyez sur CTRL+A pour sélectionner toutes les images. Ensuite, appuyez sur le bouton Start Auto-Captioning sur la droite:

Vous verrez Taggui télécharger des modèles dans la petite CLI de la colonne de droite, mais seulement si c’est la première fois que vous exécutez le légendeur. Sinon, vous verrez une prévisualisation des légendes.

Maintenant, chaque photo a une légende.txt correspondante avec une description du contenu de l’image:

Vous pouvez cliquer sur Advanced Options dans Taggui pour augmenter la longueur et le style des légendes, mais cela va au-delà de la portée de ce tutoriel.

Quittez Taggui et passons à…

PRÉ-CACHAGE LATENT

Pour éviter une charge excessive de la GPU au moment de la formation, il est nécessaire de créer deux types de fichiers pré-cachés – un pour représenter l’image latente dérivée des images elles-mêmes et un autre pour évaluer une encodeur de texte lié 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 effectueront les processus lorsque vous aurez fourni les informations nécessaires.

Pour le pré-caching latent, copiez le texte suivant dans Notepad et enregistrez-le sous forme de fichier.BAT (par exemple, nommez-le latent-precache.bat), comme précédemment, en veillant à ce que le type de fichier dans le menu déroulant de la boîte de dialogue Enregistrer sous soit 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

(Remplacez [Your Profile Name] par le nom réel de votre dossier de profil Windows)

Vous pouvez maintenant exécuter le fichier.BAT pour le pré-caching latent automatique:

Lorsque vous êtes invité par le fichier.BAT, collez ou tapez le chemin de votre jeu de données, les dossiers de cache et le fichier TOML.

PRÉ-CACHAGE DE TEXTE

Nous allons créer un deuxième fichier.BAT, cette fois pour le pré-caching de 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 votre nom de profil Windows et enregistrez-le sous text-cache.bat (ou tout autre nom que vous aimez), dans n’importe quel emplacement pratique, comme pour le fichier.BAT précédent.

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

FORMATION DU LoRA HUNYUAN VIDEO

La formation du LoRA lui-même prendra beaucoup plus de temps que ces deux processus préparatoires.

Bien qu’il y ait également de multiples variables que nous pourrions nous soucier (telles que la taille du lot, les répétitions, les époques et si nous devons utiliser des modèles complets ou quantifiés, entre autres), nous allons minimiser les choix un peu et former un LoRA sur des paramètres ‘médians’.

Nous allons créer un troisième fichier.BAT, cette fois pour lancer la formation. Collez le texte suivant dans Notepad et enregistrez-le sous forme de fichier.BAT, comme précédemment, sous le nom training.bat (ou tout autre nom que vous aimez):

@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 pour les fichiers.BAT précédents, assurez-vous de remplacer toutes les instances de [Your Profile Name] par 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 emplacement si ce n’est pas le cas.

PRÉVUES DE FORMATION

Il existe une fonction de prévisualisation de formation très basique activée pour Musubi trainer, qui permet de forcer le modèle de formation à s’arrêter et de générer des images basées sur des invites que vous avez enregistrées. Ces invites sont enregistrées dans un dossier automatiquement créé appelé Sample, dans le même répertoire que les modèles formés sont enregistrés.

Pour activer cela, vous devrez enregistrer au moins une invite dans un fichier texte. Le fichier.BAT de formation que nous avons créé vous demandera d’entrer l’emplacement de ce fichier; vous pouvez donc nommer le fichier d’invite comme vous le souhaitez et l’enregistrer n’importe où.

Voici quelques exemples d’invites pour un fichier qui produira trois images différentes lorsque demandé par la routine de formation:

Comme vous pouvez le voir dans l’exemple ci-dessus, vous pouvez mettre des drapeaux à la fin de l’invite qui affecteront les images:

–w est la largeur (par défaut 256px si non défini, selon la documentation)
–h est la hauteur (par défaut 256px si non défini)
–f est le nombre de trames. Si défini sur 1, une image est produite; plus d’une, une vidéo.
–d est la graine. Si non défini, elle est aléatoire; mais vous devriez la définir pour voir une invite évoluer.
–s est le nombre de pas dans la génération, par défaut 20.

Consultez la documentation officielle pour des drapeaux supplémentaires.

Bien que les prévisualisations de formation puissent révéler rapidement certains problèmes qui pourraient vous amener à annuler la formation et à réexaminer les données ou la configuration, n’oubliez pas que chaque invite supplémentaire ralentit un peu plus la formation.

De plus, plus l’image de prévisualisation de formation est grande (comme défini dans les drapeaux répertoriés ci-dessus), plus elle ralentit la formation.

Lancez votre fichier.BAT de formation.

Question #1 est ‘Enter the path to the dataset configuration’. Collez ou tapez le chemin correct vers votre fichier TOML.

Question #2 est ‘Enter the number of epochs to train’. Ceci est une variable d’essai et d’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 élevée que trop basse, car vous pouvez toujours arrêter la formation avec Ctrl+C dans la fenêtre de formation si vous sentez que le modèle a suffisamment progressé. Définissez-le sur 100 pour l’instant et voyez comment cela se passe.

Question #3 est ‘Enter the output name’. Nommez votre modèle! Il est peut-être préférable de garder le nom relativement court et simple.

Question #4 est ‘Choose learning rate’, qui est défini par défaut sur 1e-3 (option 1). Ceci est un bon point de départ, en attendant plus d’expérience.

Question #5 est ‘How often (in steps) to save preview images’. Si vous le définissez trop bas, vous verrez peu de progrès entre les enregistrements d’images de prévisualisation, et cela ralentira la formation.

Question #6 est ‘What is the location of the text-prompt file for training previews?’. Collez ou tapez le chemin vers votre fichier d’invites.

Le fichier.BAT affichera ensuite la commande qu’il enverra au modèle Hunyuan, et vous demandera si vous souhaitez procéder, y/n.

Allez-y et commencez la formation:

Pendant ce temps, si vous vérifiez la section GPU de l’onglet Performance de Gestionnaire de tâches Windows, vous verrez que le processus utilise environ 16 Go de VRAM.

Ceci peut ne pas être un chiffre arbitraire, car c’est la quantité de VRAM disponible sur de nombreuses cartes graphiques NVIDIA, et le code en amont peut avoir été optimisé pour adapter les tâches à 16 Go pour le bénéfice 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 une figure pour le temps écoulé depuis le début de la formation, et une estimation du temps de formation total (qui variera fortement en fonction des drapeaux définis, du nombre d’images de formation, du nombre d’images de prévisualisation de formation, et de nombreux autres facteurs).

Un temps de formation typique est d’environ 3 à 4 heures sur des paramètres médians, selon le matériel disponible, le nombre d’images, les paramètres de drapeau et d’autres facteurs.

UTILISER VOS MODÈLES LoRA FORMÉS DANS HUNYUAN VIDEO

CHOISIR LES POINTS DE CONTRÔLE

Lorsque la formation est terminée, vous aurez un point de contrô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, comme souhaité, en modifiant le nombre --save_every_n_epochs [N] dans le fichier.BAT de formation. Si vous avez ajouté un faible chiffre pour les enregistrements par étapes lorsque vous avez configuré la formation avec le fichier.BAT, il y aura un grand nombre de fichiers de point de contrôle enregistrés.

LEQUEL POINT DE CONTRÔLE CHOISIR?

Comme mentionné précédemment, les modèles formés les plus précoces seront les plus flexibles, tandis que les points de contrôle plus tardifs peuvent offrir le plus de détails. Le seul moyen de tester ces facteurs est de exécuter certains des LoRAs et de générer quelques vidéos. De cette façon, vous pouvez apprendre à connaître quels points de contrôle sont les plus productifs et représentent le meilleur équilibre entre flexibilité et fidélité.

COMFYUI

L’environnement le plus populaire (bien que non le seul) pour utiliser les LoRAs Hunyuan Video, pour l’instant, est ComfyUI, 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 directes et disponibles sur le référentiel GitHub officiel (des modèles supplémentaires devront être téléchargés).

CONVERTIR DES MODÈLES POUR COMFYUI

Vos modèles formés sont enregistrés dans un format (diffusers) qui n’est pas compatible avec la plupart des implémentations de ComfyUI. Musubi est capable de convertir un modèle en un format compatible avec ComfyUI. Créons un fichier.BAT pour implémenter cela.

Avant d’exécuter ce fichier.BAT, créez le dossier C:\Users\[Your Profile Name]\Desktop\Musubi\CONVERTED\ 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 All files à partir de Notepad, en le nommant convert.bat (ou tout autre nom que vous aimez).

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

Collez ou tapez le chemin du fichier formé que vous souhaitez convertir, cliquez sur y, puis appuyez sur Entrée.

Après avoir enregistré le LoRA converti dans le dossier CONVERTED , 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 du fichier.BAT.

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

Généralement, l’emplacement correct est quelque chose comme:

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

CRÉER DES LoRAS HUNYUAN VIDEO DANS COMFYUI

Bien que les flux de travail basés sur des nœuds de ComfyUI semblent complexes au début, les paramètres d’autres utilisateurs plus experts peuvent être chargés en faisant glisser une image (créée avec les paramètres ComfyUI de l’autre utilisateur) directement dans la fenêtre ComfyUI. Les flux de travail peuvent également être exportés sous forme de fichiers JSON, qui peuvent être importés manuellement ou glissés dans une fenêtre ComfyUI.

Certains flux de travail importés peuvent avoir des dépendances qui n’existent pas dans votre installation. Par conséquent, installez ComfyUI-Manager, qui peut récupérer automatiquement les modules manquants.

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

Pour charger l’un des flux de travail utilisés pour générer des vidéos à partir des modèles de ce tutoriel, téléchargez ce fichier JSON et faites-le glisser dans votre fenêtre ComfyUI (bien qu’il y ait de bien meilleurs exemples de flux de travail disponibles sur les communautés Reddit et Discord qui ont adopté Hunyuan Video, et que le mien est adapté de l’un d’eux).

Ce n’est pas l’endroit pour un tutoriel étendu sur l’utilisation de ComfyUI, mais il vaut la peine de mentionner quelques-uns des paramètres cruciaux qui affecteront votre sortie si vous téléchargez et utilisez le fichier de disposition JSON que j’ai lié ci-dessus.

1) Largeur et hauteur

La taille de l’image plus grande, plus longtemps la génération prendra, et plus élevé le risque d’erreur de mémoire (OOM).

2) Longueur

Il s’agit de la valeur numérique pour le nombre de trames. Combien de secondes cela représente dépend du taux d’images par seconde (défini sur 30 ips dans ce flux de travail). Vous pouvez convertir des secondes en trames basées sur le taux d’images par seconde à Omnicalculator.

3) Taille du lot

Plus vous définissez la taille du lot, plus rapide sera le résultat, mais plus lourd sera la charge de la VRAM. Définissez-le trop élevé et vous risquez d’obtenir une erreur OOM.

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

Ceci contrôle la graine aléatoire. Les options pour ce nœud sont fixe, incrémenter, décrémenter et randomiser. Si vous le laissez à fixe et que vous 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. Les paramètres incrémenter et décrémenter vous permettent d’explorer des valeurs de graine voisines, tandis que randomiser vous donne une nouvelle interprétation de l’invite.

5) Nom de LoRA

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

6) Jeton

Si vous avez formé votre modèle pour déclencher le concept avec un jeton (tel que ‘example-person’), placez ce mot déclencheur dans votre invite.

7) Étapes

Ceci représente le nombre d’étapes que le système appliquera au processus de diffusion. Des étapes plus élevées peuvent obtenir de meilleurs détails, mais il y a un plafond à l’efficacité de cette approche, et ce seuil peut être difficile à trouver. La plage de pas commune est d’environ 20-30.

8) Taille de tuile

Ceci définit la quantité d’informations traitées à la fois pendant la génération. Il est défini par défaut sur 256. L’augmenter peut accélérer la génération, mais l’augmenter trop peut entraîner une expérience OOM particulièrement frustrante, car cela se produit à la fin d’un long processus.

9) Chevauchement temporel

La génération de personnes Hunyuan Video peut conduire à un ‘fantôme’ ou à un mouvement non convaincant si cela est défini trop bas. En général, la sagesse actuelle est que cela devrait être défini sur une valeur plus élevée que le nombre de trames, pour produire un meilleur mouvement.

CONCLUSION

Bien que l’exploration plus approfondie de l’utilisation de ComfyUI soit au-delà de la portée de cet article, l’expérience de la communauté sur Reddit et Discord peut faciliter la courbe d’apprentissage, et il existe plusieurs guides en ligne qui introduisent les bases.

Publié pour la première fois le jeudi 23 janvier 2025