Como Treinar e Usar Modelos LoRA de Vídeo Hunyuan

Este artigo mostrará como instalar e usar software baseado no Windows que pode treinar modelos LoRA de vídeo Hunyuan, permitindo que o usuário gere personalidades personalizadas no modelo de fundação de vídeo Hunyuan:

Clique para reproduzir. Exemplos da recente explosão de LoRAs de celebridades Hunyuan da comunidade civit.ai.

No momento, as duas maneiras mais populares de gerar modelos LoRA Hunyuan localmente são:

1) O diffusion-pipe-ui, que depende do Subsistema do Windows para Linux (WSL) para lidar com alguns dos processos.

2) Musubi Tuner, uma nova adição à arquitetura de treinamento de difusão popular Kohya ss. O Musubi Tuner não requer Docker e não depende do WSL ou de proxies baseados em Linux – mas pode ser difícil de executar no Windows.

Portanto, este passo a passo se concentrará no Musubi Tuner e em fornecer uma solução completamente local para o treinamento e geração de LoRA Hunyuan, sem o uso de sites de API ou processos de aluguel de GPU comerciais, como o Runpod.

Clique para reproduzir. Amostras do treinamento de LoRA no Musubi Tuner para este artigo. Todas as permissões concedidas pela pessoa retratada, para ilustrar este artigo.

REQUISITOS

A instalação exigirá, no mínimo, um PC com Windows 10 e uma placa gráfica NVIDIA da série 30+/40+ com pelo menos 12 GB de VRAM (embora 16 GB sejam recomendados). A instalação usada para este artigo foi testada em um sistema com 64 GB de RAM do sistema e uma placa gráfica NVIDIA 3090 com 24 GB de VRAM. Foi testado em um sistema de teste dedicado com uma instalação limpa do Windows 10 Professional, em uma partição com mais de 600 GB de espaço livre em disco.

AVISO

Instalar o Musubi Tuner e seus pré-requisitos também envolve a instalação de software e pacotes de desenvolvedor diretamente na instalação principal do Windows de um PC. Considerando a instalação do ComfyUI, para as etapas finais, este projeto exigirá cerca de 400-500 gigabytes de espaço em disco. Embora eu tenha testado o procedimento sem incidentes várias vezes em ambientes de teste do Windows 10 recém-instalados, nem eu nem o Unite.AI somos responsáveis por qualquer dano ao sistema decorrente do seguimento dessas instruções. Eu aconselho a fazer backup de quaisquer dados importantes antes de tentar esse tipo de procedimento de instalação.

Considerações

Esse Método Ainda é Válido?

A cena de IA gerativa está se movendo muito rapidamente, e podemos esperar métodos melhores e mais otimizados de frameworks LoRA de vídeo Hunyuan este ano.

…ou mesmo esta semana! Enquanto escrevia este artigo, o desenvolvedor do Kohya/Musubi produziu musubi-tuner-gui, uma GUI Gradio sofisticada para o Musubi Tuner:

Obviamente, uma GUI de usuário é preferível aos arquivos BAT que uso neste recurso – desde que o musubi-tuner-gui esteja funcionando. Como escrevo, ele foi disponibilizado online há apenas cinco dias, e não encontrei nenhuma conta de alguém que o tenha usado com sucesso.

De acordo com posts no repositório, a nova GUI está destinada a ser incorporada diretamente ao projeto Musubi Tuner o mais rápido possível, o que encerrará sua existência como repositório independente do GitHub.

Com base nas instruções de instalação atuais, a nova GUI é clonada diretamente no ambiente virtual existente do Musubi; e, apesar de muitas tentativas, não consigo fazê-la se associar à instalação existente do Musubi.

Isso significa que, quando ela for executada, encontrará que não tem um mecanismo!

Uma vez que a GUI seja integrada ao Musubi Tuner, problemas desse tipo certamente serão resolvidos. Embora o autor conceda que o novo projeto é ‘muito bruto’, ele é otimista em relação ao seu desenvolvimento e integração direta ao Musubi Tuner.

Dada essas questões (também relacionadas a caminhos padrão no momento da instalação e ao uso do pacote Python UV, que complica certos procedimentos na nova versão), provavelmente teremos que esperar um pouco por uma experiência de treinamento de LoRA de vídeo Hunyuan mais suave. Dito isso, parece muito promissor!

Mas, se você não puder esperar e estiver disposto a se esforçar um pouco, pode executar o treinamento de LoRA de vídeo Hunyuan localmente agora mesmo.

Vamos começar.

Por Que Instalar Qualquer Coisa no Metal Nu?

(Pule este parágrafo se você não for um usuário avançado)
Usuários avançados se perguntarão por que escolhi instalar tanto software no metal nu da instalação do Windows 10, em vez de em um ambiente virtual. O motivo é que a porta essencial do Windows do pacote baseado em Linux Triton é muito mais difícil de funcionar em um ambiente virtual. Todas as outras instalações de metal nu no tutorial não puderam ser instaladas em um ambiente virtual, pois devem se comunicar diretamente com o hardware local.

Instalando Pacotes e Programas Pré-Requisitos

Para os programas e pacotes que devem ser instalados inicialmente, a ordem de instalação é importante. Vamos começar.

1: Baixe o Pacote Redistribuível da Microsoft

Baixe e instale o pacote redistribuível da Microsoft em https://aka.ms/vs/17/release/vc_redist.x64.exe.

Essa é uma instalação direta e rápida.

2: Instale o Visual Studio 2022

Baixe a edição Community do Microsoft Visual Studio 2022 em https://visualstudio.microsoft.com/downloads/?cid=learn-onpage-download-install-visual-studio-page-cta

Inicie o instalador baixado:

