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 fundo de vídeo Hunyuan:

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

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

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

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

Portanto, esta execução se concentrará no Musubi Tuner e na provisão de uma solução completamente local para o treinamento e geração de LoRA de 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 12GB de VRAM (embora 16GB sejam recomendados). A instalação usada para este artigo foi testada em uma máquina com 64GB de RAM do sistema e uma placa gráfica NVIDIA 3090 com 24GB de VRAM. Foi testado em um sistema de teste dedicado com uma instalação fresca do Windows 10 Professional, em uma partição com 600+GB de espaço de disco livre.

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 os estágios finais, este projeto exigirá cerca de 400-500 gigabytes de espaço de 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. Aconselho a fazer um backup de todos os dados importantes antes de tentar essa instalação.

CONSIDERAÇÕES

Este Método Ainda é Válido?

A cena de IA gerativa está se movendo muito rapidamente, e podemos esperar métodos melhores e mais otimizados para os 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. Na época em que escrevo, ele foi lançado há apenas cinco dias, e não encontrei nenhuma conta de alguém que o tenha usado com sucesso.

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

Com base nas instruções de instalação atuais, a nova GUI é clonada diretamente no ambiente virtual existente do Musubi; e, apesar de muitos esforços, não consigo fazê-la se associar à instalação do Musubi existente. Isso significa que, quando ela é executada, ela descobrirá 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.

