Hur man tränar och använder Hunyuan Video LoRA-modeller

Den här artikeln visar hur du installerar och använder Windows-baserad programvara som kan träna Hunyuan video LoRA-modeller, vilket möjliggör för användaren att skapa anpassade personligheter i Hunyuan Video grundmodellen.

Klicka för att spela. Exempel från den senaste explosionen av kändisar Hunyuan LoRAs från civit.ai-samhället.

För närvarande är de två mest populära sätten att generera Hunyuan LoRA-modeller lokalt:

1) Diffusion-pipe-ui Docker-baserad ram, som förlitar sig på Windows Subsystem for Linux (WSL) för att hantera vissa processer.

2) Musubi Tuner, ett nytt tillägg till den populära Kohya ss diffusionsträningsarkitektur. Musubi Tuner kräver inte Docker och är inte beroende av WSL eller andra Linux-baserade proxyservrar – men det kan vara svårt att få det att fungera på Windows.

Därför kommer den här genomgången att fokusera på Musubi Tuner och på att tillhandahålla en helt lokal lösning för Hunyuan LoRA-träning och generering, utan att använda API-styrda webbplatser eller kommersiella GPU-hyra processer som Runpod.

Klicka för att spela. Exempel från LoRA-träning på Musubi Tuner för den här artikeln. Alla tillstånd har getts av personen som avbildas, för att illustrera den här artikeln.

KRAV

Installationen kommer att kräva som minimum en Windows 10-dator med en 30+/40+-serie NVIDIA -kort som har minst 12 GB VRAM (även om 16 GB rekommenderas). Installationen som användes för den här artikeln testades på en maskin med 64 GB systemminne och en NVIDIA 3090-grafikkort med 24 GB VRAM. Den testades på ett dedikerat testsystem med en färsk installation av Windows 10 Professional, på en partition med 600+ GB ledigt diskutrymme.

VARNING

Att installera Musubi Tuner och dess förutsättningar innebär också installation av utvecklarorienterad programvara och paket direkt på huvudinstallationen av en Windows-dator. Att ta installationen av ComfyUI i beaktande, för de sista stadierna, kommer detta projekt att kräva cirka 400-500 gigabyte diskutrymme. Även om jag har testat proceduren utan incident flera gånger i nyinstallerade testmiljöer för Windows 10, är varken jag eller unite.ai ansvariga för eventuell skada på systemen från att följa dessa instruktioner. Jag rekommenderar att du säkerhetskopierar alla viktiga data innan du försöker installera detta.

ÖVERVÄGLINGAR

Är den här metoden fortfarande giltig?

Den generativa AI-scenen rör sig mycket snabbt, och vi kan förvänta oss bättre och mer strömlinjeformade metoder för Hunyuan Video LoRA-ramverk i år.

…eller till och med denna vecka! Medan jag skrev den här artikeln producerade utvecklaren av Kohya/Musubi musubi-tuner-gui, ett sofistikerat Gradio-gränssnitt för Musubi Tuner:

Det är uppenbart att ett användarvänligt gränssnitt är att föredra framför BAT-filerna som jag använder i den här funktionen – så länge musubi-tuner-gui fungerar. När jag skriver detta gick det online för fem dagar sedan, och jag kan inte hitta något konto om någon som har använt det med framgång.

Enligt inlägg i lagringsplatsen är det nya gränssnittet avsett att integreras direkt i Musubi Tuner-projektet så snart som möjligt, vilket kommer att avsluta dess nuvarande existens som en separat GitHub-lagringsplats.

Baserat på de nuvarande installationsanvisningarna kommer det nya gränssnittet att klonas direkt in i den befintliga Musubi-miljön; och trots många försök kan jag inte få det att associera med den befintliga Musubi-installationen. Detta innebär att när det körs kommer det att upptäcka att den inte har någon motor!

När gränssnittet är integrerat i Musubi Tuner kommer problem av det här slaget att säkert lösas. Även om författaren medger att det nya projektet är ‘mycket grovt’, är han optimistisk för dess utveckling och integration direkt i Musubi Tuner.

Med tanke på dessa problem (samt standardvägar vid installations tid och användningen av UV Python-paketet, som komplicerar vissa procedurer i den nya versionen), kommer vi förmodligen att behöva vänta en liten stund på en smidigare Hunyuan Video LoRA-träningsupplevelse. Det ser dock mycket lovande ut!

Men om du inte kan vänta och är villig att rulla upp ärmarna en aning, kan du få Hunyuan video LoRA-träning att fungera lokalt direkt.

Låt oss komma igång.

VARFÖR INSTALLERA NÅGOT PÅ BAR METALL?

(Hoppa över den här meningen om du inte är en avancerad användare)
Avancerade användare kommer att undra varför jag har valt att installera så mycket programvara på den nakna Windows 10-installationen istället för i en virtuell miljö. Anledningen är att den väsentliga Windows-porten av den Linux-baserade Triton-paketet är mycket svårare att få att fungera i en virtuell miljö. Alla andra bar-metallinstallationer i självstudiekursen kunde inte installeras i en virtuell miljö, eftersom de måste komma åt lokal maskinvara direkt.

INSTALLERA FÖRUTSÄTTNINGSPAKET OCH PROGRAM

För de program och paket som måste installeras initialt spelar installationsordningen roll. Låt oss komma igång.

1: LADDA NER MICROSOFT REDISTRIBUTABLE

Ladda ner och installera Microsoft Redistributable-paketet från https://aka.ms/vs/17/release/vc_redist.x64.exe.

Detta är en enkel och snabb installation.

2: INSTALLERA VISUAL STUDIO 2022

Ladda ner Microsoft Visual Studio 2022 Community-utgåva från https://visualstudio.microsoft.com/downloads/?cid=learn-onpage-download-install-visual-studio-page-cta

Starta den nedladdade installatör:

Vi behöver inte alla tillgängliga paket, som skulle vara en tung och lång installation. Vid den initiala Workloads-sidan som öppnas, markera Desktop Development with C++ (se bild nedan).