Não precisamos de todos os pacotes disponíveis, o que seria uma instalação pesada e longa. Na página inicial de Cargas de Trabalho que abre, marque Desenvolvimento de Desktop com C++ (veja a imagem abaixo).

Agora, clique na guia Componentes Individuais no canto superior esquerdo da interface e use a caixa de pesquisa para encontrar ‘Windows SDK’.

Por padrão, apenas o Windows 11 SDK está marcado. Se você estiver no Windows 10 (esse procedimento de instalação não foi testado por mim no Windows 11), marque a versão mais recente do Windows 10, indicada na imagem acima.

Pesquise por ‘C++ CMake’ e verifique se as Ferramentas C++ CMake para Windows estão marcadas.

Essa instalação exigirá pelo menos 13 GB de espaço.

Uma vez que o Visual Studio tenha sido instalado, ele tentará executar no seu computador. Deixe-o abrir completamente. Quando a interface completa do Visual Studio estiver visível, feche o programa.

3: Instale o Visual Studio 2019

Alguns dos pacotes subsequentes para o Musubi estão esperando uma versão mais antiga do Microsoft Visual Studio, enquanto outros precisam de uma versão mais recente.

Portanto, também baixe a edição Community gratuita do Visual Studio 19, seja da Microsoft (https://visualstudio.microsoft.com/vs/older-downloads/ – conta necessária) ou do Techspot (https://www.techspot.com/downloads/7241-visual-studio-2019.html).

Instale-o com as mesmas opções que para o Visual Studio 2022 (veja o procedimento acima, exceto que o Windows SDK já está marcado no instalador do Visual Studio 2019).

Você verá que o instalador do Visual Studio 2019 já está ciente da versão mais recente enquanto a instala:

Quando a instalação estiver concluída e você tiver aberto e fechado o aplicativo do Visual Studio 2019 instalado, abra um prompt de comando do Windows (digite CMD na barra de pesquisa do Iniciar) e digite e execute:

where cl

O resultado deve ser os locais conhecidos das duas edições do Visual Studio instaladas.

Se, em vez disso, você receber INFO: Could not find files for the given pattern(s), veja a seção Verificar Caminhos deste artigo abaixo e use essas instruções para adicionar os caminhos relevantes do Visual Studio ao ambiente do Windows.

Salve quaisquer alterações feitas de acordo com a seção Verificar Caminhos abaixo e, em seguida, tente o comando where cl novamente.

4: Instale as Ferramentas CUDA 11 + 12

Os vários pacotes instalados no Musubi precisam de versões diferentes do NVIDIA CUDA, que acelera e otimiza o treinamento em placas gráficas NVIDIA.

O motivo pelo qual instalamos as versões do Visual Studio primeiro é que os instaladores do NVIDIA CUDA procuram e se integram a quaisquer instalações existentes do Visual Studio.

Baixe um pacote de instalação da série 11+ CUDA em:

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

Baixe um pacote de instalação da série 12+ CUDA Toolkit em:

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

O processo de instalação é idêntico para ambos os instaladores. Ignore quaisquer avisos sobre a existência ou inexistência de caminhos de instalação em variáveis de ambiente do Windows – vamos lidar com isso manualmente mais tarde.

Instale a Ferramenta CUDA V11+

Inicie o instalador da série 11+ CUDA Toolkit.

Em Opções de Instalação, escolha Personalizado (Avançado) e prossiga.

Desmarque a opção Experiência GeForce da NVIDIA e clique em Próximo.

Deixe Selecionar Local de Instalação nos padrões (isso é importante):

Clique em Próximo e permita que a instalação seja concluída.

Ignore quaisquer avisos ou notas que o instalador fornece sobre a integração do Nsight Visual Studio, que não é necessária para o nosso caso de uso.

Instale a Ferramenta CUDA V12+

Repita todo o processo para o instalador separado da série 12+ CUDA Toolkit que você baixou:

O processo de instalação é idêntico ao listado acima (a versão 11+), exceto por um aviso sobre os caminhos de ambiente, que você pode ignorar:

Quando a instalação da versão 12+ do CUDA estiver concluída, abra um prompt de comando do Windows e digite e execute:

nvcc --version

Isso deve confirmar informações sobre a versão do driver instalada:

Para verificar se sua placa é reconhecida, digite e execute:

nvidia-smi

5: Instale o GIT

O GIT lidará com a instalação do repositório Musubi em sua máquina local. Baixe o instalador do GIT em:

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

Execute o instalador:

Use as configurações padrão para Selecionar Componentes:

Deixe o editor padrão como Vim:

Deixe o GIT decidir sobre os nomes de branch:

Use as configurações recomendadas para o Caminho do Ambiente:

Use as configurações recomendadas para SSH:

Use as configurações recomendadas para Transporte HTTPS:

Use as configurações recomendadas para conversões de fim de linha:

Escolha o console padrão do Windows como Emulador de Terminal:

Use as configurações padrão (Avançar ou Mesclar) para GIT Pull:

Use o Gerenciador de Credenciais GIT (a configuração padrão) para o Auxiliar de Credenciais:

Na seção Configurando Opções Extras, deixe Habilitar Cache do Sistema de Arquivos marcado e Habilitar Links Simbólicos desmarcado (a menos que você seja um usuário avançado que esteja usando links físicos para um repositório de modelos centralizado).

Conclua a instalação e verifique se o GIT está instalado corretamente abrindo um prompt de comando do Windows e digitando e executando:

git --version

Entrar no GitHub

Mais tarde, quando você tentar clonar repositórios do GitHub, pode ser solicitado que forneça suas credenciais do GitHub. Para antecipar isso, faça login em sua conta do GitHub (crie uma, se necessário) em qualquer navegador instalado em seu sistema Windows. Dessa forma, o método de autenticação 0Auth (uma janela pop-up) deve levar o mínimo de tempo possível.

Depois desse desafio inicial, você deve permanecer autenticado automaticamente.

6: Instale o CMake

O CMake 3.21 ou mais recente é necessário para partes do processo de instalação do Musubi. O CMake é uma arquitetura de desenvolvimento cross-platform capaz de orquestrar compiladores diversos e de compilar software a partir de código-fonte.

Baixe-o em:

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

Inicie o instalador:

Certifique-se de que Adicionar CMake às variáveis de ambiente do sistema esteja marcado.

Clique em Próximo.

Digite e execute este comando em um prompt de comando do Windows:

cmake --version

Se o CMake for instalado com sucesso, ele exibirá algo como:

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

7: Instale o Python 3.10

O interpretador Python é central para este projeto. Baixe a versão 3.10 (o melhor compromisso entre as diferentes demandas dos pacotes do Musubi) em:

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

Execute o instalador de download, deixando as configurações padrão:

No final do processo de instalação, clique em Desabilitar limite de comprimento de caminho (requer confirmação de administrador do UAC):

Em um prompt de comando do Windows, digite e execute:

python --version

Isso deve resultar em Python 3.10.0

Verificar Caminhos

A clonagem e instalação dos frameworks do Musubi, bem como seu funcionamento normal após a instalação, exigem que seus componentes saibam o caminho para vários componentes externos importantes no Windows, particularmente o CUDA.

Portanto, precisamos abrir o caminho do ambiente e verificar se todos os pré-requisitos estão lá.

Uma maneira rápida de acessar os controles do ambiente do Windows é digitar Editar as variáveis de ambiente do sistema na barra de pesquisa do Windows.

Clicando nisso, abrirá o painel de controle Propriedades do Sistema. No canto inferior direito do Propriedades do Sistema, clique no botão Variáveis de Ambiente e uma janela chamada Variáveis de Ambiente será aberta. No painel Variáveis do Sistema na metade inferior dessa janela, role até Caminho e clique duas vezes nele. Isso abrirá uma janela chamada Editar variáveis de ambiente. Arraste a largura dessa janela para que você possa ver o caminho completo das variáveis:

Aqui, as entradas importantes são:

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

Na maioria dos casos, as variáveis de caminho corretas já devem estar presentes.

Adicione quaisquer caminhos que estejam faltando clicando em Novo à esquerda da janela Editar variáveis de ambiente e colando o caminho correto:

Não copie e cole simplesmente dos caminhos listados acima; verifique se cada caminho equivalente existe em sua própria instalação do Windows.

Se houver variações menores de caminho (particularmente com instalações do Visual Studio), use os caminhos listados acima para encontrar as pastas de destino corretas (i.e., x64 em Host64 em sua própria instalação). Em seguida, cole esses caminhos na janela Editar variáveis de ambiente.

Depois disso, reinicie o computador.

Instalando o Musubi

Atualizar o PIP

Usar a versão mais recente do instalador PIP pode facilitar algumas das etapas de instalação. Em um prompt de comando do Windows com privilégios de administrador (veja Elevação abaixo), digite e execute:

pip install --upgrade pip

Elevação

Alguns comandos podem exigir privilégios elevados (i.e., para serem executados como administrador). Se você receber mensagens de erro sobre permissões nas etapas seguintes, feche a janela do prompt de comando e reabra-a no modo de administrador, digitando CMD na caixa de pesquisa do Windows, clicando com o botão direito em Prompt de Comando e selecionando Executar como administrador:

Para as próximas etapas, vamos usar o Windows Powershell em vez do prompt de comando do Windows. Você pode encontrá-lo digitando Powershell na caixa de pesquisa do Windows e (se necessário) clicando com o botão direito nele para Executar como administrador:

Instale o Torch

No Powershell, digite e execute:

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

Seja paciente enquanto os muitos pacotes são instalados.

Quando concluído, você pode verificar uma instalação do PyTorch habilitada para GPU digitando e executando:

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

Isso deve resultar em:

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

Instale o Triton para Windows

Em seguida, a instalação do componente Triton para Windows. No Powershell elevado, entre (em uma linha):

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

(O instalador triton-3.1.0-cp310-cp310-win_amd64.whl funciona para CPUs Intel e AMD, desde que a arquitetura seja 64 bits e o ambiente corresponda à versão do Python)

Depois de executado, isso deve resultar em:

Successfully installed triton-3.1.0

Podemos verificar se o Triton está funcionando importando-o no Python. Digite e execute este comando:

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

Isso deve sair:

Triton is working

Para verificar se o Triton está habilitado para GPU, digite e execute:

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

Isso deve resultar em True:

Criar o Ambiente Virtual para o Musubi

A partir de agora, vamos instalar qualquer software adicional em um ambiente virtual Python (ou venv). Isso significa que tudo o que você precisará fazer para desinstalar todo o software subsequente é arrastar a pasta de instalação do venv para a lixeira.

Vamos criar aquela pasta de instalação: crie uma pasta chamada Musubi na área de trabalho. Os exemplos a seguir supõem que essa pasta existe: C:\Users\[Seu Nome de Perfil]\Desktop\Musubi\.

No Powershell, navegue até essa pasta digitando:

cd C:\Users\[Seu Nome de Perfil]\Desktop\Musubi

Queremos que o ambiente virtual tenha acesso ao que instalamos anteriormente (especialmente o Triton), então vamos usar a flag --system-site-packages. Digite:

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

Aguarde a criação do ambiente e, em seguida, ative-o digitando:

.\musubi\Scripts\activate

A partir daqui, você pode dizer que está no ambiente virtual ativado pelo fato de (musubi) aparecer no início de todos os seus prompts.

Clonar o Repositório

Navegue até a pasta recém-criada musubi (que está dentro da pasta Musubi na área de trabalho):

cd musubi

Agora que estamos no local correto, digite o seguinte comando:

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

Aguarde a clonagem ser concluída (não levará muito tempo).

Instalando Requisitos

Navegue até a pasta de instalação:

cd musubi-tuner

Digite:

pip install -r requirements.txt

Aguarde as muitas instalações serem concluídas (isso levará mais tempo).

Automatizar o Acesso ao Venv do Hunyuan Video

Para acessar facilmente o venv para sessões futuras, cole o seguinte texto no Bloco de Notas e salve-o como um arquivo .BAT (i.e., nomeie-o como activate.bat), garantindo que o tipo de arquivo na caixa suspensa do diálogo Salvar como seja Todos os arquivos (veja a imagem abaixo).

@echo off

call C:\Users\[Seu Nome de Perfil]\Desktop\Musubi\musubi\Scripts\activate

cd C:\Users\[Seu Nome de Perfil]\Desktop\Musubi\musubi\musubi-tuner

cmd

( Certifique-se de substituir [Seu Nome de Perfil] pelo seu nome de perfil real do Windows)

Não importa em qual local você salve esse arquivo.

A partir de agora, você pode clicar duas vezes no arquivo .BAT para começar a trabalhar imediatamente.

Usando o Musubi Tuner

Baixando os Modelos

O processo de treinamento de LoRA de vídeo Hunyuan exige a instalação de pelo menos sete modelos para suportar todas as opções de otimização possíveis para pré-caching e treinamento de um LoRA de vídeo Hunyuan. Juntos, esses modelos pesam mais de 60 GB.

As instruções atuais para baixá-los podem ser encontradas em https://github.com/kohya-ss/musubi-tuner?tab=readme-ov-file#model-download

No entanto, essas são as instruções de download no momento da escrita:

clip_l.safetensors
llava_llama3_fp16.safetensors e
llava_llama3_fp8_scaled.safetensors
podem ser baixados em:
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 e
mp_rank_00_model_states_fp8_map.pt
podem ser baixados em:
https://huggingface.co/tencent/HunyuanVideo/tree/main/hunyuan-video-t2v-720p/transformers

pytorch_model.pt
pode ser baixado em:
https://huggingface.co/tencent/HunyuanVideo/tree/main/hunyuan-video-t2v-720p/vae

Embora você possa colocá-los em qualquer diretório que escolher, para consistência com a estruturação posterior, vamos colocá-los em:

C:\Users\[Seu Nome de Perfil]\Desktop\Musubi\musubi\musubi-tuner\models\

Isso é consistente com a estruturação de diretório antes deste ponto. Qualquer comando ou instrução a partir daqui supõe que este é o local onde os modelos estão localizados; e não se esqueça de substituir [Seu Nome de Perfil] pelo seu nome de perfil real do Windows.

Preparação do Conjunto de Dados

Ignorando a controvérsia comunitária sobre esse ponto, é justo dizer que você precisará de algum lugar entre 10-100 fotos para um conjunto de dados de treinamento para o seu LoRA Hunyuan. Resultados muito bons podem ser obtidos mesmo com 15 imagens, desde que as imagens sejam equilibradas e de boa qualidade.

Um LoRA Hunyuan pode ser treinado em imagens ou em clipe de vídeo muito curto e de baixa resolução, ou mesmo em uma mistura de ambos – embora o uso de clipe de vídeo como dados de treinamento seja desafiador, mesmo para um cartão de 24 GB.

No entanto, os clipe de vídeo são úteis apenas se o seu personagem se move de uma maneira tão incomum que o modelo de fundação de vídeo Hunyuan talvez não saiba sobre isso, ou consiga adivinhar.

Exemplos incluem Roger Rabbit, um xenomorfo, A Máscara, Homem-Aranha ou outras personalidades que possuem movimento único.

Como o Hunyuan Video já sabe como homens e mulheres comuns se movem, os clipe de vídeo não são necessários para obter um personagem LoRA de vídeo Hunyuan do tipo humano convincente. Portanto, usaremos imagens estáticas.

Preparação de Imagem

A Lista de Desejos

A Versão Resumida:

É melhor usar imagens que sejam todas do mesmo tamanho para o seu conjunto de dados, ou usar uma divisão 50/50 entre dois tamanhos diferentes, i.e., 10 imagens que sejam 512x768px e 10 que sejam 768x512px.

O treinamento pode ir bem mesmo se você não fizer isso – os LoRAs de vídeo Hunyuan podem ser surpreendentemente indulgentes.

A Versão Mais Longa

Como os LoRAs de Kohya-ss para sistemas gerativos estáticos, como a Difusão Estável, bucketing é usado para distribuir a carga de trabalho em imagens de diferentes tamanhos, permitindo que imagens maiores sejam usadas sem causar erros de falta de memória no momento do treinamento (i.e., o bucketing ‘corta’ as imagens em pedaços que a GPU possa lidar, mantendo a integridade semântica da imagem inteira).

Para cada tamanho de imagem que você inclui no conjunto de dados de treinamento (i.e., 512x768px), um bucket ou ‘sub-tarefa’ será criado para esse tamanho. Então, se você tiver a seguinte distribuição de imagens, isso é como a atenção do bucket se torna desequilibrada e arrisca que algumas fotos sejam consideradas mais no treinamento do que outras:

2x 512x768px imagens
7x 768x512px imagens
1x 1000x600px imagem
3x 400x800px imagens

Podemos ver que a atenção do bucket é dividida de forma desigual entre essas imagens:

Portanto, ou fique com um formato de tamanho, ou tente manter a distribuição de diferentes tamanhos relativamente igual.

Em qualquer caso, evite imagens muito grandes, pois isso provavelmente retardará o treinamento, com pouco benefício.

Para simplicidade, usei 512x768px para todas as fotos no meu conjunto de dados.

Aviso: O modelo (pessoa) usado no conjunto de dados me deu permissão total para usá-las para esse propósito e aprovou todas as saídas de IA que representam sua semelhança apresentadas neste artigo.

Meu conjunto de dados consiste em 40 imagens, no formato PNG (embora o JPG também seja bom). Minhas imagens estavam armazenadas em C:\Users\Martin\Desktop\DATASETS_HUNYUAN\examplewoman

Você deve criar uma pasta cache dentro da pasta de imagem de treinamento:

Agora, vamos criar um arquivo especial que configurará o treinamento.

Arquivos TOML

O processo de treinamento e pré-caching do LoRA de vídeo Hunyuan obtém os caminhos de arquivo de um arquivo de texto plano com a extensão .toml.

Para o meu teste, o TOML está localizado em C:\Users\Martin\Desktop\DATASETS_HUNYUAN\training.toml

O conteúdo do meu arquivo TOML de treinamento parece com isso:

[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

(As barras duplas para diretórios de imagem e cache não são sempre necessárias, mas podem ajudar a evitar erros em casos onde há um espaço no caminho. Eu treinei modelos com arquivos .toml que usavam barras simples para a frente e para trás)

Podemos ver na seção resolution que duas resoluções serão consideradas – 512px e 768px. Você também pode deixá-lo em 512, e ainda obter bons resultados.

Legendas

O Hunyuan Video é um modelo de fundação texto+visão, então precisamos de legendas descritivas para essas imagens, que serão consideradas durante o treinamento. O processo de treinamento falhará sem legendas.

Há uma multidão de sistemas de legendas de código aberto que poderíamos usar para essa tarefa, mas vamos manter as coisas simples e usar o sistema taggui. Embora esteja armazenado no GitHub e embora baixe alguns modelos de aprendizado profundo muito pesados na primeira execução, ele vem na forma de um executável do Windows simples que carrega bibliotecas Python e uma interface do usuário simples.

Depois de iniciar o Taggui, use Arquivo > Carregar Diretório para navegar até o conjunto de dados de imagem e, opcionalmente, coloque um identificador de token (neste caso, examplewoman) que será adicionado a todas as legendas:

(Certifique-se de desligar Carregar em 4-bit quando o Taggui for aberto pela primeira vez – ele lançará erros durante a legendagem se isso for deixado ligado)

Selecione uma imagem na coluna de visualização à esquerda e pressione CTRL+A para selecionar todas as imagens. Em seguida, pressione o botão Iniciar Legendagem Automática à direita:

Você verá o Taggui baixando modelos na pequena CLI na coluna da direita, mas apenas se for a primeira vez que você executou o legendador. Caso contrário, você verá uma visualização das legendas.

Agora, cada foto tem uma legenda .txt correspondente com uma descrição do conteúdo da imagem:

Você pode clicar em Opções Avançadas no Taggui para aumentar o comprimento e o estilo das legendas, mas isso está além do escopo deste passo a passo.

Sair do Taggui e vamos para…

Pré-Caching Latente

Para evitar uma carga excessiva de GPU no momento do treinamento, é necessário criar dois tipos de arquivos pré-cacheados – um para representar a imagem latente derivada das imagens em si e outro para avaliar uma codificação de texto relacionada ao conteúdo da legenda.

Para simplificar os três processos (2x cache + treinamento), você pode usar arquivos .BAT interativos que farão perguntas e realizarão os processos quando você fornecer as informações necessárias.

Para o pré-caching latente, copie o seguinte texto no Bloco de Notas e salve-o como um arquivo .BAT (i.e., nomeie-o como latent-precache.bat), como antes, garantindo que o tipo de arquivo na caixa suspensa do diálogo Salvar como seja Todos os arquivos (veja a imagem abaixo):

@echo off

REM Ative o ambiente virtual

call C:\Users\[Seu Nome de Perfil]\Desktop\Musubi\musubi\Scripts\activate.bat

REM Obtenha a entrada do usuário

set /p IMAGE_PATH=Digite o caminho do diretório de imagem:

set /p CACHE_PATH=Digite o caminho do diretório de cache:

set /p TOML_PATH=Digite o caminho do arquivo TOML:

echo Você digitou:

echo Caminho da imagem: %IMAGE_PATH%

echo Caminho do cache: %CACHE_PATH%

echo Caminho do arquivo TOML: %TOML_PATH%

set /p CONFIRM=Você deseja prosseguir com o pré-caching latente (s/n)?

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

REM Execute o script de pré-caching latente

python C:\Users\[Seu Nome de Perfil]\Desktop\Musubi\musubi\musubi-tuner\cache_latents.py --dataset_config %TOML_PATH% --vae C:\Users\[Seu Nome de Perfil]\Desktop\Musubi\musubi\musubi-tuner\models\pytorch_model.pt --vae_chunk_size 32 --vae_tiling

) else (

echo Operação cancelada.

)

REM Mantenha a janela aberta

pause

( Certifique-se de substituir [Seu Nome de Perfil] pelo seu nome de perfil real do Windows)

Agora você pode executar o arquivo .BAT para o pré-caching latente automático:

Quando solicitado pelas várias perguntas do arquivo .BAT, cole ou digite o caminho para o conjunto de dados, pastas de cache e arquivo TOML.

Pré-Caching de Texto

Vamos criar um segundo arquivo .BAT, desta vez para o pré-caching de texto.

@echo off

REM Ative o ambiente virtual

call C:\Users\[Seu Nome de Perfil]\Desktop\Musubi\musubi\Scripts\activate.bat

REM Obtenha a entrada do usuário

set /p IMAGE_PATH=Digite o caminho do diretório de imagem:

set /p CACHE_PATH=Digite o caminho do diretório de cache:

set /p TOML_PATH=Digite o caminho do arquivo TOML:

echo Você digitou:

echo Caminho da imagem: %IMAGE_PATH%

echo Caminho do cache: %CACHE_PATH%

echo Caminho do arquivo TOML: %TOML_PATH%

set /p CONFIRM=Você deseja prosseguir com o pré-caching de saída do codificador de texto (s/n)?

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

REM Use o executável Python do ambiente virtual

python C:\Users\[Seu Nome de Perfil]\Desktop\Musubi\musubi\musubi-tuner\cache_text_encoder_outputs.py --dataset_config %TOML_PATH% --text_encoder1 C:\Users\[Seu Nome de Perfil]\Desktop\Musubi\musubi\musubi-tuner\models\llava_llama3_fp16.safetensors --text_encoder2 C:\Users\[Seu Nome de Perfil]\Desktop\Musubi\musubi\musubi-tuner\models\clip_l.safetensors --batch_size 16

) else (

echo Operação cancelada.

)

