Dreambooth

Comment affiner la diffusion stable à l’aide de Dreambooth

Images générées personnalisées avec des styles ou des objets personnalisés

Auparavant, j’ai couvert un article sur le réglage fin de la diffusion stable à l’aide de l’inversion textuelle . Ce didacticiel explique comment affiner la diffusion stable à l’aide d’une autre méthode appelée Dreambooth . Contrairement à la méthode d’inversion textuelle qui entraîne uniquement l’intégration sans modification du modèle de base, Dreambooth affine l’ensemble du modèle texte-image de sorte qu’il apprenne à lier un identifiant unique à un concept spécifique (objet ou style). En conséquence, les images générées sont plus personnalisées à l’objet ou au style par rapport à l’inversion textuelle.

Ce tutoriel est basé sur une version fourchue de l’implémentation de Dreambooth par HuggingFace. L’implémentation d’origine nécessite environ 16 Go à 24 Go pour affiner le modèle. Le mainteneur ShivamShrirao a optimisé le code pour réduire l’utilisation de la VRAM à moins de 16 Go. En fonction de vos besoins et de vos paramètres, vous pouvez affiner le modèle avec un GPU de 10 Go à 16 Go. J’ai personnellement testé la formation pour être faisable sur le GPU Tesla T4.

Veuillez noter que toute l’implémentation existante n’est pas par l’auteur original de Dreambooth. En conséquence, il pourrait y avoir une légère différence en termes de reproductibilité.

Passons à la section suivante pour configurer tous les modules nécessaires.

Installation

Il est recommandé de créer un nouvel environnement virtuel avant de poursuivre l’installation.

Paquets Python

Dans votre répertoire de travail, créez un nouveau fichier appelé requirements.txtavec le code suivant :

accelerate==0.12.0 transformateurs 
torchvision 
>=4.21.0 
ftfy 
tensorboard 
modelcards

Activez votre environnement virtuel et exécutez la commande suivante un par un pour installer tous les modules nécessaires :

pip install git+https://github.com/ShivamShrirao/diffusers.git 
pip install -r requirements.txt

REMARQUE : Vous devez effectuer l’installation diffusersà l’aide de l’URL ci-dessus au lieu de l’installer directement à partir de pypi.

paquet bitsandbytes

Il existe un package optionnel appelé bitsandbytes, qui peut réduire davantage l’utilisation de la VRAM. Cependant, il ne prend en charge que les versions CUDA 10.2 à 11.7 et votre machine doit remplir les conditions suivantes :

  • LLM.int8(): NVIDIA Turing (RTX 20xx ; T4) ou GPU Ampère (RTX 30xx ; A4-A100) ; (un GPU de 2018 ou plus ancien).
  • 8-bit optimizers and quantization: GPU NVIDIA Maxwell ou plus récent (>=GTX 9XX).

Vous pouvez l’installer comme suit :

pip installer bits et octets

paquet xformer

Pour ceux dont le GPU est inférieur à 24 Go, vous devez installer le xformerspackage afin de réduire davantage l’utilisation de la VRAM. Au moment d’écrire ces lignes, l’installation xformersn’est pas si simple en raison du manque de prise en charge des roues par les développeurs.

Vous pouvez installer le package comme suit :

pip install xformers

Si vous rencontrez une erreur avec la commande ci-dessus, exécutez la commande suivante pour créer le package directement à partir du référentiel :

pip installer git+https://github.com/facebookresearch/xformers.git@main#egg=xformers#egg=xformers

Si vous rencontrez des problèmes avec la version de CUDA, assurez-vous d’installer la dernière version de CUDA compatible avec votre machine. Suivez les instructions du lien suivant .

Accélérer la configuration

L’étape suivante consiste à initialiser un Accelerateenvironnement. Exécutez la commande suivante :

accélérer la configuration

Il y aura plusieurs invites dans le terminal. Répondez-y en fonction de vos propres cas d’utilisation. Jetez un oeil à l’exemple suivant comme référence:

Dans quel environnement de calcul exécutez-vous ? ([0] Cette machine, [1] AWS (Amazon SageMaker)) : 0quel environnement de calcul utilisez-vous ? ([0] Cette machine, [1] AWS (Amazon SageMaker)) : 0 
Quel type de machine utilisez-vous ? ([0] Pas d'entraînement distribué, [1] multi-CPU, [2] multi-GPU, [3] TPU [4] MPS) : 0 
Voulez-vous exécuter votre entraînement sur CPU uniquement (même si un GPU est disponible ) ? [ oui /NON] :non 
Souhaitez-vous utiliser DeepSpeed ? [ oui /NON] : non 
Souhaitez-vous utiliser FP16 ou BF16 (précision mixte) ? [NON/fp16/bf16] : fp16

Les modèles de HuggingFace

Vous pouvez ignorer cette section si vous disposez déjà du diffusersmodèle de diffusion stable (v1.4/v1.5). Pour ceux qui

Vous devez utiliser le diffusersmodèle au lieu du ckptfichier pour un réglage fin. Vous pouvez utiliser le script suivant pour convertir votre ckptfichier en diffusersmodèle.

Enregistrez un nouveau compte dans HuggingFace et acceptez la licence du modèle avant de télécharger ou d’utiliser les poids.

Une fois que vous avez terminé, reportez-vous à cette section de la documentation pour activer le jeton d’accès.

Exécutez la commande suivante et transmettez votre jeton pour l’authentification :

connexion huggingface-cli

Il téléchargera les poids dans le dossier cache lors de l’exécution initiale.

Jeux de données

Vous devez collecter des ensembles de données de haute qualité pour obtenir des résultats cohérents et bons. Les images d’entraînement doivent correspondre à la sortie attendue et être redimensionnées à une résolution de 512 x 512.

Veuillez noter que des artefacts tels que le flou de mouvement ou une faible résolution affecteront les images générées. Cela s’applique à tout texte, filigrane ou icône indésirable dans vos ensembles de données d’entraînement. Assurez-vous de prêter attention aux ensembles de données que vous avez utilisés pour la formation.

En fonction de vos cas d’utilisation, vous pouvez utiliser les directives suivantes :

Objet

Utilisez des images de votre objet avec un arrière-plan normal. L’arrière-plan transparent peut laisser une frange ou une bordure autour de l’objet. Toutes les images d’entraînement doivent se concentrer uniquement sur l’objet avec des variations sur :

  • angle de caméra
  • pose
  • accessoires (vêtements, coupe de cheveux, etc.)
  • arrière-plan (pris à différents endroits)

Le nombre d’images d’entraînement doit être d’environ 5 à 20. Vous devrez peut-être recadrer les images pour vous concentrer uniquement sur l’objet.

Style

Utilisez des images du style que vous aimez. Cela peut provenir de vos propres collections d’art ou de films/animations/émissions de télévision publics qui partagent un style cohérent. Toutes les images de formation doivent se concentrer sur le style et non sur un objet particulier.

Pour bien généraliser, vous devez vous assurer que le même objet n’apparaît pas plus d’une fois dans les images d’entraînement (une de chaque personnage). Si votre objectif est de générer différents personnages du même style. N’incluez que des images d’entraînement avec des personnages. Sinon, incluez des paysages, des objets et d’autres images pertinentes dans vos ensembles de données d’entraînement.

Images de formation

Dans ce tutoriel, j’utiliserai les images de formation suivantes :

Ce didacticiel utilise les termes suivants pour les ensembles de données d’entraînement.

  • Instance images — Images personnalisées qui représentent le concept spécifique de la formation dreambooth. Vous devez collecter des images de haute qualité en fonction de vos cas d’utilisation.
  • Class images — Images de régularisation pour la perte de conservation préalable afin d’éviter le surajustement. Vous devez générer ces images directement à partir du modèle pré-entraîné de base. Vous pouvez choisir de les générer vous-même ou de les générer à la volée lors de l’exécution du script de formation.

Entraînement

Rendez-vous sur le référentiel Github suivant et téléchargez le train_dreambooth.pyfichier dans votre répertoire de travail.

Commandes d’entraînement

Voici une liste des paramètres communs qui doivent être modifiés en fonction de vos cas d’utilisation :

  • pretrained_model_name_or_path— Chemin d’accès au modèle pré-entraîné ou à l’identifiant du modèle à partir de huggingface.co/models
  • pretrained_vae_name_or_path— Chemin d’accès au vae préformé ou à l’identifiant vae de huggingface.co/models. Vous pouvez affiner le modèle avec ou sans vae
  • instance_data_dir— Un dossier contenant les données d’entraînement des images d’instance
  • class_data_dir— Un dossier contenant les données d’entraînement des images de classe
  • instance_prompt — L’invite avec l’identifiant spécifiant l’instance
  • class_prompt— L’invite pour spécifier des images dans la même classe que les images d’instance fournies
  • num_class_images— Images de classe minimales pour perte de conservation antérieure
  • output_dir— Le répertoire de sortie où les prédictions du modèle et les points de contrôle seront écrits
  • max_train_steps— Nombre total d’étapes d’entraînement à effectuer. Il est recommandé de le définir sur N * 100où Nreprésente le nombre d’images d’instance.
  • learning_rate — Taux d’apprentissage initial (après la période d’échauffement potentielle) à utiliser
  • lr_scheduler— Le type de planificateur à utiliser. Choisissez entre [ linearcosinecosine_with_restartspolynomialconstantconstant_with_warmup]
  • lr_warmup_steps— Nombre d’étapes pour le préchauffage dans le planificateur lr. À utiliser max_train_steps / 10lors de l’utilisation polynomialou 0lors de l’utilisation de constant.
  • save_interval — Enregistrez les poids toutes les N étapes. Assurez-vous d’avoir suffisamment d’espace de stockage pour cela. Chaque poids est d’environ 4 Go.

Vous pouvez définir un vae personnalisé à l’aide de l’indicateur suivant :

--pretrained_vae_name_or_path="stabilityai/sd-vae-ft-mse""stabilityai/sd-vae-ft-mse"

L’entraînement avec perte de conservation préalable aide à prévenir le surajustement. Activez-le comme suit :

--with_prior_preservation --prior_loss_weight=1.0

De plus, vous pouvez affiner le text_encoderlong avec unet. Cependant, cela augmentera considérablement l’utilisation de la VRAM. Définissez-le avec le drapeau suivant :

--train_text_encoder

Pour la formation d’objet, vous pouvez utiliser l’exemple suivant comme référence pour instance_promptet class_prompt. N’hésitez pas à expérimenter différentes chaînes en fonction de vos cas d’utilisation.

# Femme
 --instance_prompt= "photo d'une femme zwx" \ 
--class_prompt= "photo d'une femme" \ 

# Homme noir
 --instance_prompt= "photo d'un homme noir zwx" \ 
--class_prompt= "photo d'un homme noir" \ 

# Chien
 --instance_prompt= "photo d'un chien zwx" \ 
--class_prompt= "photo d'un chien" \

Vous pouvez utiliser votre propre chaîne personnalisée comme identifiant unique. Au début de l’implémentation, la plupart des exemples utilisent skscomme identifiant unique. Cependant, sksest un jeton connu pour un fusil semi-automatique. Il est fortement recommandé d’utiliser un identifiant unique différent qui ne fait pas partie du jeton utilisé dans les jeux de données originaux de Stable Diffusion.

De plus, l’identifiant unique n’est pas limité à une seule chaîne. Certains utilisateurs ont signalé de bonnes performances avec les invites suivantes pour l’entraînement de style :

# Style 1
 --instance_prompt= "style Disney moderne" \ 
--class_prompt= "style d'illustration" \ 

# Style 2
 --instance_prompt= "style d'animation classique" \ 
--class_prompt= "style d'illustration" \

En ce qui concerne le taux d’apprentissage et le planificateur, veuillez vous référer au blog suivant de HuggingFace.

Exemples de formation

Jetez un œil à l’exemple de commande d’entraînement suivant pour les images d’entraînement ci-dessus (testé sur Tesla T4 avec 16 Go de mémoire) :

accélérer lancer train_dreambooth.py \ 
  --pretrained_model_name_or_path="runwayml/stable-diffusion-v1-5" \"runwayml/stable-diffusion-v1-5" \ 
  --pretrained_vae_name_or_path= "stabilityai/sd-vae-ft-mse" \ 
  --instance_data_dir= "./instance-images/" \ 
  --class_data_dir= "./class- images/" \ 
  --output_dir= "./output-models/" \ 
  --with_prior_preservation --prior_loss_weight=1.0 \ 
  --instance_prompt= "photo du jouet ours zwx" \ 
  --class_prompt= "photo du jouet ours" \ 
  - -résolution=512 \ 
  --train_batch_size=1 \ 
  --train_text_encoder \ 
  --mixed_precision= "fp16"\ 
  --use_8bit_adam \
  --gradient_accumulation_steps=1 \ 
  --gradient_checkpointing \ 
  --learning_rate=1e-6 \ 
  --lr_scheduler= "constante" \ 
  --lr_warmup_steps=200 \ 
  --num_class_images=300 \ 
  --max_train_steps=2000 \ 
  --save_interval=500

Modifiez le répertoire de données en conséquence en fonction de votre répertoire de travail.

Si vous n’avez pas suffisamment de mémoire, veuillez désactiver l’ text_encoderentraînement :

accélérer lancer train_dreambooth.py \ 
  --pretrained_model_name_or_path="runwayml/stable-diffusion-v1-5" \"runwayml/stable-diffusion-v1-5" \ 
  --instance_data_dir= "./instance-images/" \ 
  --class_data_dir= "./class-images/" \ 
  --output_dir= "./output-models/" \ 
  --with_prior_preservation --prior_loss_weight=1.0 \ 
  --instance_prompt= "photo du jouet ours zwx" \ 
  --class_prompt= "photo du jouet ours" \ 
  --resolution=512 \ 
  --train_batch_size=1 \ 
  --mixed_precision= " fp16"\ 
  --use_8bit_adam \ 
  --gradient_accumulation_steps=1 \ 
  --gradient_checkpointing \ 
  --learning_rate=1e-6 \ 
  --lr_scheduler="constante" \ 
  --lr_warmup_steps=0 \ 
  --num_class_images=300 \ 
  --max_train_steps=2000 \ 
  --save_interval=500

Assurez-vous de ne pas trop entraîner votre modèle car la méthode Dreambooth a tendance à sur-s’adapter rapidement. Si votre modèle ne se généralise pas bien à vos invites ou contient des artefacts, cela signifie très probablement que vous avez surentraîné votre modèle. Veuillez réduire les étapes d’entraînement ou entraînez-vous avec des étapes plus élevées en utilisant un taux d’apprentissage inférieur.

De plus, le dernier script de formation accepte un nouveau paramètre appelé concept_list. Il représente le chemin d’accès à un fichier JSON contenant une liste de dictionnaires. Il écrasera les paramètres tels que instance_promptclass_prompt, etc. Vous pouvez l’utiliser pour former plusieurs concepts en même temps à un seul modèle. Par exemple, étant donné le concept_list.jsonfichier suivant :

[ 
    { 
        "instance_prompt": "photo d'un chien zwx","instance_prompt" :       "photo d'un chien zwx" , 
        "class_prompt" :          "photo d'un chien" , 
        "instance_data_dir" :     "./instance-images/" , 
        "class_data_dir" :        "./class-images/"
     } 
]

Vous pouvez utiliser le paramètre suivant dans la commande d’entraînement :

--concepts_list ./concepts_list.json

Ajoutez simplement un nouveau dictionnaire à la liste pour former un autre concept en même temps.

Lorsque vous l’exécuterez pour la première fois, il générera les images de classe. Vous pouvez réutiliser les mêmes images de classe pour la formation suivante tant que vous faites référence au même concept. Définissez simplement le class_data_dirdans le même répertoire que votre formation précédente. Par conséquent, vous pouvez réutiliser la plupart des images de classe générées lors de la formation pour un style particulier.

Voici quelques images de classe générées pour ce tutoriel :

Sortie de la formation

Le script enregistrera un nouveau poids sur chaque intervalle en fonction de la valeur de save_interval. Vous devriez avoir les fichiers et dossiers suivants dans chacun des dossiers de poids nouvellement générés :

|- feature_extractor 
| |- preprocessor_config.json 
|- planificateur 
| |- scheduler_config.json 
|- text_encoder 
| |- config.json 
| |- pytorch_model.bin 
|- tokenizer 
| |- merges.txt 
| |- special_tokens_map.json 
| |- tokenizer_config.json 
| |- vocab.json 
|- unet 
| |- config.json 
| |- diffusion_pytorch_model.bin 
|- vae 
| |- config.json 
| |- diffusion_pytorch_model.bin 
|- args.json 
|- model_index.json

Inférence

Maintenant, créez un nouveau fichier Python appelé inference.pydans votre répertoire de travail. Ajoutez le code suivant à l’intérieur :

depuis les diffuseurs import StableDiffusionPipeline, DDIMScheduler 
import torch 

device = "cuda""cuda" 
# utiliser le planificateur DDIM, vous pouvez le modifier pour utiliser un autre planificateur
 planificateur = DDIMScheduler(beta_start=0.00085, beta_end=0.012, beta_schedule= "scaled_linear" , clip_sample=False, set_alpha_to_one=True) 

# modifier le chemin du modèle
 pipe = StableDiffusionPipeline .from_pretrained( 
    f "./output-models/1500/" , 
    scheduler=scheduler, 
    safety_checker=None, 
    torch_dtype=torch.float16, 
).to(device) 

# activer l'attention de la mémoire
 xformers pipe.enable_xformers_memory_efficient_attention() 

prompt = "photo de zwx jouet ours"
 negative_prompt = ""
 num_samples = 4 
guidance_scale = 7.5
num_inference_steps = 50 
hauteur = 512 
largeur = 512 

avec torch.autocast( "cuda" ), torch.inference_mode() : 
    images = pipe( 
        invite, 
        hauteur=hauteur, 
        largeur=largeur, 
        negative_prompt=negative_prompt, 
        num_images_per_prompt=num_samples, 
        num_inference_steps=num_inference_steps , 
        guidance_scale=guidance_scale 
    ).images 

    count = 1 
    for image in images: 
        # save image to local directory
         image.save(f "img-{count}.png" ) 
        count += 1

Certains utilisateurs ont signalé que l’utilisation xformerspour la génération d’images entraînerait des résultats non déterministes. Cela signifie que vous ne pouvez pas reproduire la même image avec les mêmes paramètres (graine, taille d’image, etc.). Veuillez l’expérimenter vous-même et modifier le code en conséquence en fonction de vos cas d’utilisation.

Une fois que vous avez terminé, exécutez la commande suivante pour générer des images à l’aide du nouveau modèle affiné.

python inference.py

Voici quelques exemples de sorties (les invites ne sont pas incluses car j’ai commis l’erreur de ne pas les suivre au départ):

Conclusion

Dreambooth est une bonne technique pour affiner le modèle Stable Diffusion avec un concept particulier (objet ou style).

Avec l’avancement de la recherche et du développement en IA, il est désormais possible pour le Joe moyen d’affiner ses propres modèles personnalisés. Cependant, cela peut être une épée à double tranchant avec à la fois des opportunités et des défis pour les industries de l’art.

Si vous faites partie des industries artistiques, il est recommandé d’adopter et d’utiliser cette technologie pour rationaliser votre flux de travail. De plus, ce serait formidable si tout le monde pouvait utiliser cette technologie à bon escient pour le bien de l’humanité.

Malheureusement, je n’ai pas suffisamment de mémoire pour le moment pour affiner l’ensemble du modèle en utilisant des paires d’images et de légendes.

Merci d’avoir lu cet article. Bonne journée à venir !

Retour en haut