Nu klickar du på Individual Components-fliken längst upp till vänster i gränssnittet och använder sökrutan för att hitta ‘Windows SDK’.

Genom att markera Windows 11 SDK är endast den senaste versionen av Windows 10 markerad (om du är på Windows 10; den här installationsproceduren har inte testats av mig på Windows 11)).

Sök efter ‘C++ CMake’ och kontrollera att C++ CMake tools for Windows är markerat.

Denna installation kommer att ta minst 13 GB utrymme.

När Visual Studio har installerats kommer det att försöka köra på din dator. Låt det öppna sig fullständigt. När Visual Studio:s fullskärmsgränssnitt är synligt, stäng programmet.

3: INSTALLERA VISUAL STUDIO 2019

Vissa av de efterföljande paketen för Musubi förväntar sig en äldre version av Microsoft Visual Studio, medan andra behöver en nyare.

Därför laddar du också ner den kostnadsfria Community-utgåvan av Visual Studio 19 antingen från Microsoft (https://visualstudio.microsoft.com/vs/older-downloads/ – kräver konto) eller Techspot (https://www.techspot.com/downloads/7241-visual-studio-2019.html).

Installera det med samma alternativ som för Visual Studio 2022 (se procedur ovan, förutom att Windows SDK redan är markerat i Visual Studio 2019-installationsprogrammet).

Du kommer att se att Visual Studio 2019-installationsprogrammet redan är medvetet om den nyare versionen när den installeras:

När installationen är klar och du har öppnat och stängt den installerade Visual Studio 2019-applikationen, öppna ett Windows-kommandofönster (skriv CMD i Start-sök) och skriv in och kör:

where cl

Resultatet bör vara de kända platserna för de två installerade Visual Studio-utgåvorna.

Om du istället får INFO: Could not find files for the given pattern(s), se Check Path-avsnittet i den här artikeln nedan och använd instruktionerna för att lägga till relevanta Visual Studio-sökvägar till Windows-miljö.

Spara alla ändringar som gjorts enligt Check Paths-avsnittet nedan och försök sedan where cl-kommandot igen.

4: INSTALLERA CUDA 11 + 12 VERKTYGSUPPSÄTTNINGAR

De olika paket som installeras i Musubi behöver olika versioner av NVIDIA CUDA, som accelererar och optimerar träning på NVIDIA-grafikkort.

Anledningen till att vi installerade Visual Studio-versionerna först är att NVIDIA CUDA-installationsprogrammen söker efter och integrerar med befintliga Visual Studio-installationer.

Ladda ner ett 11+ serie CUDA-installationspaket från:

https://developer.nvidia.com/cuda-11-8-0-download-archive?target_os=Windows&target_arch=x86_64&target_version=11&target_type=exe_local (ladda ner ‘exe (local)’)

Ladda ner ett 12+ serie CUDA-verktygsuppsättningsinstallationspaket från:

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

Installationsprocessen är identisk för båda installationsprogrammen. Ignorera varningar om existensen eller icke-existensen av installationsvägar i Windows-miljövariabler – vi kommer att hantera detta manuellt senare.

INSTALLERA NVIDIA CUDA VERKTYGSUPPSÄTTNING V11+

Starta installationsprogrammet för 11+ serie CUDA-verktygsuppsättning.

Vid Installation Options väljer du Custom (Advanced) och fortsätter.

Avmarkera NVIDIA GeForce Experience-alternativet och klicka på Next.

Lämna Select Installation Location på standardvärden (detta är viktigt):

Klicka på Next och låt installationen slutföras.

Ignorera varningar eller anteckningar som installationsprogrammet ger om Nsight Visual Studio-integration, som inte behövs för vårt användningsfall.

INSTALLERA NVIDIA CUDA VERKTYGSUPPSÄTTNING V12+

Upprepa hela processen för den separata 12+ NVIDIA-verktygsuppsättningsinstallatör som du laddade ner:

Installationsprocessen för den här versionen är identisk med den som listas ovan (11+ versionen), förutom en varning om miljövägar, som du kan ignorera:

När 12+ CUDA-versionens installation är klar, öppna ett kommandofönster i Windows och skriv in och kör:

nvcc --version

Detta bör bekräfta information om den installerade drivrutinsversionen:

För att kontrollera att ditt kort är erkänt, skriv in och kör:

nvidia-smi

5: INSTALLERA GIT

GIT kommer att hantera installationen av Musubi-lagringsplatsen på din lokala maskin. Ladda ner GIT-installationsprogrammet på:

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

Kör installationsprogrammet:

Använd standardinställningar för Select Components:

Lämna standardredigeraren på Vim:

Låt GIT bestämma grennamn:

Använd rekommenderade inställningar för Path miljö:

Använd rekommenderade inställningar för SSH:

Använd rekommenderade inställningar för HTTPS Transport backend:

Använd rekommenderade inställningar för radslutsomvandling:

Välj Windows standardkonsol som terminal-emulator:

Använd standardinställningar (Fast-forward or merge) för Git Pull:

Använd Git-Credential Manager (standardinställning) för Credential Helper:

I Configuring extra options lämna Enable file system caching markerat och Enable symbolic links avmarkerat (om du inte är en avancerad användare som använder hårda länkar för en central modellrepository).

Avsluta installationen och testa att GIT är installerat korrekt genom att öppna ett CMD-fönster och skriva in och kör:

git --version

GITHUB-INLOGGNING

Senare, när du försöker klona GitHub-lagringsplatser, kan du utmanas för dina GitHub-autentiseringsuppgifter. För att förvänta dig detta, logga in på ditt GitHub-konto (skapa ett om det behövs) på någon webbläsare som är installerad på din Windows-system. På detta sätt bör 0Auth-autentiseringsmetoden (en popup-fönster) ta så lite tid som möjligt.

Efter den första utmaningen bör du förbli autentiserad automatiskt.

6: INSTALLERA CMAKE

CMake 3.21 eller nyare krävs för delar av Musubi-installationsprocessen. CMake är en plattformsoberoende utvecklingsarkitektur som kan orkestrera olika kompilatorer och kompilera programvara från källkod.

Ladda ner det på:

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

Starta installationsprogrammet:

Se till att Add Cmake to the PATH environment variable är markerat.

Klicka på Next.

Skriv in och kör det här kommandot i ett Windows-kommandofönster:

cmake --version

Om CMake installerades korrekt bör det visa något som:

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

7: INSTALLERA PYTHON 3.10

Python-tolken är central för det här projektet. Ladda ner version 3.10 (det bästa kompromisset mellan de olika kraven från Musubi-paket) på:

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

Kör nedladdade installationsprogrammet och lämna på standardinställningar:

Vid slutet av installationsprocessen klickar du på Disable path length limit (kräver UAC-administratörsgodkännande):

I ett Windows-kommandofönster skriv in och kör:

python --version

Detta bör resultera i Python 3.10.0

KONTROLLERA SÖKVÄGAR

Kloning och installation av Musubi-ramverk, samt dess normala drift efter installation, kräver att dess komponenter känner till sökvägen till flera viktiga externa komponenter i Windows, särskilt CUDA.

Så vi behöver öppna sökvägs miljö och kontrollera att alla kraven finns där.

En snabb väg att komma åt kontrollerna för Windows-miljö är att skriva Redigera systemmiljövariabler i Windows-sökfältet.

Klickar du på det här kommer Systemegenskaper-kontrollpanelen att öppnas. I det nedre högra hörnet av Systemegenskaper klickar du på Miljövariabler-knappen, och ett fönster som heter Miljövariabler öppnas. I Systemvariabler-panelen i den nedre halvan av det här fönstret bläddrar du ned till Sökväg och dubbelklickar på det. Detta öppnar ett fönster som heter Redigera miljövariabler. Dra sökvägsfönstrets bredd så att du kan se den fullständiga sökvägen för variablerna:

Här är de viktiga posterna:

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

I de flesta fall bör de korrekta sökvägsvariablerna redan finnas.

Lägg till eventuella saknade sökvägar genom att klicka på Ny på vänster sida av Redigera miljövariabler-fönstret och klistra in den korrekta sökvägen:

Se inte bara till att kopiera och klistra in från de listade sökvägarna ovan; kontrollera att varje motsvarande sökväg finns i din egen Windows-installation.

Om det finns mindre sökvägsvariationer (särskilt med Visual Studio-installationer), använd de listade sökvägarna ovan för att hitta de korrekta målmapparna (dvs. x64 i Host64 i din egen installation). Klistra sedan in de sökvägarna i Redigera miljövariabler-fönstret.

Efter det här, starta om datorn.

INSTALLERA MUSUBI

UPPDATERA PIP

Att använda den senaste versionen av PIP-installationsprogrammet kan underlätta vissa installationsstadier. I ett Windows-kommandofönster med administrativa behörigheter (se Upphöjning nedan), skriv in och kör:

pip install --upgrade pip

UPPHÖJNING

Vissa kommandon kan kräva förhöjda behörigheter (dvs. att de körs som administratör). Om du får felmeddelanden om behörigheter i de följande stadierna, stäng kommandofönstret och öppna det igen i administratörsläge genom att skriva CMD i Windows-sökfältet, högerklicka på Command Prompt och välja Kör som administratör:

För de kommande stadierna kommer vi att använda Windows PowerShell istället för Windows-kommandofönstret. Du kan hitta det genom att skriva PowerShell i Windows-sökfältet och (om nödvändigt) högerklicka på det för att Kör som administratör:

INSTALLERA TORCH

I PowerShell, skriv in och kör:

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

Var tålamod medan de många paketen installeras.

När det är klart kan du verifiera en GPU-aktiverad PyTorch-installation genom att skriva in och kör:

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

Detta bör resultera i:

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

INSTALLERA TRITON FÖR WINDOWS

Nästa, installationen av Triton för Windows-komponenten. I förhöjd PowerShell, skriv in (på en rad):

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

(Installationsprogrammet triton-3.1.0-cp310-cp310-win_amd64.whl fungerar för både Intel- och AMD-processor, så länge arkitekturen är 64-bitars och miljön matchar Python-versionen)

Efter att ha körts bör det resultera i:

Successfully installed triton-3.1.0

Vi kan kontrollera om Triton fungerar genom att importera det i Python. Skriv in det här kommandot:

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

Detta bör producera:

Triton is working

För att kontrollera att Triton är GPU-aktiverad, skriv in:

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

Detta bör resultera i True:

SKAPA DEN VIRTUELLA MILJÖN FÖR MUSUBI

Från och med nu kommer vi att installera all ytterligare programvara i en Python virtuell miljö (eller venv). Detta innebär att allt du behöver göra för att avinstallera all följande programvara är att dra venv:s installationsmapp till papperskorgen.

Låt oss skapa installationsmappen: skapa en mapp som heter Musubi på din skrivbord. Följande exempel förutsätter att den här mappen finns: C:\Users\[Ditt Profilnamn]\Desktop\Musubi\.

I PowerShell, navigera till den mappen genom att skriva in:

cd C:\Users\[Ditt Profilnamn]\Desktop\Musubi

Vi vill att den virtuella miljön ska ha tillgång till vad vi redan har installerat (särskilt Triton), så vi kommer att använda --system-site-packages-flaggan. Skriv in:

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

Vänta på att miljön skapas, och aktivera den sedan genom att skriva in:

.\musubi\Scripts\activate

Från och med nu kan du se att du är i den aktiverade virtuella miljön genom att (musubi) visas i början av alla dina prompter.

KLONERA REPOSITORYT

Navigera till den nyss skapade musubi-mappen (som är inuti Musubi-mappen på ditt skrivbord):

cd musubi

Nu när vi är på rätt plats, skriv in följande kommando:

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

Vänta på att kloningen ska slutföras (det tar inte lång tid).

INSTALLERA KRaven

Navigera till installationsmappen:

cd musubi-tuner

Skriv in:

pip install -r requirements.txt

Vänta på att de många installationerna ska slutföras (det tar längre tid).

AUTOMATISERA ÅTKOMST TILL HUNYUAN VIDEO VENV

För att enkelt aktivera och komma åt den nya venv för framtida sessioner, klistra in följande i Anteckningar och spara det med namnet activate.bat, spara det med Alla filer-alternativet (se bild nedan).

@echo off

call C:\Users\[Ditt Profilnamn]\Desktop\Musubi\musubi\Scripts\activate

cd C:\Users\[Ditt Profilnamn]\Desktop\Musubi\musubi\musubi-tuner

cmd

(Ersätt [Ditt Profilnamn] med ditt riktiga Windows-profilnamn)

Det spelar ingen roll var du sparar den här filen.

Från och med nu kan du dubbelklicka på activate.bat och börja arbeta omedelbart.

ANVÄND MUSUBI TUNER

LADDA NER MODELLERNA

Hunyuan Video LoRA-träningsprocessen kräver att du laddar ner minst sju modeller för att stödja alla möjliga optimeringsalternativ för förkaching och träning av en Hunyuan video LoRA. Tillsammans väger dessa modeller mer än 60 GB.

Aktuella instruktioner för att ladda ner dem kan hittas på https://github.com/kohya-ss/musubi-tuner?tab=readme-ov-file#model-download

Men det här är nedladdningsinstruktionerna vid tidpunkten för skrivande:

clip_l.safetensors, llava_llama3_fp16.safetensors och llava_llama3_fp8.safetensors kan laddas ner på 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 och mp_rank_00_model_states_fp8_map.pt kan laddas ner på https://huggingface.co/tencent/HunyuanVideo/tree/main/hunyuan-video-t2v-720p/transformers

pytorch_model.pt kan laddas ner på https://huggingface.co/tencent/HunyuanVideo/tree/main/hunyuan-video-t2v-720p/vae

Även om du kan placera dem i valfri katalog, låt oss för konsekvensens skull med de föregående skripten placera dem i:

C:\Users\[Ditt Profilnamn]\Desktop\Musubi\musubi\musubi-tuner\modeller\

Detta är konsekvent med katalogarrangemanget före den här punkten. Glöm inte att ersätta [Ditt Profilnamn] med ditt riktiga Windows-profilnamn.

DATASETSFÖRBEREDNING

Ignorera samhällskontroversen kring den här punkten, men det är rättvist att säga att du kommer att behöva mellan 10-100 foton för en träningsdataset för din Hunyuan LoRA. Mycket bra resultat kan uppnås även med 15 bilder, så länge bilderna är välbalanserade och av god kvalitet.

En Hunyuan LoRA kan tränas både på bilder eller mycket korta och lågupplösta videoklipp, eller till och med en blandning av båda – även om att använda videoklipp som träningsdata är utmanande, även för ett 24 GB-kort.

Men videoklipp är bara verkligen användbara om din karaktär rör sig på ett sådant ovanligt sätt att Hunyuan Video-grundmodellen kanske inte känner till det, eller kan gissa.

Exempel skulle inkludera Roger Rabbit, en xenomorph, The Mask, Spider-Man eller andra personligheter som besitter unika karaktärsdrag.

Eftersom Hunyuan Video redan vet hur vanliga män och kvinnor rör sig, är videoklipp inte nödvändiga för att få en övertygande Hunyuan Video LoRA-mänsklig typ av karaktär. Så vi kommer att använda statiska bilder.

BILDFÖRBEREDNING

BUCKETLISTAN

TLDR-versionen:

Det är bäst att antingen använda bilder som alla är i samma storlek för din dataset, eller använda en 50/50-delning mellan två olika storlekar, t.ex. 10 bilder som är 512x768px och 10 som är 768x512px.

Träningen kan gå bra även om du inte gör detta – Hunyuan Video LoRAs kan vara ganska förlåtande.

Längre versionen

Som med Kohya-ss LoRAs för statiska generativa system som Stable Diffusion, används bucketing för att distribuera arbetsbelastningen över olika storlekar på bilder, vilket möjliggör att större bilder kan användas utan att orsaka minnesfel under träningstiden (dvs. bucketing ‘skär upp’ bilderna i bitar som GPU:n kan hantera, samtidigt som den behåller den semantiska integriteten hos hela bilden).

För varje bildstorlek du inkluderar i din träningsdataset (t.ex. 512x768px), skapas en bucket eller ‘underuppgift’ för den storleken. Så om du har följande fördelning av bilder, blir bucket-uppmärksamheten ojämn och riskerar att vissa foton kommer att ges större betydelse under träningen än andra:

2x 512x768px bilder
7x 768x512px bilder
1x 1000x600px bild
3x 400x800px bilder

Vi kan se att bucket-uppmärksamheten är ojämnt fördelad bland dessa bilder:

Därför är det antingen bäst att hålla sig till en formatstorlek, eller försöka hålla fördelningen av olika storlekar relativt jämn.

I båda fallen, undvik mycket stora bilder, eftersom det sannolikt kommer att sakta ner träningen, till ingen betydande fördel.

För enkelhetens skull har jag använt 512x768px för alla foton i min dataset.

Ansvarsfriskrivning: Modellen (personen) som användes i datasetet gav mig fullständigt tillstånd att använda dessa bilder för det här ändamålet, och godkände alla AI-baserade utdata som visar hennes liknande i den här artikeln.

Min dataset består av 40 bilder i PNG-format (även om JPG är bra också). Mina bilder lagrades på C:\Users\Martin\Desktop\DATASETS_HUNYUAN\examplewoman

Du bör skapa en cache-mapp inuti träningsbildmappen:

Nu låt oss skapa en specialfil som kommer att konfigurera träningen.

TOML-FILER

Hunyuan Video LoRA-tränings- och förkachningsprocesser hämtar filsökvägarna från en platt textfil med .toml-tillägget.

För min test är TOML-filen placerad på C:\Users\Martin\Desktop\DATASETS_HUNYUAN\training.toml

Innehållet i min tränings-TOML ser ut så här:

[allmänt]

upplösning = [512, 768]

undertext_tillägg = ".txt"

batchstorlek = 1

aktivera_bucket = true

bucket_no_upscale = false

[[dataset]]

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

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

antal_upprepningar = 1

(Dubbla bakslasha (\\) för bild- och cachemappar är inte alltid nödvändiga, men de kan hjälpa till att undvika fel i fall där det finns ett utrymme i sökvägen. Jag har tränat modeller med.toml-filer som använde enkel-framåt- och enkel-bakåtslashar)

Vi kan se i upplösning-avsnittet att två upplösningar kommer att beaktas – 512px och 768px. Du kan också lämna det på 512 och fortfarande uppnå bra resultat.

UNDERTexter

Hunyuan Video är en text+vision grundmodell, så vi behöver beskrivande undertexter för dessa bilder, som kommer att beaktas under träningen. Träningsprocessen kommer att misslyckas utan undertexter.

Det finns en mängd öppen källkod för bildundertextsystem som vi kunde använda för det här ändamålet, men låt oss hålla det enkelt och använda taggui-systemet. Även om det lagras på GitHub, och även om det laddar ner några tunga djupinlärningsmodeller på första körningen, kommer det i form av ett enkelt Windows-körbar fil som laddar Python-bibliotek och ett enkelt gränssnitt.

Efter att ha startat Taggui, använd Arkiv > Ladda katalog för att navigera till din bild-dataset och eventuellt lägga till en token-identifierare (i det här fallet examplewoman) som kommer att läggas till i alla undertexter:

(Se till att stänga av Ladda i 4-bit när Taggui först öppnas – det kommer att kasta fel under undertextning)

Välj en bild i den vänstra förhandsgranskningskolumnen och tryck på CTRL+A för att välja alla bilderna. Sedan tryck på Start Auto-Captioning-knappen på höger sida:

Du kommer att se Taggui ladda ner modeller i den lilla CLI-rutan på höger sida, men bara om det är första gången du har kört undertextaren. Annars kommer du att se en förhandsgranskning av undertexterna.

Nu har varje foto en motsvarande.txt-undertext med en beskrivning av dess innehåll:

Du kan klicka på Avancerade alternativ i Taggui för att öka längden och stilen på undertexterna, men det är utanför ramen för den här genomgången.

Stäng Taggui och låt oss gå vidare till…

LATENT FÖRKACHNING

För att undvika överdriven GPU-belastning under träningstiden är det nödvändigt att skapa två typer av förkachade filer – en för att representera den latenta bilden som härrör från bilderna själva, och en annan för att utvärdera en textkodning som hänför sig till undertextinnehåll.

För att förenkla alla tre processer (2x cache + träning) kan du använda interaktiva.BAT-filer som kommer att fråga dig frågor och utföra processerna när du har gett nödvändig information.

För den latenta förkachningen, kopiera följande text till Anteckningar och spara det som en.BAT-fil (t.ex. namnge det latent-precache.bat), som tidigare, och se till att filtypen i Spara som-dialogrutan är Alla filer (se bild nedan):

@echo off

REM Aktivera den virtuella miljön

call C:\Users\[Ditt Profilnamn]\Desktop\Musubi\musubi\Scripts\activate.bat

REM Hämta användarinformation

set /p BILD_SÖKVÄG=Ange sökvägen till bildkatalogen:

set /p CACHE_SÖKVÄG=Ange sökvägen till cachemappen:

set /p TOML_SÖKVÄG=Ange sökvägen till TOML-filen:

echo Du angav:

echo Bildsökväg: %BILD_SÖKVÄG%

echo Cachemapp: %CACHE_SÖKVÄG%

echo TOML-filsökväg: %TOML_SÖKVÄG%

set /p BEKRÄFTA=Vill du fortsätta med latent förkachning (j/n)?

if /i "%BEKRÄFTA%"=="j" (

REM Kör det latenta förkachningskommandot

python C:\Users\[Ditt Profilnamn]\Desktop\Musubi\musubi\musubi-tuner\cache_latents.py --dataset_config %TOML_SÖKVÄG% --vae C:\Users\[Ditt Profilnamn]\Desktop\Musubi\musubi\musubi-tuner\models\pytorch_model.pt --vae_chunk_size 32 --vae_tiling

) else (

echo Operationen avbröts.

)

REM Håll fönstret öppet

pause

(Ersätt [Ditt Profilnamn] med ditt riktiga Windows-profilnamn)

Nu kan du köra.BAT-filen för automatisk latent cache:

När du uppmanas av.BAT-filen, klistra in eller skriv in sökvägen till din dataset, cache-mapp och TOML-fil.

TEXT FÖRKACHNING

Vi kommer att skapa en andra.BAT-fil, den här gången för textförkachning.

@echo off

REM Aktivera den virtuella miljön

call C:\Users\[Ditt Profilnamn]\Desktop\Musubi\musubi\Scripts\activate.bat

REM Hämta användarinformation

set /p BILD_SÖKVÄG=Ange sökvägen till bildkatalogen:

set /p CACHE_SÖKVÄG=Ange sökvägen till cachemappen:

set /p TOML_SÖKVÄG=Ange sökvägen till TOML-filen:

echo Du angav:

echo Bildsökväg: %BILD_SÖKVÄG%

echo Cachemapp: %CACHE_SÖKVÄG%

echo TOML-filsökväg: %TOML_SÖKVÄG%

set /p BEKRÄFTA=Vill du fortsätta med textkodningsutdataförkachning (j/n)?

if /i "%BEKRÄFTA%"=="j" (

REM Använd python-köraren från den virtuella miljön

python C:\Users\[Ditt Profilnamn]\Desktop\Musubi\musubi\musubi-tuner\cache_text_encoder_outputs.py --dataset_config %TOML_SÖKVÄG% --text_encoder1 C:\Users\[Ditt Profilnamn]\Desktop\Musubi\musubi\musubi-tuner\models\llava_llama3_fp16.safetensors --text_encoder2 C:\Users\[Ditt Profilnamn]\Desktop\Musubi\musubi\musubi-tuner\models\clip_l.safetensors --batch_size 16

) else (

echo Operationen avbröts.

)

REM Håll fönstret öppet

pause

(Ersätt [Ditt Profilnamn] med ditt riktiga Windows-profilnamn)

Spara det här skriptet som text-cache.bat (eller vilket namn du vill), på valfri plats, enligt proceduren för den föregående.BAT-filen.

Kör den nya.BAT-filen, följ instruktionerna och de nödvändiga textkodade filerna kommer att dyka upp i cache-mappen:

TRÄNA HUNYUAN VIDEO LORA

Träning av den faktiska LoRA kommer att ta betydligt längre tid än dessa två förberedande processer.

Även om det finns flera variabler som vi kunde oroa oss för (såsom batchstorlek, upprepningar, epoker och om vi ska använda fullständiga eller kvantiserade modeller, bland annat), kommer vi att spara dessa överväganden för en annan dag och en djupare titt på de intrikata detaljerna i LoRA-skapande.

För nu kommer vi att minimera valmöjligheterna en aning och träna en LoRA på ‘median’ inställningar.

Vi kommer att skapa en tredje.BAT-fil, den här gången för att initiera träning. Kopiera följande text till Anteckningar och spara det som en.BAT-fil, som tidigare, och namnge det träning.bat (eller vilket namn du vill):

@echo off

REM Aktivera den virtuella miljön

call C:\Users\[Ditt Profilnamn]\Desktop\Musubi\musubi\Scripts\activate.bat

REM Hämta användarinformation

set /p DATASET_KONFIG=Ange sökvägen till dataset-konfigurationsfilen:

set /p EPOKER=Ange antalet epoker att träna:

set /p OUTPUT_NAMN=Ange utdata-modellnamn (t.ex. example0001):

set /p INLÄRNINGS_HASTIGHET=Välj inlärningshastighet (1 för 1e-3, 2 för 5e-3, standard 1e-3):

if "%INLÄRNINGS_HASTIGHET%"=="1" set LR=1e-3

if "%INLÄRNINGS_HASTIGHET%"=="2" set LR=5e-3

if "%INLÄRNINGS_HASTIGHET%"=="" set LR=1e-3

set /p Spara_STEG=Hur ofta (i steg) ska förhandsgranskningsbilder sparas:

set /p PROVM_PUNKTER=Vad är platsen för text-prompt-filen för träningsförhandsgranskningar?

echo Du angav:

echo Dataset-konfigurationsfil: %DATASET_KONFIG%

echo Antal epoker: %EPOKER%

echo Utdata-modellnamn: %OUTPUT_NAMN%

echo Inlärningshastighet: %LR%

echo Spara förhandsgranskningsbilder var %Spara_STEG%e steg.

echo Text-prompt-fil: %PROVM_PUNKTER%

REM Förbered kommandot

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

C:\Users\[Ditt Profilnamn]\Desktop\Musubi\musubi\musubi-tuner\hv_train_network.py ^

--dit C:\Users\[Ditt Profilnamn]\Desktop\Musubi\musubi\musubi-tuner\models\mp_rank_00_model_states.pt ^

--dataset_config %DATASET_KONFIG% ^

--sdpa ^

--mixed_precision bf16 ^

--fp8_base ^

--optimizer_type adamw8bit ^

--inlärnings_hastighet %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 %EPOKER% ^

--save_every_n_epochs=1 ^

--seed 42 ^

--output_dir "C:\Users\[Ditt Profilnamn]\Desktop\Musubi\Output Models" ^

--output_name %OUTPUT_NAMN% ^

--vae C:/Users/[Ditt Profilnamn]/Desktop/Musubi/musubi/musubi-tuner/models/pytorch_model.pt ^

--vae_chunk_size 32 ^

--vae_spatial_tile_sample_min_size 128 ^

--text_encoder1 C:/Users/[Ditt Profilnamn]/Desktop/Musubi/musubi/musubi-tuner/models/llava_llama3_fp16.safetensors ^

--text_encoder2 C:/Users/[Ditt Profilnamn]/Desktop/Musubi/musubi/musubi-tuner/models/clip_l.safetensors ^

--sample_prompts %PROVM_PUNKTER% ^

--sample_every_n_steps %Spara_STEG% ^

--sample_at_first

echo Följande kommando kommer att köras:

echo %CMD%

set /p BEKRÄFTA=Vill du fortsätta med träning (j/n)?

if /i "%BEKRÄFTA%"=="j" (

%CMD%

) else (

echo Operationen avbröts.

)

REM Håll fönstret öppet

cmd /k

(Ersätt [Ditt Profilnamn] med ditt riktiga Windows-profilnamn)

Se till att katalogen C:\Users\[Ditt Profilnamn]\Desktop\Musubi\Output Models\ finns, och skapa den på den platsen om den inte finns.

TRÄNINGSFÖRHANDSGRANSKNINGAR

Det finns en mycket grundläggande träningsförhandsgranskningsfunktion som nyligen aktiverats för Musubi, som tillåter dig att tvinga träningsmodellen att pausa och generera bilder baserat på prompter som du har sparade. Dessa sparas i en automatiskt skapad mapp som heter Exempel, i samma katalog som de tränade modellerna sparas.

För att aktivera detta måste du spara minst en prompt i en textfil. Tränings-BAT som vi skapade kommer att fråga dig var du har placerat den filen; därför kan du namnge prompt-filen till vad du vill och spara den var du vill.

Här är några exempel på prompter för en fil som kommer att producera tre olika bilder när de begärs av träningsrutinen:

Som du kan se i exemplet ovan kan du lägga till flaggor i slutet av prompten som kommer att påverka bilderna:

–w är bredd (standard är 256px om den inte anges, enligt dokumentationen)
–h är höjd (standard är 256px om den inte anges)
–f är antal ramar. Om den är inställd på 1 produceras en bild; mer än en, en video.
–d är frön. Om den inte är inställd är den slumpmässig; men du bör ställa in den för att se en prompt utvecklas.
–s är antalet steg i generationen, som standard 20.

Se den officiella dokumentationen för ytterligare flaggor.

Även om träningsförhandsgranskningar kan snabbt avslöja några problem som kan orsaka att du avbryter träningen och omprövar data eller inställningar, var så god kom ihåg att varje extra prompt kommer att sakta ner träningen en aning mer.

Och ju större träningsförhandsgranskningsbildens bredd och höjd (som anges i flaggorna ovan), desto mer kommer det att sakta ner träningen.

Starta din tränings-BAT-fil.

Fråga #1 är ‘Ange sökvägen till dataset-konfigurationsfilen’. Klistra in eller skriv in den korrekta sökvägen till din TOML-fil.

Fråga #2 är ‘Ange antalet epoker att träna’. Detta är en trial-and-error-variabel, eftersom det påverkas av mängden och kvaliteten på bilder, liksom undertexter och andra faktorer. I allmänhet är det bäst att ställa in det för högt än för lågt, eftersom du alltid kan avbryta träningen med Ctrl+C i träningsfönstret om du känner att modellen har framskridit tillräckligt. Ställ in det på 100 första gången, och se hur det går.

Fråga #3 är ‘Ange utdata-modellnamn’. Namnge din modell! Det kan vara bäst att hålla namnet relativt kort och enkelt.

Fråga #4 är ‘Välj inlärningshastighet’, som standard är 1e-3 (alternativ 1). Detta är en bra plats att börja, med tanke på ytterligare erfarenhet.

Fråga #5 är ‘Hur ofta (i steg) ska förhandsgranskningsbilder sparas’. Om du ställer in det för lågt kommer du att se liten framgång mellan förhandsgranskningsbildsparande, och detta kommer att sakta ner träningen.

Fråga #6 är ‘Vad är platsen för text-prompt-filen för träningsförhandsgranskningar?’. Klistra in eller skriv in sökvägen till din prompt-textfil.

BAT-filen visar dig kommandot som den kommer att skicka till Hunyuan-modellen, och frågar om du vill fortsätta, j/n.

Gå vidare och starta träningen:

Under den här tiden, om du kontrollerar GPU-avsnittet i Prestanda-fliken i Windows Aktivitetshanteraren, kommer du att se att processen tar cirka 16 GB VRAM.

Detta kan inte vara en godtycklig siffra, eftersom detta är den mängd VRAM som finns på ganska många NVIDIA-grafikkort, och den uppströmskod som kan ha optimerats för att passa uppgifterna i 16 GB för att gynna de som äger sådana kort.

Sagt och gjort, är det mycket enkelt att öka den här användningen, genom att skicka mer exorbitanta flaggor till träningskommandot.

Under träning kommer du att se i den nedre högra delen av CMD-fönstret en siffra för hur lång tid som har passerat sedan träningen började, och en uppskattning av den totala tränings­tiden (som kan variera kraftigt beroende på flaggor, antalet träningsbilder, antalet träningsförhandsgranskningsbilder och flera andra faktorer).

En typisk tränings­tids­period är runt 3-4 timmar på median­inställningar, beroende på den tillgängliga maskin­varan, antalet bilder, flagg­inställningar och andra faktorer.

ANVÄND DIN TRÄNAD LoRA-MODELL I HUNYUAN VIDEO

VALET AV CHECKPOINTS

När träningen är avslutad kommer du att ha en modellcheckpunkt för varje epok av träning.

Detta sparfrekvens kan ändras av användaren för att spara oftare eller mindre ofta, som önskat, genom att ändra --save_every_n_epochs [N]-numret i tränings-BAT-filen. Om du lade till ett lågt tal för sparande-per-steg när du ställde in träning med BAT-filen, kommer det att finnas ett stort antal sparade checkpoint-filer.

VILKEN CHECKPOINT SKA JAG VÄLJA?

Som nämnts tidigare kommer de tidigast tränade modellerna att vara de mest flexibla, medan de senare checkpointen kan erbjuda mest detalj. Det enda sättet att testa för dessa faktorer är att köra några av LoRAs och generera några videor. På det sättet kan du lära känna vilka checkpoint som är mest produktiva och representerar den bästa balansen mellan flexibilitet och trohet.

COMFYUI

Den mest populära (även om inte den enda) miljön för att använda Hunyuan Video LoRAs just nu är ComfyUI, en nodbaserad redigerare med ett elaborerat Gradio-gränssnitt som körs i din webbläsare.

Källa: https://github.com/comfyanonymous/ComfyUI

Installationsanvisningar är raka och tillgängliga på den officiella GitHub-lagringsplatsen (ytterligare modeller måste laddas ner).

OMVANDLA MODELLER FÖR COMFYUI

Dina tränade modeller sparas i ett (diffusers) format som inte är kompatibelt med de flesta ComfyUI-implementeringar. Musubi kan omvandla en modell till ett ComfyUI-kompatibelt format. Låt oss ställa in en BAT-fil för att implementera detta.

Innan du kör den här BAT-filen, skapa C:\Users\[Ditt Profilnamn]\Desktop\Musubi\OMVANDLADE\-mappen som skriptet förväntar sig.

@echo off

REM Aktivera den virtuella miljön

call C:\Users\[Ditt Profilnamn]\Desktop\Musubi\musubi\Scripts\activate.bat

:START

REM Hämta användarinformation

set /p INDATA_SÖKVÄG=Ange sökvägen till Musubi-safetensors-filen (eller skriv "exit" för att avsluta):

REM Avsluta om användaren skriver "exit"

if /i "%INDATA_SÖKVÄG%"=="exit" goto END

REM Extrahera filnamnet från indata-sökvägen och lägg till 'omvandlad' till det

for %%F in ("%INDATA_SÖKVÄG%") do set FILNAMN=%%~nF

set UTDATA_SÖKVÄG=C:\Users\[Ditt Profilnamn]\Desktop\Musubi\Output Models\CONVERTED\%FILNAMN%_omvandlad.safetensors

set MÅL=annan

echo Du angav:

echo Indatafil: %INDATA_SÖKVÄG%

echo Utdatafil: %UTDATA_SÖKVÄG%

echo Målformat: %MÅL%

set /p BEKRÄFTA=Vill du fortsätta med omvandlingen (j/n)?

if /i "%BEKRÄFTA%"=="j" (

REM Kör omvandlingsskriptet med korrekt citerade sökvägar

python C:\Users\[Ditt Profilnamn]\Desktop\Musubi\musubi\musubi-tuner\convert_lora.py --input "%INDATA_SÖKVÄG%" --output "%UTDATA_SÖKVÄG%" --target %MÅL%

echo Omvandling slutförd.

) else (

echo Operationen avbröts.

)

REM Återgå till start för en annan fil

goto START

:END

REM Håll fönstret öppet

echo Avslutar skriptet.

pause

(Som tidigare, spara skriptet som ‘Alla filer’ från Anteckningar, namnge det convert.bat eller vilket namn du vill).

När det är sparat, dubbelklicka på den nya BAT-filen, som kommer att fråga efter platsen för en fil att omvandla.

Klistra in eller skriv in sökvägen till den tränade filen du vill omvandla, klicka på j och tryck på enter.

Efter att ha sparat den omvandlade LoRA till OMVANDLADE-mappen, kommer skriptet att fråga om du vill omvandla en annan fil. Om du vill testa flera checkpoint i ComfyUI, omvandla ett urval av modellerna.

När du har omvandlat tillräckligt med checkpoint, stäng BAT-kommandofönstret.

Du kan nu kopiera dina omvandlade modeller till C:\Users\[Ditt Profilnamn]\Desktop\ComfyUI\models\loras\-mappen.

Typiskt är den korrekta platsen något liknande:

C:\Users\[Ditt Profilnamn]\Desktop\ComfyUI\models\loras\

SKAPA HUNYUAN VIDEO LoRAS I COMFYUI

Även om ComfyUI:s nodbaserade arbetsflöden verkar komplexa initialt, kan inställningarna för andra, mer erfarna användare laddas genom att dra en bild (skapad med ComfyUI) direkt in i ComfyUI-fönstret. Arbetsflöden kan också exporteras som JSON-filer, som kan importeras manuellt eller dras in i ett ComfyUI-fönster.

Några importerade arbetsflöden kan ha beroenden som inte finns i din installation. Därför installerar du ComfyUI-Manager, som kan hämta saknade moduler automatiskt.

Källa: https://github.com/ltdrdata/ComfyUI-Manager

För att ladda ett av arbetsflödena som användes för att generera videor från modellerna i den här artikeln, ladda ner den här JSON-filen och dra den in i ditt ComfyUI-fönster (även om det finns betydligt bättre exempel på arbetsflöden tillgängliga på de olika Reddit- och Discord-samhällen som har antagit Hunyuan Video, och min egen är anpassad från en av dem).

Detta är inte platsen för en utökad tutorial om hur man använder ComfyUI, men det är värt att nämna några av de viktigaste parametrarna som kommer att påverka din utdata om du laddar ner och använder den JSON-layout som jag länkade till ovan.

1) BREDD OCH HÖJD