REM Mantenha a janela aberta

pause

Substitua o nome do seu perfil do Windows e salve este script como text-cache.bat (ou qualquer nome que você goste), em qualquer local conveniente, conforme o procedimento para o arquivo .BAT anterior.

Execute esse novo arquivo .BAT, siga as instruções e os arquivos de texto codificados necessários aparecerão na pasta cache:

Treinando o LoRA de Vídeo Hunyuan

Treinar o LoRA real levará consideravelmente mais tempo do que esses dois processos preparatórios.

Embora haja também muitas variáveis que poderíamos se preocupar (como tamanho de lote, repetições, épocas e se usar modelos completos ou quantizados, entre outros), vamos poupar essas considerações para outro dia e um olhar mais profundo nas complexidades da criação de LoRA.

Por agora, vamos minimizar as escolhas um pouco e treinar um LoRA em configurações ‘medianas’.

Vamos criar um terceiro arquivo .BAT, desta vez para iniciar o treinamento. Cole o seguinte texto no Bloco de Notas e salve-o como um arquivo .BAT, como antes, como training.bat (ou qualquer nome que você goste):

@echo off

REM Ative o ambiente virtual

call C:\Users\[Seu Nome de Perfil]\Desktop\Musubi\musubi\Scripts\activate.bat

REM Obtenha a entrada do usuário