Dadas essas questões (também relacionadas a caminhos padrão no momento da instalação e ao uso do pacote UV Python, 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 pode esperar e está 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 em Metal Nu?

(Pule este parágrafo se você não é 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 do Windows para o 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.

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

2: Instale o Visual Studio 2022

Baixe a edição Comunity 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 longa e pesada. Na página inicial de Workloads que é aberta, 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 (este 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 Ferramentas C++ CMake para Windows está marcado.

Esta 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 de tela cheia do Visual Studio for finalmente 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, baixe também a edição Comunity gratuita do Visual Studio 19, seja da Microsoft (https://visualstudio.microsoft.com/vs/older-downloads/ – conta necessária) ou 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 for concluída e você tiver aberto e fechado o aplicativo 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: Não foi possível encontrar arquivos para os padrões fornecidos(s), consulte a seção Verificar Caminhos deste artigo abaixo e use essas instruções para adicionar os caminhos relevantes do Visual Studio às variáveis de 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 diferentes versões da 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 da NVIDIA CUDA procuram e se integram a qualquer instalação existente 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 atender a isso manualmente mais tarde.

Instale a Ferramenta CUDA V11+

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

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

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

Deixe Selecionar Local de Instalação com os valores padrão (isso é importante):

Clique em Próximo e deixe a instalação concluir.

Ignore quaisquer avisos ou notas que o instalador dê sobre Nsight Visual Studio integração, 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 caminhos de ambiente, que você pode ignorar:

Quando a instalação da versão 12+ da CUDA for 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 será responsável pela 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 ramo:

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

Use as configurações recomendadas para SSH:

Use as configurações recomendadas para HTTPS Transport backend:

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 (Fast-forward ou mesclar) para Git Pull:

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

Na Configurando Opções Extras, deixe Habilitar Cache de 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 teste se o GIT está instalado corretamente abrindo uma janela de comando e digitando e executando:

git --version

LOGIN DO 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 do 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 PATH esteja marcado.

Pressione 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 e deixe as configurações padrão:

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

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

python --version

Isso deve resultar em Python 3.10.0

VERIFICAR CAMINHOS

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

Portanto, precisamos abrir o ambiente do PATH e verificar se todos os 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, a janela de controle Propriedades do Sistema será aberta. No canto inferior direito de 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 da janela, role até Caminho e clique duas vezes nele. Isso abrirá uma janela chamada Editar variável de ambiente. Arraste a largura da 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ável de ambiente e colando o caminho correto:

Não copie e cole os caminhos listados acima; verifique se cada caminho equivalente existe na sua 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 (por exemplo, x64 em Host64 na sua instalação). Em seguida, cole esses caminhos na janela Editar variável 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 (ou seja, para serem executados como administrador). Se você receber mensagens de erro sobre permissões nas etapas subsequentes, feche a janela do prompt de comando e abra-a novamente no modo 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:

INSTALAR 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:

True

INSTALAR O TRITON PARA WINDOWS

Em seguida, a instalação do componente Triton para Windows. No Powershell elevado, digite (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, instalaremos qualquer software adicional em um ambiente virtual Python (ou venv). Isso significa que tudo o que você precisará fazer para desinstalar todos os softwares subsequentes é arrastar a pasta de instalação do venv para a lixeira.

Vamos criar a pasta de instalação: crie uma pasta chamada Musubi na sua á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 já instalamos (especialmente o Triton), então usaremos a flag --system-site-packages. Digite e execute isso:

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 musubi recém-criada (que está dentro da pasta Musubi na sua á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 até que o clone seja concluído (não levará muito tempo).

INSTALANDO OS REQUISITOS

Navegue até a pasta de instalação:

cd musubi-tuner

Digite e execute:

pip install -r requirements.txt

Aguarde até que as muitas instalações sejam concluídas (isso levará mais tempo).

AUTOMATIZAR O ACESSO AO VENV DE HUNYUAN VIDEO

Para facilitar o acesso e ativar o venv para sessões futuras, cole o seguinte em um Bloco de Notas e salve-o com o nome activate.bat, salvando-o com a opção 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

(Substitua [Seu Nome de Perfil] pelo nome real da sua pasta de perfil do Windows)

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

Daqui em diante, você pode dar um duplo clique em activate.bat e começar a trabalhar imediatamente.

USANDO O MUSUBI TUNER

BAIXANDO OS MODELOS

O processo de treinamento de LoRA de vídeo Hunyuan exige o download de pelo menos sete modelos para suportar todas as opções de pré-cache e treinamento de LoRA de vídeo Hunyuan. Juntos, esses modelos pesam mais de 60GB.

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 na época 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 os scripts posteriores, vamos colocá-los em:

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

Isso é consistente com o arranjo de diretórios até este ponto. Qualquer comando ou instrução a partir daqui suporá que este é o local dos modelos; e não se esqueça de substituir [Seu Nome de Perfil] pelo nome real da sua pasta de perfil 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 sua LoRA de Hunyuan. Resultados muito bons podem ser obtidos mesmo com 15 imagens, desde que as imagens sejam bem equilibradas e de boa qualidade.

Uma LoRA de Hunyuan pode ser treinada tanto em imagens quanto em clips de vídeo muito curtos e de baixa resolução, ou até mesmo em uma mistura de ambos – embora usar clips de vídeo como dados de treinamento seja desafiador, mesmo para um cartão de 24GB.

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

Exemplos incluiriam Roger Rabbit, um xenomorfo, A Máscara, Homem-Aranha ou outras personalidades que possuem características de movimento únicas.

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

PREPARAÇÃO DE IMAGENS

A LISTA DE ITENS

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, por exemplo, 10 imagens que sejam 512x768px e 10 que sejam 768x512px.

O treinamento pode correr bem mesmo se você não fizer isso – as LoRAs de Hunyuan Video podem ser surpreendentemente indulgentes.

A Versão Mais Longa

Como as LoRAs de Kohya-ss para sistemas gerativos estáticos, como o Stable Diffusion, bucketing é usado para distribuir a carga de trabalho por imagens de tamanhos diferentes, permitindo que imagens maiores sejam usadas sem causar erros de falta de memória no momento do treinamento (ou seja, 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 (por exemplo, 512x768px), um bucket ou ‘sub-tarefa’ será criado para esse tamanho. Portanto, se você tiver a seguinte distribuição de imagens, a atenção do bucket se torna desequilibrada e arrisca que algumas fotos sejam dadas maior consideração 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.

Evite imagens muito grandes, pois isso provavelmente retardará o treinamento, com benefício negligenciável.

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

Aviso de Responsabilidade: O modelo (pessoa) usado no conjunto de dados me deu permissão total para usar essas imagens para este propósito e aprovou todos os resultados de IA que representam sua semelhança apresentados neste artigo.

Meu conjunto de dados consiste em 40 imagens, no formato PNG (embora o JPG também seja aceitável). 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

Os processos de treinamento e pré-cache de LoRAs 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 arquivo TOML está localizado em C:\Users\Martin\Desktop\DATASETS_HUNYUAN\training.toml

O conteúdo do meu arquivo TOML de treinamento parece assim:

[geral]

resolução = [512, 768]

extensão_legenda = ".txt"

tamanho_lote = 1

habilitar_bucket = true

bucket_no_upscale = false

[[conjuntos_de_dados]]

diretório_de_imagem = "C:\\Users\\Martin\\Desktop\\DATASETS_HUNYUAN\\examplewoman"

diretório_de_cache = "C:\\Users\\Martin\\Desktop\\DATASETS_HUNYUAN\\examplewoman\\cache"

repetições = 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 usaram barras para a frente e barras para trás)

Podemos ver na seção resolução 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 fundo 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 a simplicidade e usar o sistema taggui. Embora esteja armazenado no GitHub e embora baixe alguns modelos de aprendizado de máquina pesados na primeira execução, ele vem na forma de um executável do Windows simples que carrega bibliotecas Python e uma interface de 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 iniciado – 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 Auto-Legendagem à direita:

Você verá o Taggui baixando modelos na pequena janela CLI à direita, mas apenas se for a primeira vez que você o executou. 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 desta execução.

Feche o Taggui e vamos prosseguir…

PRÉ-CACHE 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é-cache latente, copie o seguinte texto em um Bloco de Notas e salve-o como um arquivo.BAT (por exemplo, nomeie-o como latent-precache.bat), como anteriormente, garantindo que o tipo de arquivo na caixa de 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 CAMINHO_DE_IMAGEM=Digite o caminho para o diretório de imagem:

set /p CAMINHO_DE_CACHE=Digite o caminho para o diretório de cache:

set /p CAMINHO_DO_TOML=Digite o caminho para o arquivo TOML:

echo Você digitou:

echo Caminho da imagem: %CAMINHO_DE_IMAGEM%

echo Caminho do cache: %CAMINHO_DE_CACHE%

echo Caminho do arquivo TOML: %CAMINHO_DO_TOML%

set /p CONFIRMAÇÃO=Deseja prosseguir com o pré-cache latente (s/n)?

if /i "%CONFIRMAÇÃO%"=="s" (

REM Execute o script de pré-cache latente

python C:\Users\[Seu Nome de Perfil]\Desktop\Musubi\musubi\musubi-tuner\cache_latents.py --dataset_config %CAMINHO_DO_TOML% --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

(Substitua [Seu Nome de Perfil] pelo nome real da sua pasta de perfil do Windows)

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

Quando solicitado pelo arquivo.BAT, cole ou digite o caminho para o conjunto de dados, pastas de cache e arquivo TOML.

PRÉ-CACHE DE TEXTO

Vamos criar um segundo arquivo.BAT, desta vez para o pré-cache 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 CAMINHO_DE_IMAGEM=Digite o caminho para o diretório de imagem:

set /p CAMINHO_DE_CACHE=Digite o caminho para o diretório de cache:

set /p CAMINHO_DO_TOML=Digite o caminho para o arquivo TOML:

echo Você digitou:

echo Caminho da imagem: %CAMINHO_DE_IMAGEM%

echo Caminho do cache: %CAMINHO_DE_CACHE%

echo Caminho do arquivo TOML: %CAMINHO_DO_TOML%

set /p CONFIRMAÇÃO=Deseja prosseguir com o pré-cache de saída do codificador de texto (s/n)?

if /i "%CONFIRMAÇÃO%"=="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 %CAMINHO_DO_TOML% --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 seu nome de perfil do Windows e salve este como text-cache.bat (ou qualquer nome que você goste).

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

TREINANDO O LORA DE VÍDEO HUNYUAN

O treinamento real da LoRA 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 do 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.

Vamos minimizar as escolhas um pouco e treinar uma LoRA em configurações ‘medianas’.

Vamos criar um terceiro arquivo.BAT, desta vez para iniciar o treinamento. Cole o seguinte em um 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 CONFIGURAÇÃO_DO_CONJUNTO_DE_DADOS=Digite o caminho para o arquivo de configuração do conjunto de dados:

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

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

set /p TAXA_DE_APREDIZADO=Escolha a taxa de aprendizado (1 para 1e-3, 2 para 5e-3, padrão 1e-3):

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

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

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

set /p PASSOS_PARA_SALVAR=Quão frequentemente (em passos) salvar imagens de visualização:

set /p PROMPTOS_DE_TEXTO=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: %CONFIGURAÇÃO_DO_CONJUNTO_DE_DADOS%

echo Número de épocas: %ÉPOCAS%

echo Nome de saída: %NOME_DE_SAÍDA%

echo Taxa de aprendizado: %LR%

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

echo Arquivo de prompt de texto: %PROMPTOS_DE_TEXTO%

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 %CONFIGURAÇÃO_DO_CONJUNTO_DE_DADOS% ^

--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 %ÉPOCAS% ^

--save_every_n_epochs=1 ^

--seed 42 ^

--output_dir "C:\Users\[Seu Nome de Perfil]\Desktop\Musubi\Output Models" ^

--output_name %NOME_DE_SAÍDA% ^

--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 %PROMPTOS_DE_TEXTO% ^

--sample_every_n_steps %PASSOS_PARA_SALVAR% ^

--sample_at_first

echo O seguinte comando será executado:

echo %CMD%

set /p CONFIRMAÇÃO=Deseja prosseguir com o treinamento (s/n)?

if /i "%CONFIRMAÇÃO%"=="s" (

%CMD%

) else (

echo Operação cancelada.

)

REM Mantenha a janela aberta

cmd /k

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

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.

TREINAMENTO DE VISUALIZAÇÕES

Há um recurso de visualização de treinamento muito básico habilitado recentemente para o Musubi Trainer, que permite forçar o modelo de treinamento a pausar e gerar imagens com base em prompts que você salvou. Essas são salvas em uma pasta automaticamente criada chamada Sample, no mesmo diretório em 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 perguntará 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á com três imagens diferentes quando solicitado pelo rotina de treinamento:

Como você pode ver no exemplo acima, você pode colocar flags 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, com padrão de 20.

Consulte a documentação oficial para flags 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, portanto economizando tempo, lembre-se de que cada prompt extra desacelera o treinamento um pouco mais.

Além disso, a imagem de visualização de treinamento maior (definida pelas flags listadas acima) desacelera o treinamento.

Inicie o arquivo.BAT de treinamento.

Pergunta #1 é ‘Digite o caminho para o arquivo de configuração do conjunto de dados’. Cole ou digite o caminho correto para o seu 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 das 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). Este é um bom lugar para começar, pendente de mais experiência.

Pergunta #5 é ‘Quão frequentemente (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 seu arquivo de prompts de texto.

O arquivo.BAT então mostra a você o comando que ele enviará ao Modelo de Hunyuan e pergunta 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á consumindo cerca de 16GB 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 nesses 16GB para o benefício daqueles que possuem essas placas.

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

Durante o treinamento, você verá no lado inferior direito da janela do CMD uma figura para o tempo decorrido desde o início do treinamento e uma estimativa do tempo total de treinamento (que variará muito dependendo das flags definidas, 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 flag 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 mais ou menos frequentemente, como desejado, alterando o número --save_every_n_epochs [N] no arquivo.BAT de treinamento. Se você adicionou um número baixo 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 nó 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 este 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

:INÍCIO

REM Obtenha a entrada do usuário

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

REM Sair se o usuário digitar "sair"

if /i "%CAMINHO_DE_ENTRADA%"=="sair" goto FIM

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

for %%F in ("%CAMINHO_DE_ENTRADA%") do set NOME_DO_ARQUIVO=%%~nF

set CAMINHO_DE_SAÍDA=C:\Users\[Seu Nome de Perfil]\Desktop\Musubi\Output Models\CONVERTED\%NOME_DO_ARQUIVO%_converted.safetensors

set ALVO=other

echo Você digitou:

echo Arquivo de entrada: %CAMINHO_DE_ENTRADA%

echo Arquivo de saída: %CAMINHO_DE_SAÍDA%

echo Formato de saída: %ALVO%

set /p CONFIRMAÇÃO=Deseja prosseguir com a conversão (s/n)?

if /i "%CONFIRMAÇÃO%"=="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 "%CAMINHO_DE_ENTRADA%" --output "%CAMINHO_DE_SAÍDA%" --target %ALVO%

echo Conversão concluída.

) else (

echo Operação cancelada.

)

REM Retorne ao início para outro arquivo

goto INÍCIO

:FIM

REM Mantenha a janela aberta

echo Saindo do script.

pause

Como nos 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, dê um duplo clique no novo arquivo.BAT, que perguntará a localização de um arquivo para converter.

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

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

Quando você tiver convertido modelos suficientes, feche a janela do comando.BAT.

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

Normalmente, a localização correta é 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 nós 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 ComfyUI de outro usuário) 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 não existam na 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 várias comunidades do 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

Este é 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>frames com base na taxa de frames no Omnicalculator.

3) TAMANHO DO LOTE

Quanto maior 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 (OOM).

4) CONTROLE APÓS GERAR

Isso controla a semente aleatória. As opções para esse nó são fixo, incrementar, decrementar e randomizar. Se você deixá-lo como fixo e não alterar o prompt de texto, você obterá a mesma imagem a cada vez. 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 randomizar lhe dará uma interpretação completamente nova do prompt.

5) NOME DA LoRA

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

6) TOKEN

Se você treinou seu modelo para acionar o conceito com um token (por exemplo, ‘example-person’), coloque essa palavra de gatilho no seu prompt.

7) PASSOS

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

8) TAMANHO DA PASTA

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 (OOM) 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 mais aprofundada do uso do ComfyUI esteja além do escopo deste artigo, a experiência da comunidade no Reddit e Discord pode facilitar a curva de aprendizado, e há vários guias online que introduzem os conceitos básicos.

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