Ce dépôt contient des définitions de modèle PyTorch, des poids pré-entraînés et un code d'inférence/d'échantillonnage pour notre article explorant Hunyuan-DiT. Vous pouvez trouver plus de visualisations sur notre page de projet.
Hunyuan-DiT : un puissant transformateur de diffusion multi-résolution avec une compréhension fine du chinois
DialogGen : système de dialogue interactif multimodal pour la génération de texte en image multi-tours
15 juillet 2024 : HunYuanDiT et Shakker.Ai ont lancé conjointement un événement de mise au point basé sur le modèle HunYuanDiT 1.2. En publiant un lora ou un modèle affiné basé sur HunYuanDiT, vous pouvez gagner jusqu'à 230 $ de bonus de Shakker.Ai. Voir Shakker.Ai pour plus de détails.
15 juillet 2024 : ? Mettez à jour ComfyUI pour prendre en charge les flux de travail standardisés et la compatibilité avec les poids du module t2i et la formation Lora pour les versions 1.1/1.2, ainsi que ceux formés par Kohya ou le script officiel. Voir ComfyUI pour plus de détails.
15 juillet 2024 : ⚡ Nous proposons des environnements Docker pour CUDA 11/12, vous permettant de contourner les installations complexes et de jouer en un seul clic ! Voir les dockers pour plus de détails.
08 juil. 2024 : ? La version HYDiT-v1.2 est publiée. Veuillez consulter HunyuanDiT-v1.2 et Distillation-v1.2 pour plus de détails.
03 juil. 2024 : ? Version Kohya-hydit désormais disponible pour les modèles v1.1 et v1.2, avec interface graphique pour l'inférence. La version officielle de Kohya est en cours de révision. Voir kohya pour plus de détails.
27 juin 2024 : ? Hunyuan-Captioner est publié, fournissant une légende fine pour les données d'entraînement. Voir mllm pour plus de détails.
27 juin 2024 : ? Supporte LoRa et ControlNet dans les diffuseurs. Voir les diffuseurs pour plus de détails.
27 juin 2024 : ? Des scripts d'inférence GPU VRAM de 6 Go sont publiés. Voir Lite pour plus de détails.
19 juin 2024 : ? ControlNet est publié, prenant en charge le contrôle astucieux, de pose et de profondeur. Voir les codes de formation/d'inférence pour plus de détails.
13 juin 2024 : ⚡ La version HYDiT-v1.1 est publiée, ce qui atténue le problème de sursaturation de l'image et atténue le problème du filigrane. Veuillez consulter HunyuanDiT-v1.1 et Distillation-v1.1 pour plus de détails.
13 juin 2024 : ? Le code de formation est publié, offrant une formation complète sur les paramètres et une formation LoRA.
06 juin 2024 : ? Hunyuan-DiT est désormais disponible dans ComfyUI. Veuillez consulter ComfyUI pour plus de détails.
06 juin 2024 : Nous introduisons la version Distillation pour l'accélération Hunyuan-DiT, qui atteint une accélération de 50 % sur les GPU NVIDIA. Veuillez consulter Distillation pour plus de détails.
05 juin 2024 : ? Hunyuan-DiT est maintenant disponible en ? Des diffuseurs ! Veuillez vérifier l'exemple ci-dessous.
04 juin 2024 : Supportez les liens Tencent Cloud pour télécharger les modèles pré-entraînés ! Veuillez vérifier les liens ci-dessous.
22 mai 2024 : nous introduisons la version TensorRT pour l'accélération Hunyuan-DiT, qui atteint une accélération de 47 % sur les GPU NVIDIA. Veuillez consulter TensorRT-libs pour obtenir des instructions.
22 mai 2024 : nous prenons désormais en charge la démo exécutant la génération text2image multi-tours. Veuillez vérifier le script ci-dessous.
Bienvenue sur notre robot Tencent Hunyuan basé sur le Web, où vous pourrez explorer nos produits innovants ! Saisissez simplement les invites suggérées ci-dessous ou toute autre invite imaginative contenant des mots-clés liés au dessin pour activer la fonction de génération de texte en image Hunyuan. Libérez votre créativité et créez n'importe quelle image que vous désirez, le tout gratuitement !
Vous pouvez utiliser des invites simples similaires au texte en langage naturel
画一只穿着西装的猪
dessiner un cochon en costume
生成一幅画，赛博朋克风，跑车
générer un tableau, style cyberpunk, voiture de sport
ou des interactions linguistiques à plusieurs tours pour créer l'image.
画一个木制的鸟
dessiner un oiseau en bois
变成玻璃的
se transformer en verre
Hunyuan-DiT (modèle texte-image)
Inférence
Points de contrôle
Version Distillation
Version TensorRT
Entraînement
Lorraine
Controlnet (Pose, Canny, Profondeur)
Inférence GPU VRAM de 6 Go
Adaptateur IP
Points de contrôle Hunyuan-DiT-S (modèle 0,7B)
Mllm
Inférence
Inférence
Hunyuan-Captioner (Re-sous-titrer les paires image-texte brutes)
Hunyuan-DialogGen (modèle d'amélioration rapide)
Démo Web (Gradio)
Démo T2I multitours (Gradio)
Démo CLI
Interface utilisateur confortable
Diffuseurs
Kohya
Interface utilisateur Web
Hunyuan-DiT : un puissant transformateur de diffusion multi-résolution avec une compréhension fine du chinois
Exemples
Instructions
Inférence
Gradio
ContrôleNet
Inférence GPU VRAM de 6 Go
Utiliser Gradio
En utilisant ? Diffuseurs
Utiliser la ligne de commande
Plus de configurations
Utiliser ComfyUI
Utiliser Kohya
Utilisation des versions précédentes
Préparation des données
Formation complète sur les paramètres
LoRA
Guide d'installation pour Linux
Architecture DiT bilingue chinois-anglais
Génération Text2Image multi-tours
Nouvelles!!
Essayez-le sur le Web
Forfait open source
Contenu
Abstrait
Caractéristiques principales du Hunyuan-DiT
Comparaisons
Visualisation
Exigences
Dépendances et installation
Télécharger des modèles pré-entraînés - 1. Utilisation de HF-Mirror - 2. Reprendre le téléchargement
Entraînement
Inférence
Adaptateur
Sous-titreur Hunyuan
Accélération (pour Linux)
BibTeX
Historique de démarrage
Nous présentons Hunyuan-DiT, un transformateur de diffusion texte en image avec une compréhension fine de l'anglais et du chinois. Pour construire Hunyuan-DiT, nous avons soigneusement conçu la structure du transformateur, l'encodeur de texte et l'encodage de position. Nous construisons également à partir de zéro tout un pipeline de données pour mettre à jour et évaluer les données en vue d'une optimisation itérative du modèle. Pour une compréhension fine du langage, nous formons un grand modèle de langage multimodal pour affiner les légendes des images. Enfin, Hunyuan-DiT peut effectuer un dialogue multimodal à plusieurs tours avec les utilisateurs, générant et affinant des images en fonction du contexte. Grâce à notre protocole d'évaluation humaine holistique soigneusement conçu avec plus de 50 évaluateurs humains professionnels, Hunyuan-DiT établit un nouvel état de l'art en matière de génération d'images chinoises par rapport à d'autres modèles open source.
Hunyuan-DiT est un modèle de diffusion dans l'espace latent, comme le montre la figure ci-dessous. Suivant le modèle de diffusion latente, nous utilisons un auto-encodeur variationnel (VAE) pré-entraîné pour compresser les images dans des espaces latents de basse dimension et entraîner un modèle de diffusion pour apprendre la distribution des données avec des modèles de diffusion. Notre modèle de diffusion est paramétré avec un transformateur. Pour encoder les invites textuelles, nous exploitons une combinaison de CLIP bilingue (anglais et chinois) pré-entraîné et d'un encodeur T5 multilingue.
Comprendre les instructions en langage naturel et effectuer une interaction multi-tours avec les utilisateurs sont importants pour un système de conversion texte-image. Cela peut aider à construire un processus de création dynamique et itératif qui concrétise étape par étape l'idée de l'utilisateur. Dans cette section, nous détaillerons comment nous donnons à Hunyuan-DiT la possibilité d'effectuer des conversations à plusieurs tours et de générer des images. Nous formons MLLM à comprendre le dialogue utilisateur à plusieurs tours et générons la nouvelle invite de texte pour la génération d'images.
Afin de comparer de manière exhaustive les capacités de génération de HunyuanDiT et d'autres modèles, nous avons construit un ensemble de tests en 4 dimensions, comprenant la cohérence texte-image, à l'exclusion des artefacts IA, la clarté du sujet et l'esthétique. Plus de 50 évaluateurs professionnels effectuent l'évaluation.
| Modèle | Source ouverte | Cohérence texte-image (%) | Hors artefacts IA (%) | Clarté du sujet (%) | Esthétique (%) | Dans l'ensemble (%) | ||||
|---|---|---|---|---|---|---|---|---|---|---|
| SDXL | ✔ | 64,3 | 60,6 | 91.1 | 76.3 | 42,7 | ||||
| PixArt-α | ✔ | 68,3 | 60,9 | 93.2 | 77,5 | 45,5 | ||||
| Aire de jeux 2.5 | ✔ | 71,9 | 70,8 | 94,9 | 83,3 | 54.3 | ||||
| SD3 | ✘ | 77.1 | 69,3 | 94,6 | 82,5 | 56,7 | ||||
| Milieu du voyage 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 |
Éléments chinois
Saisie de texte long
Génération Text2Image multi-tours
Ce référentiel se compose de DialogGen (un modèle d'amélioration rapide) et de Hunyuan-DiT (un modèle texte-image).
Le tableau suivant montre les conditions requises pour exécuter les modèles (taille du lot = 1) :
| Modèle | --load-4bit (DialogGen) | Mémoire maximale du GPU | GPU |
|---|---|---|---|
| DialogGen + Hunyuan-DiT | ✘ | 32G | A100 |
| DialogGen + Hunyuan-DiT | ✔ | 22G | A100 |
| Hunyuan-DiT | - | 11G | A100 |
| Hunyuan-DiT | - | 14G | RTX3090/RTX4090 |
Un GPU NVIDIA avec prise en charge CUDA est requis.
Nous avons testé les GPU V100 et A100.
Minimum : La mémoire GPU minimale requise est de 11 Go.
Recommandé : Nous recommandons d'utiliser un GPU avec 32 Go de mémoire pour une meilleure qualité de génération.
Système d'exploitation testé : Linux
Commencez par cloner le dépôt :
clone git https://github.com/tencent/HunyuanDiTcd HunyuanDiT
Nous fournissons un fichier environment.yml pour configurer un environnement Conda. Les instructions d'installation de Conda sont disponibles ici.
Nous recommandons les versions CUDA 11.7 et 12.0+.
# 1. Préparez conda Environmentconda env create -f Environment.yml# 2. Activez l'environnementconda activate HunyuanDiT# 3. Installez pip dependenciespython -m pip install -r Requirements.txt# 4. Installez Flash Attention v2 pour l'accélération (nécessite CUDA 11.6 ou ci-dessus)python -m pip install git+https://github.com/Dao-AILab/[email protected]
De plus, vous pouvez également utiliser Docker pour configurer l'environnement.
# 1. Utilisez le lien suivant pour télécharger le fichier tar de l'image docker.# Pour CUDA 12wget https://dit.hunyuan.tencent.com/download/HunyuanDiT/hunyuan_dit_cu12.tar# Pour CUDA 11wget https://dit.hunyuan. tencent.com/download/HunyuanDiT/hunyuan_dit_cu11.tar# 2. Importez le fichier tar docker et affichez l'image méta-informations# Pour la charge CUDA 12docker -i hunyuan_dit_cu12.tar# Pour la charge CUDA 11docker -i hunyuan_dit_cu11.tar docker image ls# 3. Exécutez le conteneur basé sur imagedocker run -dit --gpus all --init --net=host --uts=host --ipc=host --name hunyuandit --security-opt=seccomp= non confiné --ulimit=stack=67108864 --ulimit=memlock=-1 --privileged docker_image_tag
Pour télécharger le modèle, installez d’abord le fichier huggingface-cli. (Des instructions détaillées sont disponibles ici.)
python -m pip install "huggingface_hub[cli]"
Téléchargez ensuite le modèle à l'aide des commandes suivantes :
# Créez un répertoire nommé 'ckpts' où le modèle sera enregistré, en remplissant les prérequis pour exécuter le demo.mkdir ckpts# Utilisez l'outil huggingface-cli pour télécharger le modèle.# Le temps de téléchargement peut varier de 10 minutes à 1 heure selon sur les conditions du réseau.huggingface-cli télécharger Tencent-Hunyuan/HunyuanDiT-v1.2 --local-dir ./ckpts
Si vous rencontrez des vitesses de téléchargement lentes en Chine, vous pouvez essayer un miroir pour accélérer le processus de téléchargement. Par exemple,
HF_ENDPOINT=https://hf-mirror.com huggingface-cli télécharger Tencent-Hunyuan/HunyuanDiT-v1.2 --local-dir ./ckpts
huggingface-cli prend en charge la reprise des téléchargements. Si le téléchargement est interrompu, vous pouvez simplement réexécuter la commande de téléchargement pour reprendre le processus de téléchargement.
Remarque : Si une erreur de type No such file or directory: 'ckpts/.huggingface/.gitignore.lock' se produit pendant le processus de téléchargement, vous pouvez ignorer l'erreur et réexécuter la commande de téléchargement.
Tous les modèles seront automatiquement téléchargés. Pour plus d'informations sur le modèle, visitez le référentiel Hugging Face ici.
| Modèle | #Params | URL de téléchargement de Huggingface | URL de téléchargement du cloud Tencent |
|---|---|---|---|
| mT5 | 1,6 milliards | mT5 | mT5 |
| AGRAFE | 350M | AGRAFE | AGRAFE |
| Tokeniseur | - | Tokeniseur | Tokeniseur |
| DialogGen | 7.0B | DialogGen | DialogGen |
| sdxl-vae-fp16-fix | 83M | sdxl-vae-fp16-fix | sdxl-vae-fp16-fix |
| Hunyuan-DiT-v1.0 | 1,5 milliards | Hunyuan-DiT | Hunyuan-DiT-v1.0 |
| Hunyuan-DiT-v1.1 | 1,5 milliards | Hunyuan-DiT-v1.1 | Hunyuan-DiT-v1.1 |
| Hunyuan-DiT-v1.2 | 1,5 milliards | Hunyuan-DiT-v1.2 | Hunyuan-DiT-v1.2 |
| Démo de données | - | - | Démo de données |
Reportez-vous aux commandes ci-dessous pour préparer les données d'entraînement.
Installer les dépendances
Nous proposons une bibliothèque de gestion de données efficace, nommée IndexKits, prenant en charge la gestion de la lecture de centaines de millions de données pendant la formation, voir plus dans la documentation.
# 1 Installer les dépendancescd HunyuanDiT pip install -e ./IndexKits
Téléchargement de données
N'hésitez pas à télécharger la démo des données.
# 2 Téléchargement de donnéeswget -O ./dataset/data_demo.zip https://dit.hunyuan.tencent.com/download/HunyuanDiT/data_demo.zip décompresser ./dataset/data_demo.zip -d ./dataset mkdir ./dataset/porcelain/arrows ./dataset/porcelain/jsons
Conversion de données
Créez un fichier CSV pour les données d'entraînement avec les champs répertoriés dans le tableau ci-dessous.
| Champs | Requis | Description | Exemple |
|---|---|---|---|
image_path | Requis | chemin de l'image | ./dataset/porcelain/images/0.png |
text_zh | Requis | texte | 一只蓝色的鸟儿站在蓝色的花瓶上，周围点缀着白色花朵，背景是白色 |
md5 | Facultatif | image md5 (algorithme de résumé de message 5) | d41d8cd98f00b204e9800998ecf8427e |
width | Facultatif | largeur de l'image | 1024 |
height | Facultatif | hauteur de l'image | 1024 |
️ Les champs facultatifs tels que MD5, largeur et hauteur peuvent être omis. En cas d'omission, le script ci-dessous les calculera automatiquement. Ce processus peut prendre du temps lorsqu'il s'agit de données de formation à grande échelle.
Nous utilisons Arrow pour la formation du format de données, offrant une représentation des données en mémoire standard et efficace. Un script de conversion est fourni pour transformer les fichiers CSV au format Arrow.
# 3 Conversion de données python ./hydit/data_loader/csv2arrow.py ./dataset/porcelain/csvfile/image_text.csv ./dataset/porcelain/arrows 1
Sélection des données et création de fichiers de configuration
Nous configurons les données de formation via des fichiers YAML. Dans ces fichiers, vous pouvez configurer des stratégies de traitement de données standard pour le filtrage, la copie, la déduplication et bien plus encore concernant les données d'entraînement. Pour plus de détails, consultez ./IndexKits.
Pour un exemple de fichier, veuillez vous référer au fichier . Pour un fichier de configuration complet des paramètres, voir fichier.
Créez un fichier d'index de données d'entraînement à l'aide du fichier YAML.
# Préparation des données à résolution unique
idk base -c dataset/yamls/porcelain.yaml -t dataset/porcelain/jsons/porcelain.json # Préparation de données multi-résolution
idk multireso -c dataset/yamls/porcelain_mt.yaml -t dataset/porcelain/jsons/porcelain_mt.json La structure des répertoires pour l'ensemble de données porcelain est la suivante :
cd ./ensemble de données
porcelaine
├──images/ (fichiers images)
│ ├──0.png
│ ├──1.png
│ ├──......
├──csvfile/ (fichiers csv contenant des paires texte-image)
│ ├──image_text.csv
├──flèches/ (fichiers de flèches contenant toutes les données d'entraînement nécessaires)
│ ├──00000.flèche
│ ├──00001.flèche
│ ├──......
├──jsons/ (fichiers d'index de données d'entraînement finaux qui lisent les données des fichiers de flèches pendant l'entraînement)
│ ├──porcelaine.json
│ ├──porcelain_mt.jsonExigence:
La configuration minimale requise est un seul GPU avec au moins 20 Go de mémoire, mais nous vous recommandons d'utiliser un GPU avec environ 30 Go de mémoire pour éviter le déchargement de la mémoire hôte.
De plus, nous encourageons les utilisateurs à exploiter les multiples GPU sur différents nœuds pour accélérer la formation sur de grands ensembles de données.
Avis:
Les utilisateurs personnels peuvent également utiliser le Kohya léger pour affiner le modèle avec environ 16 Go de mémoire. Actuellement, nous essayons de réduire davantage l'utilisation de la mémoire de notre infrastructure industrielle pour les utilisateurs personnels.
Si vous disposez de suffisamment de mémoire GPU, essayez de supprimer --cpu-offloading ou --gradient-checkpointing pour réduire les coûts de temps.
Spécifiquement pour la formation distribuée, vous avez la possibilité de contrôler la formation à un seul nœud / multi-nœuds en ajustant des paramètres tels que --hostfile et --master_addr . Pour plus de détails, voir le lien.
# Formation à résolution uniquePYTHONPATH=./ sh hydit/train.sh --index-file dataset/porcelain/jsons/porcelain.json# Formation multi-résolutionPYTHONPATH=./ sh hydit/train.sh --index-file dataset/porcelain/jsons /porcelain_mt.json --multireso --reso-step 64# Formation avec l'ancienne version de HunyuanDiT (<= v1.1)PYTHONPATH=./ sh hydit/train_v1.1.sh --index-file dataset/porcelain/jsons/porcelain.json
Une fois les points de contrôle enregistrés, vous pouvez utiliser la commande suivante pour évaluer le modèle.
# Inférence # Vous devez remplacer le 'log_EXP/xxx/checkpoints/final.pt' par votre chemin réel.python sample_t2i.py --infer-mode fa --prompt "青花瓷风格，一只可爱的哈士奇" --no-enhance - -dit-weight log_EXP/xxx/checkpoints/final.pt --load-key module# Ancienne version de HunyuanDiT (<= v1.1)# Vous devez remplacer le 'log_EXP/xxx/checkpoints/final.pt' par votre chemin actuel.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- module clé
Nous fournissons des scripts de formation et d'inférence pour LoRA, détaillés dans le ./lora.
# Formation pour la porcelaine LoRA.PYTHONPATH=./ sh lora/train_lora.sh --index-file dataset/porcelain/jsons/porcelain.json# Inférence à l'aide de LORA Weights.python entraînés sample_t2i.py --infer-mode fa --prompt "青花瓷风格，一只小狗" --no-enhance --lora-ckpt log_EXP/001-lora_porcelain_ema_rank64/checkpoints/0001000.pt
Nous proposons deux types de poids LoRA entraînés pour porcelain et jade , voir détails sur les liens
cd HunyuanDiT# Utilisez l'outil huggingface-cli pour télécharger le modèle.huggingface-cli download Tencent-Hunyuan/HYDiT-LoRA --local-dir ./ckpts/t2i/lora# Démarrage rapidepython sample_t2i.py --infer-mode fa - -rapide "青花瓷风格，一只猫在追蝴蝶" --no-enhance --load-key ema --lora-ckpt ./ckpts/t2i/lora/porcelain
| Exemples de données d'entraînement | |||
| Style porcelaine, un l'oiseau bleu se dresse sur un vase bleu, entouré de fleurs blanches, sur fond blanc. ） | 青花瓷风格，这是一幅蓝白相间的陶瓷盘子，上面描绘着一只狐狸和它的幼崽在森林中漫步，背景是白色（De style porcelaine, il s'agit d'une assiette en céramique bleue et blanche représentant un renard et ses petits se promenant dans la forêt, sur fond blanc.） | Porcelaine style, sur fond noir, un loup bleu se dresse sur une assiette bleue et blanche, entouré d'arbres et de la lune.） | 青花瓷风格，在蓝色背景上，一只蓝色蝴蝶和白色花朵被放置在中央 （Style porcelaine, sur fond bleu, un papillon bleu et des fleurs blanches sont placés au centre.） |
| Exemples de résultats d'inférence | |||
| 青花瓷风格，苏州园林 （Style porcelaine, jardins de Suzhou.） | 青花瓷风格，一朵荷花 （Style porcelaine, une fleur de lotus.） | 青花瓷风格，一只羊（Style porcelaine, un mouton.） | 青花瓷风格，一个女孩在雨中跳舞（Style porcelaine, une fille qui danse sous la pluie.） |
L’exécution de HunyuanDiT dans moins de 6 Go de VRAM GPU est désormais disponible sur la base de diffuseurs. Nous fournissons ici des instructions et une démo pour votre démarrage rapide.
La version 6 Go prend en charge les cartes graphiques de la série d'architecture Nvidia Ampere telles que RTX 3070/3080/4080/4090, A100, etc.
La seule chose que vous devez faire est d'installer la bibliothèque suivante :
pip install -U bits et octets pip install git+https://github.com/huggingface/diffusers pip installer la torche == 2.0.0
Ensuite, vous pourrez profiter directement de votre voyage de conversion texte-image HunyuanDiT sous 6 Go de VRAM GPU !
Voici une démo pour vous.
cd HunyuanDiT# Quick startmodel_id=Tencent-Hunyuan/HunyuanDiT-v1.2-Diffusers-Distilled
prompt=一个宇航员在骑马
infer_steps=50
guidance_scale=6
python3 lite/inference.py ${model_id} ${prompt} ${infer_steps} ${guidance_scale}Plus de détails peuvent être trouvés dans ./lite.
Assurez-vous que l'environnement conda est activé avant d'exécuter la commande suivante.
# Par défaut, nous démarrons une interface utilisateur chinoise. Utilisation de Flash Attention pour accélération.python app/hydit_app.py --infer-mode fa# Vous pouvez désactiver le modèle d'amélioration si la mémoire GPU est insuffisante.# L'amélioration sera indisponible jusqu'à ce que vous redémarriez l'application sans le `--no- améliorer le drapeau. python app/hydit_app.py --no-enhance --infer-mode fa# Commencez par l'UI en anglaispython app/hydit_app.py --lang en --infer-mode fa# Démarrez une interface utilisateur de génération T2I multi-tours. # Si la mémoire de votre GPU est inférieure à 32 Go, utilisez '--load-4bit' pour activer la quantification 4 bits, ce qui nécessite au moins 22 Go de mémoire.python app/multiTurnT2I_app.py --infer-mode fa
Ensuite, la démo est accessible via http://0.0.0.0:443. Il convient de noter que le 0.0.0.0 ici doit être XXXX avec l'adresse IP de votre serveur.
Veuillez installer PyTorch version 2.0 ou supérieure à l'avance pour satisfaire aux exigences de la version spécifiée de la bibliothèque de diffuseurs.
Installez les diffuseurs en vous assurant que la version est au minimum 0.28.1 :
pip install git+https://github.com/huggingface/diffusers.git
ou
pip installer des diffuseurs
Vous pouvez générer des images avec des invites en chinois et en anglais à l'aide du script Python suivant :
import torchfrom diffusers import HunyuanDiTPipelinepipe = HunyuanDiTPipeline.from_pretrained("Tencent-Hunyuan/HunyuanDiT-v1.2-Diffusers", torch_dtype=torch.float16)pipe.to("cuda")# Vous pouvez également utiliser l'invite en anglais car HunyuanDiT prend en charge l'anglais et chinois# prompt = "Un astronaute montant à cheval"prompt = "一个宇航员在骑马"image = pipe(prompt).images[0]Vous pouvez utiliser notre modèle distillé pour générer des images encore plus rapidement :
import torchfrom diffuseurs import HunyuanDiTPipelinepipe = HunyuanDiTPipeline.from_pretrained("Tencent-Hunyuan/HunyuanDiT-v1.2-Diffusers-Distilled", torch_dtype=torch.float16)pipe.to("cuda")# Vous pouvez également utiliser l'invite en anglais car HunyuanDiT prend en charge en anglais et en chinois# prompt = "Un astronaute montant à cheval"prompt = "一个宇航员在骑马"image = pipe(prompt, num_inference_steps=25).images[0]Plus de détails peuvent être trouvés dans HunyuanDiT-v1.2-Diffusers-Distilled
Plus de fonctions : Pour d'autres fonctions comme LoRA et ControlNet, veuillez consulter le README de ./diffusers.
Nous fournissons plusieurs commandes pour un démarrage rapide :
# Uniquement texte-image. Flash Attention modepython sample_t2i.py --infer-mode fa --prompt "渔舟唱晚" --no-enhance# Générer une image avec d'autres tailles d'image.python sample_t2i.py --infer-mode fa --prompt "渔舟唱晚" --image-size 1280 768# Amélioration de l'invite + Texte à image. DialogGen se charge avec une quantification 4 bits, mais cela peut perdre des performances.python sample_t2i.py --infer-mode fa --prompt "渔舟唱晚" --load-4bit
D'autres exemples d'invites peuvent être trouvés dans example_prompts.txt
Nous répertorions quelques configurations plus utiles pour une utilisation facile :
| Argument | Défaut | Description |
|---|---|---|
--prompt | Aucun | L'invite de texte pour la génération d'images |
--image-size | 1024 1024 | La taille de l'image générée |
--seed | 42 | La graine aléatoire pour générer des images |
--infer-steps | 100 | Le nombre d'étapes d'échantillonnage |
--negative | - | L'invite négative pour la génération d'images |
--infer-mode | torche | Le mode d'inférence (torch, fa ou trt) |
--sampler | ddpm | L'échantillonneur de diffusion (ddpm, ddim ou dpmms) |
--no-enhance | FAUX | Désactiver le modèle d'amélioration des invites |
--model-root | chèques | Le répertoire racine des points de contrôle du modèle |
--load-key | ema | Charger le modèle étudiant ou le modèle EMA (ema ou module) |
--load-4bit | Faslé | Charger le modèle DialogGen avec quantification 4 bits |
Prend en charge deux flux de travail : Standard ComfyUI et Diffusers Wrapper, le premier étant recommandé.
Prend en charge HunyuanDiT-v1.1 et v1.2.
Module de support, modèles lora et clip lora formés par Kohya.
Module de support, modèles lora formés par les scripts de formation officiels HunyunDiT.
ControlNet arrive bientôt.
Plus de détails peuvent être trouvés dans ./comfyui-hydit
Nous prenons en charge les codes personnalisés pour l'interface graphique kohya_ss et les codes de formation sd-scripts pour HunyuanDiT. Plus de détails peuvent être trouvés dans ./kohya_ss-hydit
Hunyuan-DiT <= v1.1
# ============================== v1.1 ================= ==============# Téléchargez le modelhuggingface-cli télécharger Tencent-Hunyuan/HunyuanDiT-v1.1 --local-dir ./HunyuanDiT-v1.1# Inférence avec le 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 ================== =============# Téléchargez le modelhuggingface-cli download Tencent-Hunyuan/HunyuanDiT --local-dir ./HunyuanDiT-v1.0# Inférence avec le modelpython sample_t2i.py --infer-mode fa --prompt "渔舟唱晚" --model-root ./HunyuanDiT-v1.0 --use-style-cond --size-cond 1024 1024 --beta-end 0.03
Nous fournissons des scripts de formation pour ControlNet, détaillés dans le ./controlnet.
# Formation pour Astucieux ControlNet.PYTHONPATH=./ sh hydit/train_controlnet.sh
Nous proposons trois types de poids ControlNet entraînés pour depth et pose canny , voir les détails sur les liens
cd HunyuanDiT# Utilisez l'outil huggingface-cli pour télécharger le modèle.# Nous vous recommandons d'utiliser des poids distillés comme modèle de base pour l'inférence ControlNet, car nos poids pré-entraînés fournis sont formés sur eux.huggingface-cli télécharger Tencent-Hunyuan/HYDiT-ControlNet- v1.2 --local-dir ./ckpts/t2i/controlnet huggingface-cli télécharger Tencent-Hunyuan/Distillation-v1.2 ./pytorch_model_distill.pt --local-dir ./ckpts/t2i/model# Démarrage rapidepython3 sample_controlnet.py --infer-mode fa --no-enhance --load -key distill --infer-steps 50 --control-type astucieux --prompt « » ，它的眼睛闪烁着光芒，仿佛在守护着这座建筑。背景是夜晚的酒店前，构图方式是特写，平视，居中构图。这张照photo呈现" --condition-image-path controlnet/asset/input/canny.jpg --control-weight 1.0
| Entrée de condition | ||
| Canny ControlNet | Contrôle de profondeurNet | Pose ControlNet |
| 在夜晚的酒店门前，一座古老的中国风格的狮子雕像矗立着，它的眼睛闪烁着光芒，仿佛在守护着这座建筑。背景是夜晚的酒店前，构图方式是特写，平视，居中构图。这张照片呈现了真实摄影风格，蕴含了中国雕塑文化，同时展现了神秘氛围（À La nuit tombée, une ancienne statue de lion de style chinois se dresse devant l'hôtel, ses yeux brillants comme s'il gardait le bâtiment. L’arrière-plan est l’entrée de l’hôtel la nuit, avec une composition en gros plan, à la hauteur des yeux et centrée. Cette photo présente un style photographique réaliste, incarne la culture de la sculpture chinoise et révèle une atmosphère mystérieuse.） | 在茂密的森林中，一只黑白相间的熊猫静静地坐在绿树红花中，周围是山川和海洋。背景是白天的森林，光线充足。照片采用特写、平视和居中构图的方式，呈现出写实的效果（In Dans la forêt dense, un panda noir et blanc se repose tranquillement parmi les arbres verts et les fleurs rouges, entouré de montagnes et d'océans. L’arrière-plan est une forêt diurne avec beaucoup de lumière. La photo utilise une composition en gros plan, au niveau des yeux et centrée pour créer un effet réaliste.） | 在白天的森林中，一位穿着绿色上衣的亚洲女性站在大象旁边。照photo采用了中景、平视和居中构图的方式，呈现出写实的效果。这张照片蕴含了人物摄影文化，并展现了宁静的氛围（In Dans la forêt diurne, une femme asiatique vêtue d'une chemise verte se tient à côté d'un éléphant. La photo utilise un plan moyen, au niveau des yeux et une composition centrée pour créer un effet réaliste. Cette image incarne la culture de la photographie de personnages et véhicule une atmosphère sereine.） |
| Sortie ControlNet | ||
Hunyuan-Captioner répond aux besoins des techniques de conversion texte-image en maintenant un haut degré de cohérence image-texte. Il peut générer des descriptions d'images de haute qualité sous différents angles, notamment la description des objets, les relations entre les objets, les informations de base, le style de l'image, etc. Notre code est basé sur l'implémentation de LLaVA.
un. Installer les dépendances
Les dépendances et l'installation sont fondamentalement les mêmes que celles du modèle de base .
b. Téléchargement du modèle
# Utilisez l'outil huggingface-cli pour télécharger le modèle.huggingface-cli download Tencent-Hunyuan/HunyuanCaptioner --local-dir ./ckpts/captioner
Notre modèle prend en charge trois modes différents : générer directement une légende en chinois , générer une légende en chinois basée sur des connaissances spécifiques et générer directement une légende en anglais . Les informations injectées peuvent être soit des indices précis, soit des étiquettes bruitées (par exemple, des descriptions brutes extraites d'Internet). Le modèle est capable de générer des descriptions fiables et précises basées à la fois sur les informations insérées et sur le contenu de l'image.
| Mode | Modèle d'invite | Description |
|---|---|---|
| légende_zh | 描述这张图photo | Légende en chinois |
| insert_content | 根据提示词“{}”,描述这张图photo | Légende avec connaissances insérées |
| caption_fr | Veuillez décrire le contenu de cette image | Légende en anglais |
un. Inférence d'image unique en chinois
python mllm/caption_demo.py --mode "caption_zh" --image_file "mllm/images/demo1.png" --model_path "./ckpts/captioner"
b. Insérer des connaissances spécifiques dans la légende
python mllm/caption_demo.py --mode "insert_content" --content "宫保鸡丁" --image_file "mllm/images/demo2.png" --model_path "./ckpts/captioner"
c. Inférence d'image unique en anglais
python mllm/caption_demo.py --mode "caption_en" --image_file "mllm/images/demo3.png" --model_path "./ckpts/captioner"
d. Inférence de plusieurs images en chinois