set /p DATASET_CONFIG=Digite o caminho do arquivo de configuração do conjunto de dados:

set /p EPOCHS=Digite o número de épocas para treinar:

set /p OUTPUT_NAME=Digite o nome do modelo de saída (por exemplo, example0001):

set /p LEARNING_RATE=Escolha a taxa de aprendizado (1 para 1e-3, 2 para 5e-3, padrão 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=Com que frequência (em passos) salvar imagens de visualização:

set /p SAMPLE_PROMPTS=Qual é a localização do arquivo de prompt de texto para visualizações de treinamento?

echo Você digitou:

echo Arquivo de configuração do conjunto de dados: %DATASET_CONFIG%

echo Número de épocas: %EPOCHS%

echo Nome de saída: %OUTPUT_NAME%

echo Taxa de aprendizado: %LR%

echo Salvar imagens de visualização a cada %SAVE_STEPS% passos.

echo Arquivo de prompt de texto: %SAMPLE_PROMPTS%

REM Prepare o comando

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

C:\Users\[Seu Nome de Perfil]\Desktop\Musubi\musubi\musubi-tuner\hv_train_network.py ^

--dit C:\Users\[Seu Nome de Perfil]\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\[Seu Nome de Perfil]\Desktop\Musubi\Output Models" ^

--output_name %OUTPUT_NAME% ^

--vae C:/Users/[Seu Nome de Perfil]/Desktop/Musubi/musubi/musubi-tuner/models/pytorch_model.pt ^

--vae_chunk_size 32 ^

--vae_spatial_tile_sample_min_size 128 ^

--text_encoder1 C:/Users/[Seu Nome de Perfil]/Desktop/Musubi/musubi/musubi-tuner/models/llava_llama3_fp16.safetensors ^

--text_encoder2 C:/Users/[Seu Nome de Perfil]/Desktop/Musubi/musubi/musubi-tuner/models/clip_l.safetensors ^

--sample_prompts %SAMPLE_PROMPTS% ^

--sample_every_n_steps %SAVE_STEPS% ^

--sample_at_first

echo O seguinte comando será executado:

echo %CMD%

set /p CONFIRM=Você deseja prosseguir com o treinamento (s/n)?

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

%CMD%

) else (

echo Operação cancelada.

)