Ju större din bild, desto längre tid tar generationen, och desto större är risken för ett minnesfel (OOM).

2) LÄNGD

Detta är det numeriska värdet för antalet ramar. Hur många sekunder det lägger till beror på bildfrekvensen (inställd på 30fps i den här layouten). Du kan konvertera sekunder till ramar baserat på fps på Omnicalculator.

3) BATCHSTORLEK

Ju högre du ställer in batchstorleken, desto snabbare kan resultatet komma, men desto större är belastningen på VRAM. Ställ in det för högt och du kan få ett minnesfel.

4) KONTROLL EFTER GENERERING

Detta kontrollerar den slumpmässiga frön. Alternativen för den här undernoden är fast, inkrement, dekrement och slumpmässig. Om du lämnar det på fast och inte ändrar textprompten, kommer du att få samma bild varje gång. Om du ändrar textprompten, kommer bilden att ändras i viss mån. Inkrement– och dekrement-inställningarna låter dig utforska närliggande frövärden, medan slumpmässig ger dig en helt ny tolkning av prompten.

5) LoRA-NAMN

Du måste välja din egen installerade modell här, innan du försöker generera.

6) TOKEN

Om du har tränat din modell för att utlösa konceptet med en token (t.ex. ‘example-person’), lägg till den utlösande ordet i din prompt.

7) STEG

Detta representerar hur många steg systemet kommer att tillämpa på diffusionprocessen. Högre steg kan ge bättre detaljer, men det finns en tak på hur effektivt det här tillvägagångssättet är, och den tröskeln kan vara svår att hitta. Det vanliga intervallet för steg är runt 20-30.

8) KAKSTORLEK

Detta definierar hur mycket information som hanteras samtidigt under generationen. Det är inställt på 256 som standard. Att höja det kan påskynda generationen, men att höja det för högt kan leda till ett särskilt frustrerande minnesfel, eftersom det kommer i slutet av en lång process.

9) TEMPORAL ÖVERLAPPNING

Hunyuan Video-generering av människor kan leda till ‘spökbilder’ eller icke övertygande rörelse om det här är inställt för lågt. I allmänhet är den nuvarande visdomen att det här bör ställas in på ett högre värde än antalet ramar, för att producera bättre rörelse.

SLUTSATS

Även om en ytterligare utforskning av ComfyUI-användning ligger utanför ramen för den här artikeln, kan samhällserfarenhet på Reddit och Discord underlätta lärandekurvan, och det finns flera onlineguider som introducerar grunderna.

Publicerad första gången torsdag, 23 januari 2025