Este repositório contém definições de modelo PyTorch, pesos pré-treinados e código de inferência/amostragem para nosso artigo que explora Hunyuan-DiT. Você pode encontrar mais visualizações em nossa página do projeto.
Hunyuan-DiT: um poderoso transformador de difusão multi-resolução com compreensão refinada do chinês
DialogGen: Sistema de diálogo interativo multimodal para geração de texto em imagem em múltiplas voltas
15 de julho de 2024: HunYuanDiT e Shakker.Ai lançaram em conjunto um evento de ajuste fino baseado no modelo HunYuanDiT 1.2. Ao publicar um lora ou modelo ajustado baseado em HunYuanDiT, você pode ganhar um bônus de até $ 230 do Shakker.Ai. Consulte Shakker.Ai para obter mais detalhes.
15 de julho de 2024: ? Atualize o ComfyUI para suportar fluxos de trabalho padronizados e compatibilidade com pesos do módulo t2i e treinamento Lora para versões 1.1/1.2, bem como aqueles treinados por Kohya ou pelo script oficial. Consulte ComfyUI para obter detalhes.
15 de julho de 2024: ⚡ Oferecemos ambientes Docker para CUDA 11/12, permitindo que você ignore instalações complexas e jogue com um único clique! Consulte as janelas de encaixe para obter detalhes.
08 de julho de 2024: ? A versão HYDiT-v1.2 é lançada. Por favor, verifique HunyuanDiT-v1.2 e Distillation-v1.2 para mais detalhes.
03 de julho de 2024: ? Versão Kohya-hydit agora disponível para modelos v1.1 e v1.2, com GUI para inferência. A versão oficial do Kohya está em revisão. Veja kohya para detalhes.
27 de junho de 2024: ? Hunyuan-Captioner é lançado, fornecendo legendas refinadas para dados de treinamento. Consulte mllm para obter detalhes.
27 de junho de 2024: ? Suporte LoRa e ControlNet em difusores. Veja difusores para detalhes.
27 de junho de 2024: ? Scripts de inferência VRAM de GPU de 6 GB são lançados. Consulte Lite para obter detalhes.
19 de junho de 2024: ? ControlNet é lançado, suportando controle astuto, pose e profundidade. Consulte códigos de treinamento/inferência para obter detalhes.
13 de junho de 2024: ⚡ A versão HYDiT-v1.1 é lançada, o que atenua o problema de supersaturação da imagem e alivia o problema da marca d’água. Por favor, verifique HunyuanDiT-v1.1 e Distillation-v1.1 para mais detalhes.
13 de junho de 2024: ? O código de treinamento é lançado, oferecendo treinamento de parâmetros completos e treinamento LoRA.
06 de junho de 2024: ? Hunyuan-DiT agora está disponível no ComfyUI. Por favor, verifique ComfyUI para mais detalhes.
06 de junho de 2024: Apresentamos a versão Destilação para aceleração Hunyuan-DiT, que atinge 50% de aceleração em GPUs NVIDIA. Por favor, verifique Destilação para mais detalhes.
05 de junho de 2024: ? Hunyuan-DiT agora está disponível em ? Difusores! Por favor, verifique o exemplo abaixo.
04 de junho de 2024: Apoie os links do Tencent Cloud para baixar os modelos pré-treinados! Por favor, verifique os links abaixo.
22 de maio de 2024: Apresentamos a versão TensorRT para aceleração Hunyuan-DiT, que atinge 47% de aceleração em GPUs NVIDIA. Verifique as bibliotecas do TensorRT para obter instruções.
22 de maio de 2024: Agora oferecemos suporte à demonstração executando a geração text2image multivoltas. Por favor, verifique o script abaixo.
Bem-vindo ao nosso Tencent Hunyuan Bot baseado na web, onde você pode explorar nossos produtos inovadores! Basta inserir as instruções sugeridas abaixo ou quaisquer outras instruções criativas contendo palavras-chave relacionadas a desenhos para ativar o recurso de geração de texto para imagem Hunyuan. Liberte a sua criatividade e crie qualquer imagem que desejar, tudo de graça!
Você pode usar prompts simples semelhantes ao texto em linguagem natural
画一只穿着西装的猪
desenhe um porco de terno
生成一幅画,赛博朋克风,跑车
gerar uma pintura, estilo cyberpunk, carro esportivo
ou interações linguísticas multivoltas para criar a imagem.
画一个木制的鸟
desenhe um pássaro de madeira
变成玻璃的
transformar em vidro
Hunyuan-DiT (modelo de texto para imagem)
Inferência
Pontos de verificação
Versão de destilação
Versão TensorRT
Treinamento
Lora
Controlnet (Pose, Canny, Profundidade)
Inferência VRAM de GPU de 6 GB
Adaptador IP
Pontos de verificação Hunyuan-DiT-S (modelo 0.7B)
Mllm
Inferência
Inferência
Hunyuan-Captioner (relegenda novamente os pares imagem-texto brutos)
Hunyuan-DialogGen (modelo de aprimoramento de prompt)
Demonstração da Web (Grádio)
Demonstração T2I multivoltas (Gradio)
Demonstração Cli
UI confortável
Difusores
Kohya
UI da Web
Hunyuan-DiT: um poderoso transformador de difusão multi-resolução com compreensão refinada do chinês
Exemplos
Instruções
Inferência
Gradio
ControlNet
Inferência VRAM de GPU de 6 GB
Usando Gradio
Usando ? Difusores
Usando linha de comando
Mais configurações
Usando ComfyUI
Usando Kohya
Usando versões anteriores
Preparação de Dados
Treinamento com parâmetros completos
LoRA
Guia de instalação para Linux
Arquitetura DiT bilíngue chinês-inglês
Geração Text2Image multivoltas
Notícias!!
Experimente na web
Plano de código aberto
Conteúdo
Resumo
Principais recursos do Hunyuan-DiT
Comparações
Visualização
Requisitos
Dependências e Instalação
Baixe modelos pré-treinados - 1. Usando HF-Mirror - 2. Retome o download
Treinamento
Inferência
Adaptador
Hunyuan-Captioner
Aceleração (para Linux)
BibTeX
Iniciar histórico
Apresentamos Hunyuan-DiT, um transformador de difusão de texto para imagem com compreensão refinada de inglês e chinês. Para construir o Hunyuan-DiT, projetamos cuidadosamente a estrutura do transformador, o codificador de texto e a codificação posicional. Também construímos do zero um pipeline de dados completo para atualizar e avaliar dados para otimização de modelo iterativo. Para uma compreensão refinada da linguagem, treinamos um modelo multimodal de linguagem grande para refinar as legendas das imagens. Finalmente, Hunyuan-DiT pode realizar diálogos multimodais com os usuários, gerando e refinando imagens de acordo com o contexto. Através de nosso protocolo de avaliação humana holística cuidadosamente projetado com mais de 50 avaliadores humanos profissionais, Hunyuan-DiT estabelece um novo estado da arte na geração de imagem chinesa em comparação com outros modelos de código aberto.
Hunyuan-DiT é um modelo de difusão no espaço latente, conforme mostrado na figura abaixo. Seguindo o Modelo de Difusão Latente, usamos um Autoencoder Variacional (VAE) pré-treinado para compactar as imagens em espaços latentes de baixa dimensão e treinar um modelo de difusão para aprender a distribuição de dados com modelos de difusão. Nosso modelo de difusão é parametrizado com um transformador. Para codificar os prompts de texto, utilizamos uma combinação de CLIP bilíngue pré-treinado (inglês e chinês) e codificador T5 multilíngue.
Compreender as instruções em linguagem natural e realizar interações múltiplas com os usuários são importantes para um sistema de texto para imagem. Pode ajudar a construir um processo de criação dinâmico e iterativo que transforma a ideia do usuário em realidade, passo a passo. Nesta seção, detalharemos como capacitamos Hunyuan-DiT com a capacidade de realizar conversas em várias rodadas e geração de imagens. Treinamos o MLLM para entender o diálogo do usuário em várias rodadas e gerar o novo prompt de texto para geração de imagem.
A fim de comparar de forma abrangente as capacidades de geração do HunyuanDiT e de outros modelos, construímos um conjunto de testes quadridimensional, incluindo consistência de texto-imagem, exclusão de artefatos de IA, clareza de assunto e estética. Mais de 50 avaliadores profissionais realizam a avaliação.
| Modelo | Código aberto | Consistência Texto-Imagem (%) | Excluindo artefatos de IA (%) | Clareza do Assunto (%) | Estética (%) | Geral (%) | ||||
|---|---|---|---|---|---|---|---|---|---|---|
| SDXL | ✔ | 64,3 | 60,6 | 91,1 | 76,3 | 42,7 | ||||
| PixArt-α | ✔ | 68,3 | 60,9 | 93,2 | 77,5 | 45,5 | ||||
| Parque 2.5 | ✔ | 71,9 | 70,8 | 94,9 | 83,3 | 54,3 | ||||
| SD3 | ✘ | 77,1 | 69,3 | 94,6 | 82,5 | 56,7 | ||||
| Meio da jornada v6 | ✘ | 73,5 | 80,2 | 93,5 | 87,2 | 63,3 | ||||
| DALL-E 3 | ✘ | 83,9 | 80,3 | 96,5 | 89,4 | 71,0 | ||||
| Hunyuan-DiT | ✔ | 74,2 | 74,3 | 95,4 | 86,6 | 59,0 |
Elementos Chineses
Entrada de texto longo
Geração Text2Image multivoltas
Este repositório consiste em DialogGen (um modelo de aprimoramento imediato) e Hunyuan-DiT (um modelo de texto para imagem).
A tabela a seguir mostra os requisitos para execução dos modelos (tamanho do lote = 1):
| Modelo | --load-4bit (DialogGen) | Memória de pico da GPU | GPU |
|---|---|---|---|
| DialogGen + Hunyuan-DiT | ✘ | 32G | A100 |
| DialogGen + Hunyuan-DiT | ✔ | 22G | A100 |
| Hunyuan-DiT | - | 11G | A100 |
| Hunyuan-DiT | - | 14G | RTX3090/RTX4090 |
É necessária uma GPU NVIDIA com suporte CUDA.
Testamos GPUs V100 e A100.
Mínimo : A memória GPU mínima necessária é 11 GB.
Recomendado : Recomendamos usar uma GPU com 32GB de memória para melhor qualidade de geração.
Sistema operacional testado: Linux
Comece clonando o repositório:
clone git https://github.com/tencent/HunyuanDiTcd HunyuanDiT
Fornecemos um arquivo environment.yml para configurar um ambiente Conda. As instruções de instalação do Conda estão disponíveis aqui.
Recomendamos as versões 11.7 e 12.0+ do CUDA.
# 1. Prepare o ambiente condaconda env create -f ambiente.yml# 2. Ative o ambienteconda activate HunyuanDiT# 3. Instale pip dependenciespython -m pip install -r requisitos.txt# 4. Instale o flash Attention v2 para aceleração (requer CUDA 11.6 ou acima)python -m pip install git+https://github.com/Dao-AILab/[email protected]
Além disso, você também pode usar o docker para configurar o ambiente.
# 1. Use o link a seguir para baixar o arquivo tar da imagem docker.# Para CUDA 12wget https://dit.hunyuan.tencent.com/download/HunyuanDiT/hunyuan_dit_cu12.tar# Para CUDA 11wget https://dit.hunyuan. tencent.com/download/HunyuanDiT/hunyuan_dit_cu11.tar# 2. Importe o arquivo docker tar e mostre as meta informações da imagem# Para CUDA 12docker load -i hunyuan_dit_cu12.tar# Para CUDA 11docker load -i hunyuan_dit_cu11.tar docker image ls# 3. Execute o contêiner com base no imagedocker run -dit --gpus all --init --net=host --uts=host --ipc=host --name hunyuandit --security-opt=seccomp= não confinado --ulimit=stack=67108864 --ulimit=memlock=-1 --privileged docker_image_tag
Para baixar o modelo, primeiro instale o huggingface-cli. (Instruções detalhadas estão disponíveis aqui.)
python -m pip instalar "huggingface_hub[cli]"
Em seguida, baixe o modelo usando os seguintes comandos:
# Crie um diretório chamado 'ckpts' onde o modelo será salvo, atendendo aos pré-requisitos para execução do demo.mkdir ckpts# Utilize a ferramenta huggingface-cli para baixar o modelo.# O tempo de download pode variar de 10 minutos a 1 hora dependendo nas condições de rede.huggingface-cli baixe Tencent-Hunyuan/HunyuanDiT-v1.2 --local-dir ./ckpts
Se você encontrar velocidades de download lentas na China, você pode tentar um espelho para acelerar o processo de download. Por exemplo,
HF_ENDPOINT=https://hf-mirror.com huggingface-cli baixar Tencent-Hunyuan/HunyuanDiT-v1.2 --local-dir ./ckpts
huggingface-cli suporta a retomada de downloads. Se o download for interrompido, basta executar novamente o comando de download para retomar o processo de download.
Nota: Se um erro semelhante No such file or directory: 'ckpts/.huggingface/.gitignore.lock' ocorrer durante o processo de download, você pode ignorar o erro e executar novamente o comando de download.
Todos os modelos serão baixados automaticamente. Para mais informações sobre o modelo, visite o repositório Hugging Face aqui.
| Modelo | #Params | URL de download do Hugging Face | URL de download da nuvem Tencent |
|---|---|---|---|
| mT5 | 1,6B | mT5 | mT5 |
| GRAMPO | 350 milhões | GRAMPO | GRAMPO |
| Tokenizador | - | Tokenizador | Tokenizador |
| DialogGen | 7,0B | DialogGen | DialogGen |
| sdxl-vae-fp16-fix | 83 milhões | sdxl-vae-fp16-fix | sdxl-vae-fp16-fix |
| Hunyuan-DiT-v1.0 | 1,5B | Hunyuan-DiT | Hunyuan-DiT-v1.0 |
| Hunyuan-DiT-v1.1 | 1,5B | Hunyuan-DiT-v1.1 | Hunyuan-DiT-v1.1 |
| Hunyuan-DiT-v1.2 | 1,5B | Hunyuan-DiT-v1.2 | Hunyuan-DiT-v1.2 |
| Demonstração de dados | - | - | Demonstração de dados |
Consulte os comandos abaixo para preparar os dados de treinamento.
Instalar dependências
Oferecemos uma biblioteca eficiente de gerenciamento de dados, chamada IndexKits, que suporta o gerenciamento de leitura de centenas de milhões de dados durante o treinamento, veja mais na documentação.
#1 Instalar dependênciascd HunyuanDiT pip instalar -e ./IndexKits
Download de dados
Sinta-se à vontade para baixar a demonstração de dados.
# 2 Download de dadoswget -O ./dataset/data_demo.zip https://dit.hunyuan.tencent.com/download/HunyuanDiT/data_demo.zip descompacte ./dataset/data_demo.zip -d ./dataset mkdir ./dataset/porcelain/arrows ./dataset/porcelain/jsons
Conversão de dados
Crie um arquivo CSV para dados de treinamento com os campos listados na tabela abaixo.
| Campos | Obrigatório | Descrição | Exemplo |
|---|---|---|---|
image_path | Obrigatório | caminho da imagem | ./dataset/porcelain/images/0.png |
text_zh | Obrigatório | texto | 青花瓷风格，一只蓝色的鸟儿站在蓝色的花瓶上，周围点缀着白色花朵，背景是白色 |
md5 | Opcional | imagem md5 (algoritmo de resumo de mensagem 5) | d41d8cd98f00b204e9800998ecf8427e |
width | Opcional | largura da imagem | 1024 |
height | Opcional | altura da imagem | 1024 |
️ Campos opcionais como MD5, largura e altura podem ser omitidos. Se omitido, o script abaixo irá calculá-los automaticamente. Este processo pode ser demorado ao lidar com dados de treinamento em grande escala.
Utilizamos Arrow para formato de dados de treinamento, oferecendo uma representação de dados na memória padrão e eficiente. Um script de conversão é fornecido para transformar arquivos CSV no formato Arrow.
# 3 Conversão de dados python ./hydit/data_loader/csv2arrow.py ./dataset/porcelain/csvfile/image_text.csv ./dataset/porcelain/arrows 1
Seleção de dados e criação de arquivo de configuração
Configuramos os dados de treinamento por meio de arquivos YAML. Nesses arquivos, você pode configurar estratégias de processamento de dados padrão para filtragem, cópia, desduplicação e muito mais em relação aos dados de treinamento. Para obter mais detalhes, consulte ./IndexKits.
Para obter um arquivo de amostra, consulte arquivo. Para obter um arquivo completo de configuração de parâmetros, consulte arquivo.
Crie um arquivo de índice de dados de treinamento usando o arquivo YAML.
# Preparação de dados de resolução única
idk base -c dataset/yamls/porcelain.yaml -t dataset/porcelain/jsons/porcelain.json # Preparação de dados de resolução múltipla
idk multireso -c dataset/yamls/porcelain_mt.yaml -t dataset/porcelain/jsons/porcelain_mt.json A estrutura de diretórios do conjunto de dados porcelain é:
cd./conjunto de dados
porcelana
├──imagens/ (arquivos de imagem)
│ ├──0.png
│ ├──1.png
│ ├──......
├──csvfile/ (arquivos csv contendo pares texto-imagem)
│ ├──image_text.csv
├──arrows/ (arquivos de seta contendo todos os dados de treinamento necessários)
│ ├──00000.seta
│ ├──00001.seta
│ ├──......
├──jsons/ (arquivos de índice de dados de treinamento finais que leem dados de arquivos de seta durante o treinamento)
│ ├──porcelana.json
│ ├──porcelain_mt.jsonExigência:
O requisito mínimo é uma única GPU com pelo menos 20 GB de memória, mas recomendamos usar uma GPU com cerca de 30 GB de memória para evitar o descarregamento da memória do host.
Além disso, incentivamos os usuários a aproveitar as múltiplas GPUs em diferentes nós para acelerar o treinamento em grandes conjuntos de dados.
Perceber:
Os usuários pessoais também podem usar o leve Kohya para ajustar o modelo com cerca de 16 GB de memória. Atualmente, estamos tentando reduzir ainda mais o uso de memória de nossa estrutura de nível industrial para usuários pessoais.
Se você tiver memória GPU suficiente, tente remover --cpu-offloading ou --gradient-checkpointing para obter menos tempo.
Especificamente para treinamento distribuído, você tem a flexibilidade de controlar o treinamento de nó único / vários nós ajustando parâmetros como --hostfile e --master_addr . Para mais detalhes, consulte o link.
# Treinamento de resolução únicaPYTHONPATH=./ sh hydit/train.sh --index-file dataset/porcelain/jsons/porcelain.json# Treinamento de resolução múltiplaPYTHONPATH=./ sh hydit/train.sh --index-file dataset/porcelain/jsons /porcelain_mt.json --multireso --reso-step 64# Treinamento com versão antiga do HunyuanDiT (<= v1.1)PYTHONPATH=./ sh hydit/train_v1.1.sh --index-file dataset/porcelain/jsons/ porcelana.json
Depois que os pontos de verificação forem salvos, você poderá usar o comando a seguir para avaliar o modelo.
# Inferência # Você deve substituir o 'log_EXP/xxx/checkpoints/final.pt' pelo seu caminho real.python sample_t2i.py --infer-mode fa --prompt "青花瓷风格，一只可爱的哈士奇" --no-enhance - -dit-weight log_EXP/xxx/checkpoints/final.pt --load-key module# Versão antiga do HunyuanDiT (<= v1.1)# Você deve substituir o 'log_EXP/xxx/checkpoints/final.pt' pelo seu valor real path.python sample_t2i.py --infer-mode fa --prompt "青花瓷风格，一只可爱的哈士奇" --model-root ./HunyuanDiT-v1.1 --use-style-cond --size-cond 1024 1024 --beta-end 0.03 --no-enhance --dit-weight log_EXP/xxx/checkpoints/final.pt --load-key module
Fornecemos scripts de treinamento e inferência para LoRA, detalhados em ./lora.
# Treinamento para porcelana LoRA.PYTHONPATH=./ sh lora/train_lora.sh --index-file dataset/porcelain/jsons/porcelain.json# Inferência usando pesos LORA treinados.python sample_t2i.py --infer-mode fa --prompt "青花瓷风格，一只小狗" --no-enhance --lora-ckpt log_EXP/001-lora_porcelain_ema_rank64/checkpoints/0001000.pt
Oferecemos dois tipos de pesos LoRA treinados para porcelain e jade , veja detalhes nos links
cd HunyuanDiT# Use a ferramenta huggingface-cli para baixar o model.huggingface-cli download Tencent-Hunyuan/HYDiT-LoRA --local-dir ./ckpts/t2i/lora# Quick startpython sample_t2i.py --infer-mode fa - -prompt "青花瓷风格，一只猫在追蝴蝶" --no-enhance --load-key ema --lora-ckpt ./ckpts/t2i/lora/porcelain
| Exemplos de dados de treinamento | |||
| 青花瓷风格，一只蓝色的鸟儿站在蓝色的花瓶上，周围点缀着白色花朵，背景是白色 （Estilo porcelana, um pássaro azul sobre um fundo azul vaso, rodeado de flores brancas, com fundo branco. ） | 青花瓷风格，这是一幅蓝白相间的陶瓷盘子，上面描绘着一只狐狸和它的幼崽在森林中漫步，背景是白色 （Em porcelana, este é um prato de cerâmica azul e branco representando uma raposa e seu filhotes passeando na floresta, com fundo branco.） | 青花瓷风格，在黑色背景上，一只蓝色的狼站在蓝白相间的盘子上，周围是树木和月亮 （Estilo porcelana, sobre fundo preto , um lobo azul está em uma placa azul e branca, cercado por árvores e a lua.） | 青花瓷风格，在蓝色背景上，一只蓝色蝴蝶和白色花朵被放置在中央 （Estilo porcelana, sobre fundo azul, uma borboleta azul e flores brancas são colocadas no centro.） |
| Exemplos de resultados de inferência | |||
| 青花瓷风格，苏州园林 （Estilo porcelana, Jardins de Suzhou.） | 青花瓷风格，一朵荷花 (Estilo porcelana, uma flor de lótus.) | 青花瓷风格，一只羊（Estilo porcelana, uma ovelha.） | 青花瓷风格，一个女孩在雨中跳舞（Estilo porcelana, uma garota dançando na chuva.） |
A execução do HunyuanDiT em GPU VRAM com menos de 6 GB já está disponível com base em difusores. Aqui fornecemos instruções e demonstração para seu início rápido.
A versão de 6 GB suporta placas gráficas da série de arquitetura Nvidia Ampere, como RTX 3070/3080/4080/4090, A100 e assim por diante.
A única coisa que você precisa fazer é instalar a seguinte biblioteca:
pip install -U bits e bytes pip instalar git + https://github.com/huggingface/diffusers pip instalar tocha ==2.0.0
Então você pode aproveitar sua jornada de texto para imagem HunyuanDiT diretamente com GPU VRAM de 6 GB!
Aqui está uma demonstração para você.
cd HunyuanDiT# Início rápidomodel_id=Tencent-Hunyuan/HunyuanDiT-v1.2-Diffusers-Distilled
prompt=一个宇航员在骑马
infer_steps=50
escala_orientação=6
python3 lite/inference.py ${model_id} ${prompt} ${infer_steps} ${guidance_scale}Mais detalhes podem ser encontrados em ./lite.
Certifique-se de que o ambiente conda esteja ativado antes de executar o comando a seguir.
# Por padrão, iniciamos uma UI chinesa. Usando Flash Attention para aceleration.python app/hydit_app.py --infer-mode fa# Você pode desabilitar o modelo de aprimoramento se a memória da GPU for insuficiente.# O aprimoramento ficará indisponível até que você reinicie o aplicativo sem o `--no- melhorar a bandeira. python app/hydit_app.py --no-enhance --infer-mode fa# Comece com UI em inglêspython app/hydit_app.py --lang en --infer-mode fa# Inicie uma UI de geração T2I multivoltas. # Se a memória da sua GPU for inferior a 32 GB, use '--load-4bit' para ativar a quantização de 4 bits, que requer pelo menos 22 GB de memória.python app/multiTurnT2I_app.py --infer-mode fa
Então a demonstração pode ser acessada através de http://0.0.0.0:443. Deve-se observar que 0.0.0.0 aqui precisa ser XXXX com o IP do seu servidor.
Instale o PyTorch versão 2.0 ou superior com antecedência para satisfazer os requisitos da versão especificada da biblioteca de difusores.
Instale os difusores, garantindo que a versão seja no mínimo 0.28.1:
pip instalar git + https://github.com/huggingface/diffusers.git
ou
pip instalar difusores
Você pode gerar imagens com prompts em chinês e inglês usando o seguinte script Python:
importar torchfrom difusores import HunyuanDiTPipelinepipe = HunyuanDiTPipeline.from_pretrained("Tencent-Hunyuan/HunyuanDiT-v1.2-Diffusers", torch_dtype=torch.float16)pipe.to("cuda")# Você também pode usar o prompt em inglês, pois HunyuanDiT suporta ambos em inglês e chinês# prompt = "Um astronauta andando a cavalo"prompt = "一个宇航员在骑马"image = pipe(prompt).images[0]Você pode usar nosso modelo destilado para gerar imagens ainda mais rápido:
importar tocha de difusores importar HunyuanDiTPipelinepipe = HunyuanDiTPipeline.from_pretrained("Tencent-Hunyuan/HunyuanDiT-v1.2-Diffusers-Distilled", torch_dtype=torch.float16)pipe.to("cuda")# Você também pode usar o prompt em inglês, pois o HunyuanDiT suporta inglês e chinês# prompt = "Um astronauta andando a cavalo"prompt = "一个宇航员在骑马"image = pipe(prompt, num_inference_steps=25).images[0]Mais detalhes podem ser encontrados em HunyuanDiT-v1.2-Diffusers-Distilled
Mais funções: Para outras funções como LoRA e ControlNet, dê uma olhada no README de ./diffusers.
Fornecemos vários comandos para início rápido:
# Somente texto para imagem. Flash Attention modepython sample_t2i.py --infer-mode fa --prompt "渔舟唱晚" --no-enhance# Gere uma imagem com outros tamanhos de imagem.python sample_t2i.py --infer-mode fa --prompt "渔舟唱晚" --image-size 1280 768# Aprimoramento de prompt + texto para imagem. O DialogGen carrega com quantização de 4 bits, mas pode perder desempenho.python sample_t2i.py --infer-mode fa --prompt "渔舟唱晚" --load-4bit
Mais exemplos de prompts podem ser encontrados em example_prompts.txt
Listamos algumas configurações mais úteis para facilitar o uso:
| Argumento | Padrão | Descrição |
|---|---|---|
--prompt | Nenhum | O prompt de texto para geração de imagem |
--image-size | 1024 1024 | O tamanho da imagem gerada |
--seed | 42 | A semente aleatória para gerar imagens |
--infer-steps | 100 | O número de etapas para amostragem |
--negative | - | O prompt negativo para geração de imagem |
--infer-mode | tocha | O modo de inferência (tocha, fa ou trt) |
--sampler | ddpm | O amostrador de difusão (ddpm, ddim ou dpmms) |
--no-enhance | Falso | Desative o modelo de aprimoramento de prompt |
--model-root | recibos | O diretório raiz dos pontos de verificação do modelo |
--load-key | ema | Carregue o modelo do aluno ou modelo EMA (ema ou módulo) |
--load-4bit | Fasle | Carregar modelo DialogGen com quantização de 4 bits |
Suporta dois fluxos de trabalho: Standard ComfyUI e Diffusers Wrapper, sendo o primeiro recomendado.
Suporte HunyuanDiT-v1.1 e v1.2.
Módulo de suporte, modelos lora e clip lora treinados por Kohya.
Módulo de suporte, modelos lora treinados pelos scripts de treinamento oficiais da HunyunDiT.
ControlNet estará disponível em breve.
Mais detalhes podem ser encontrados em ./comfyui-hydit
Oferecemos suporte a códigos personalizados para GUI kohya_ss e códigos de treinamento de scripts sd para HunyuanDiT. Mais detalhes podem ser encontrados em ./kohya_ss-hydit
Hunyuan-DiT <= v1.1
# ============================= v1.1 ================ ==============# Baixe o modelhuggingface-cli download Tencent-Hunyuan/HunyuanDiT-v1.1 --local-dir ./HunyuanDiT-v1.1# Inferência com o modelpython sample_t2i.py --infer-mode fa --prompt "渔舟唱晚" --model-root ./HunyuanDiT-v1.1 --use-style-cond --size-cond 1024 1024 --beta-end 0.03# === =========================== v1.0 ==================== ==========# Baixe o modelhuggingface-cli download Tencent-Hunyuan/HunyuanDiT --local-dir ./HunyuanDiT-v1.0# Inferência com o modelpython sample_t2i.py --infer-mode fa -- prompt "渔舟唱晚" --model-root ./HunyuanDiT-v1.0 --use-style-cond --size-cond 1024 1024 --beta-end 0.03
Fornecemos scripts de treinamento para ControlNet, detalhados em ./controlnet.
# Treinamento para o astuto ControlNet.PYTHONPATH=./sh hydit/train_controlnet.sh
Oferecemos três tipos de pesos ControlNet treinados para depth e pose canny , veja detalhes nos links
cd HunyuanDiT# Use a ferramenta huggingface-cli para baixar o modelo.# Recomendamos usar pesos destilados como modelo base para inferência ControlNet, já que nossos pesos pré-treinados fornecidos são treinados neles.huggingface-cli download Tencent-Hunyuan/HYDiT-ControlNet- v1.2 --local-dir ./ckpts/t2i/controlnet huggingface-cli download Tencent-Hunyuan/Distillation-v1.2 ./pytorch_model_distill.pt --local-dir ./ckpts/t2i/model# Início rápidopython3 sample_controlnet.py --infer-mode fa --no-enhance --load -key destilar --infer-steps 50 --control-type astuto --prompt "在夜晚的酒店门前，一座古老的中国风格的狮子雕像矗立着，它的眼睛闪烁着光芒, 仿佛在守护着这座建筑。背景是夜晚的酒店前，构图方式是特写，平视，居中构图。这张照片呈现了真实摄影风格，蕴含了中国雕塑文化,同时展现了神秘氛围" --condition-image-path controlnet/asset /input/canny.jpg --control-peso 1.0
| Entrada de condição | ||
| Canny ControlNet | Rede de controle de profundidade | Pose ControlNet |
| 在夜晚的酒店门前，一座古老的中国风格的狮子雕像矗立着，它的眼睛闪烁着光芒，仿佛在守护着这座建筑。背景是夜晚的酒店前，构图方式是特写，平视，居中构图。这张Photo se estiver guardando o prédio. O fundo é a entrada do hotel à noite, com composição em close, na altura dos olhos e centralizada. Esta foto apresenta um estilo fotográfico realista, incorpora a cultura da escultura chinesa e revela uma atmosfera misteriosa.） | 在茂密的森林中，一只黑白相间的熊猫静静地坐在绿树红花中，周围是山川和海洋。背景是白天的森林，光线充足。照片采用特写、平视和居中构图的方式，呈现出写实的效果（Na floresta densa, um panda preto e branco senta-se calmamente entre as árvores verdes e flores vermelhas, cercado por montanhas e oceanos. O fundo é uma floresta diurna com bastante luz. A foto usa uma composição em close, no nível dos olhos e centralizada para criar um efeito realista.） | 在白天的森林中, 一位穿着绿色上衣的亚洲女性站在大象旁边。照片采用了中景、平视和居中构图的方式，呈现出写实的效果。这张照片蕴含了人物摄影文化，并展现了宁静的氛围（Na floresta diurna, uma mulher asiática vestindo uma camisa verde está ao lado de um elefante. A foto usa uma composição média, no nível dos olhos e centralizada para criar um efeito realista. Esta imagem incorpora a cultura da fotografia de personagens e transmite uma atmosfera serena.） |
| Saída ControlNet | ||
Hunyuan-Captioner atende à necessidade de técnicas de texto para imagem, mantendo um alto grau de consistência imagem-texto. Ele pode gerar descrições de imagens de alta qualidade de vários ângulos, incluindo descrição de objetos, relacionamentos de objetos, informações de fundo, estilo de imagem, etc. Nosso código é baseado na implementação LLaVA.
um. Instalar dependências
As dependências e instalação são basicamente as mesmas do modelo base .
b. Baixar modelo
# Use a ferramenta huggingface-cli para baixar o model.huggingface-cli download Tencent-Hunyuan/HunyuanCaptioner --local-dir ./ckpts/captioner
Nosso modelo oferece suporte a três modos diferentes, incluindo: geração direta de legenda em chinês , geração de legenda em chinês com base em conhecimento específico e geração direta de legenda em inglês . As informações injetadas podem ser pistas precisas ou rótulos barulhentos (por exemplo, descrições brutas rastreadas da Internet). O modelo é capaz de gerar descrições confiáveis e precisas com base tanto nas informações inseridas quanto no conteúdo da imagem.
| Modo | Modelo de prompt | Descrição |
|---|---|---|
| legenda_zh | 描述这张图 fotos | Legenda em chinês |
| inserir_conteúdo | 根据提示词“{}”,描述这张图片 | Legenda com conhecimento inserido |
| caption_en | Por favor, descreva o conteúdo desta imagem | Legenda em inglês |
um. Inferência de imagem única em chinês
python mllm/caption_demo.py --mode "caption_zh" --image_file "mllm/images/demo1.png" --model_path "./ckpts/captioner"
b. Insira conhecimento específico na legenda
python mllm/caption_demo.py --mode "insert_content" --content "宫保鸡丁" --image_file "mllm/images/demo2.png" --model_path "./ckpts/captioner"
c. Inferência de imagem única em inglês
python mllm/caption_demo.py --mode "caption_en" --image_file "mllm/images/demo3.png" --model_path "./ckpts/captioner"
d. Inferência de múltiplas imagens em chinês