REM Mantenha a janela aberta

cmd /k

Como de costume, certifique-se de substituir todas as instâncias de [Seu Nome de Perfil] pelo seu nome de perfil real do Windows.

Certifique-se de que o diretório C:\Users\[Seu Nome de Perfil]\Desktop\Musubi\Output Models\ exista e crie-o nesse local se não existir.

Visualizações de Treinamento

Há um recurso de visualização de treinamento muito básico habilitado recentemente para o treinador Musubi, que permite que você force o modelo de treinamento a pausar e gerar imagens com base em prompts que você salvou. Essas são salvas em uma pasta Amostra automaticamente criada no mesmo diretório que os modelos treinados são salvos.

Para habilitar isso, você precisará salvar pelo menos um prompt em um arquivo de texto. O arquivo .BAT de treinamento pedirá que você insira a localização desse arquivo; portanto, você pode nomear o arquivo de prompt como quiser e salvá-lo em qualquer lugar.

Aqui estão alguns exemplos de prompts para um arquivo que sairá três imagens diferentes quando solicitado pela rotina de treinamento:

Como você pode ver no exemplo acima, você pode colocar sinalizadores no final do prompt que afetarão as imagens:

–w é largura (padrão 256px se não definido, de acordo com a documentação)
–h é altura (padrão 256px se não definido)
–f é o número de frames. Se definido como 1, uma imagem é produzida; mais de um, um vídeo.
–d é a semente. Se não definido, é aleatório; mas você deve defini-lo para ver um prompt evoluindo.
–s é o número de passos na geração, padrão 20.

Veja a documentação oficial para sinalizadores adicionais.

Embora as visualizações de treinamento possam revelar rapidamente alguns problemas que podem fazer com que você cancele o treinamento e reconsidere os dados ou a configuração, economizando tempo, lembre-se de que cada prompt extra desacelera o treinamento um pouco mais.

Além disso, quanto maior a largura e altura da imagem de visualização de treinamento (conforme definido nos sinalizadores listados acima), mais o treinamento será desacelerado.

Inicie o arquivo .BAT de treinamento.

Pergunta #1 é ‘Digite o caminho do arquivo de configuração do conjunto de dados’. Cole ou digite o caminho correto para o arquivo TOML.

Pergunta #2 é ‘Digite o número de épocas para treinar’. Essa é uma variável de tentativa e erro, pois é afetada pela quantidade e qualidade das imagens, bem como pelas legendas e outros fatores. Em geral, é melhor definir como muito alto do que muito baixo, pois você sempre pode interromper o treinamento com Ctrl+C na janela de treinamento se sentir que o modelo avançou o suficiente. Defina como 100 no primeiro caso e veja como vai.

Pergunta #3 é ‘Digite o nome do modelo de saída’. Nomeie seu modelo! Pode ser melhor manter o nome razoavelmente curto e simples.

Pergunta #4 é ‘Escolha a taxa de aprendizado’, que é padrão 1e-3 (opção 1). Isso é um bom lugar para começar, pendente de mais experiência.

Pergunta #5 é ‘Com que frequência (em passos) salvar imagens de visualização’. Se você definir isso muito baixo, você verá pouco progresso entre as imagens de visualização salvas, e isso desacelerará o treinamento.

Pergunta #6 é ‘Qual é a localização do arquivo de prompt de texto para visualizações de treinamento?’. Cole ou digite o caminho para o arquivo de prompts de texto.

O arquivo .BAT, em seguida, mostrará o comando que ele enviará ao modelo Hunyuan e perguntará se você deseja prosseguir, s/n.

Vá em frente e comece o treinamento:

Durante esse tempo, se você verificar a seção GPU da guia de Desempenho do Gerenciador de Tarefas do Windows, você verá que o processo está usando cerca de 16 GB de VRAM.

Isso pode não ser uma figura arbitrária, pois essa é a quantidade de VRAM disponível em muitas placas gráficas NVIDIA, e o código upstream pode ter sido otimizado para caber nessa tarefa para o benefício daqueles que possuem essas placas.

Dito isso, é muito fácil aumentar esse uso, enviando sinalizadores mais exorbitantes para o comando de treinamento.

Durante o treinamento, você verá no canto inferior direito da janela do prompt de comando uma figura para o tempo decorrido desde o início do treinamento e uma estimativa do tempo total de treinamento (que variará muito dependendo dos sinalizadores definidos, número de imagens de treinamento, número de imagens de visualização de treinamento e vários outros fatores).

Um tempo de treinamento típico é de cerca de 3-4 horas em configurações medianas, dependendo do hardware disponível, número de imagens, configurações de sinalizadores e outros fatores.

Usando Seus Modelos LoRA Treinados no Hunyuan Video

Escolhendo Pontos de Verificação

Quando o treinamento for concluído, você terá um ponto de verificação para cada época de treinamento.

Essa frequência de salvamento pode ser alterada pelo usuário para salvar com mais ou menos frequência, conforme desejado, alterando o número --save_every_n_epochs [N] no arquivo .BAT de treinamento. Se você adicionou uma figura baixa para salvamentos por passos ao configurar o treinamento com o arquivo .BAT, haverá um grande número de arquivos de ponto de verificação salvos.

Qual Ponto de Verificação Escolher?

Como mencionado anteriormente, os modelos treinados mais cedo serão mais flexíveis, enquanto os pontos de verificação posteriores podem oferecer mais detalhes. A única maneira de testar esses fatores é executar alguns dos LoRAs e gerar alguns vídeos. Dessa forma, você pode conhecer quais pontos de verificação são mais produtivos e representam o melhor equilíbrio entre flexibilidade e fidelidade.

ComfyUI

O ambiente mais popular (embora não o único) para usar LoRAs de vídeo Hunyuan no momento é o ComfyUI, um editor baseado em node com uma interface Gradio elaborada que é executada em seu navegador.

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

As instruções de instalação são diretas e disponíveis no repositório GitHub oficial (modelos adicionais precisarão ser baixados).

Convertendo Modelos para o ComfyUI

Seus modelos treinados são salvos em um formato (diffusers) que não é compatível com a maioria das implementações do ComfyUI. O Musubi pode converter um modelo para um formato compatível com o ComfyUI. Vamos configurar um arquivo .BAT para implementar isso.

Antes de executar esse arquivo .BAT, crie a pasta C:\Users\[Seu Nome de Perfil]\Desktop\Musubi\CONVERTED\ que o script está esperando.

@echo off

REM Ative o ambiente virtual

call C:\Users\[Seu Nome de Perfil]\Desktop\Musubi\musubi\Scripts\activate.bat

:START

REM Obtenha a entrada do usuário

set /p INPUT_PATH=Digite o caminho do arquivo safetensors de entrada (ou digite "sair" para sair):

REM Saia se o usuário digitar "sair"

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

REM Extraia o nome do arquivo do caminho de entrada e adicione 'converted' a ele

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

set OUTPUT_PATH=C:\Users\[Seu Nome de Perfil]\Desktop\Musubi\Output Models\CONVERTED\%FILENAME%_converted.safetensors

set TARGET=other

echo Você digitou:

echo Arquivo de entrada: %INPUT_PATH%

echo Arquivo de saída: %OUTPUT_PATH%

echo Formato de destino: %TARGET%

set /p CONFIRM=Você deseja prosseguir com a conversão (s/n)?

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

REM Execute o script de conversão com caminhos corretamente citados

python C:\Users\[Seu Nome de Perfil]\Desktop\Musubi\musubi\musubi-tuner\convert_lora.py --input "%INPUT_PATH%" --output "%OUTPUT_PATH%" --target %TARGET%

echo Conversão concluída.

) else (

echo Operação cancelada.

)

REM Retorne ao início para outro arquivo

goto START

:END

REM Mantenha a janela aberta

echo Saindo do script.

pause

Como os arquivos .BAT anteriores, salve o script como ‘Todos os arquivos’ do Bloco de Notas, nomeando-o como convert.bat (ou qualquer nome que você goste).

Uma vez salvo, clique duas vezes no novo arquivo .BAT, que perguntará a localização de um arquivo para converter.

Cole ou digite o caminho para o arquivo treinado que você deseja converter, clique em s e pressione Enter.

Depois de salvar o LoRA convertido na pasta CONVERTED, o script perguntará se você deseja converter outro arquivo. Se você deseja testar vários pontos de verificação no ComfyUI, converta uma seleção de modelos.

Quando você tiver convertido pontos de verificação suficientes, feche a janela do prompt de comando do arquivo .BAT.

Agora você pode copiar seus modelos convertidos para a pasta models\loras na instalação do ComfyUI.

Normalmente, o local correto é algo como:

C:\Users\[Seu Nome de Perfil]\Desktop\ComfyUI\models\loras\

Criando LoRAs de Vídeo Hunyuan no ComfyUI

Embora os fluxos de trabalho baseados em node do ComfyUI pareçam complexos inicialmente, as configurações de outros usuários mais experientes podem ser carregadas arrastando uma imagem (feita com as configurações do outro usuário do ComfyUI) diretamente para a janela do ComfyUI. Fluxos de trabalho também podem ser exportados como arquivos JSON, que podem ser importados manualmente ou arrastados para uma janela do ComfyUI.

Alguns fluxos de trabalho importados podem ter dependências que podem não existir em sua instalação. Portanto, instale o ComfyUI-Manager, que pode buscar módulos ausentes automaticamente.

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

Para carregar um dos fluxos de trabalho usados para gerar vídeos a partir dos modelos neste tutorial, baixe este arquivo JSON e arraste-o para a janela do ComfyUI (embora haja muitos exemplos de fluxos de trabalho melhores disponíveis nas comunidades Reddit e Discord que adotaram o Hunyuan Video, e o meu é adaptado de um deles).

Isso não é o lugar para um tutorial estendido sobre o uso do ComfyUI, mas vale a pena mencionar alguns dos parâmetros cruciais que afetarão a saída se você baixar e usar o layout JSON que eu vinculei acima.

1) Largura e Altura

Quanto maior a imagem, mais tempo a geração levará e maior o risco de um erro de falta de memória (OOM).

2) Comprimento

Isso é o valor numérico para o número de frames. Quanto tempo isso soma depende da taxa de frames (definida como 30fps neste layout). Você pode converter segundos>quadros com base na taxa de frames no Omnicalculator.

3) Tamanho do Lote

Quanto mais alto você definir o tamanho do lote, mais rápido o resultado pode vir, mas maior a carga de VRAM. Defina isso muito alto e você pode obter um erro de falta de memória.

4) Controle Após Geração

Isso controla a semente aleatória. As opções para esse nó são fixo, incrementar, decrementar e aleatorizar. Se você deixar como fixo e não alterar o prompt de texto, você obterá a mesma imagem todas as vezes. Se você alterar o prompt de texto, a imagem mudará em uma extensão limitada. As configurações incrementar e decrementar permitem que você explore valores de semente próximos, enquanto aleatorizar fornece uma interpretação completamente nova do prompt.

5) Nome do LoRA

Você precisará selecionar seu próprio modelo instalado aqui antes de tentar gerar.

6) Token

Se você treinou seu modelo para acionar o conceito com um token (como ‘example-person’), coloque a palavra de gatilho nesse prompt.

7) Passos

Isso representa quantos passos o sistema aplicará ao processo de difusão. Passos mais altos podem obter melhores detalhes, mas há um teto na eficácia dessa abordagem, e esse limiar pode ser difícil de encontrar. A faixa comum de passos é de 20-30.

8) Tamanho do Azulejo

Isso define quantas informações são tratadas de uma vez durante a geração. Ele é definido como 256 por padrão. Aumentar isso pode acelerar a geração, mas aumentá-lo demais pode levar a uma experiência de falta de memória particularmente frustrante, pois ela vem no final de um longo processo.

9) Sobreposição Temporal

A geração de vídeo Hunyuan de pessoas pode levar a ‘ghosting’ ou movimento não convincente se isso for definido muito baixo. Em geral, a sabedoria atual é que isso deve ser definido como um valor mais alto do que o número de frames, para produzir melhor movimento.

Conclusão

Embora a exploração adicional do uso do ComfyUI esteja além do escopo deste artigo, a experiência comunitária no Reddit e nos Discords pode facilitar a curva de aprendizado, e há várias guias online que introduzem os conceitos básicos.

Publicado pela primeira vez na quinta-feira, 23 de janeiro de 2025