Le guide du débutant pour la génération d'images inconditionnelles à l'aide de diffuseurs | de Ng Wai Foong

Explorez et générez des images uniques et imaginatives basées sur des ensembles de données existants

Auparavant, j’ai couvert les articles suivants sur le réglage fin du modèle de diffusion stable pour générer des images personnalisées :

Les modèles affinés ci-dessus sont classés dans la génération d’image conditionnelle, qui prend une entrée (texte, image, etc.) pour générer des images.

Ce didacticiel se concentre sur la génération d’images inconditionnelle. Pour votre information, le but principal de la génération d’images inconditionnelle est de créer des images nouvelles et uniques sans aucune entrée spécifique (texte, image, etc.).

La génération d’images inconditionnelle a différents objectifs et convient aux cas d’utilisation suivants :

artistic expression — explorer de nouveaux concepts et possibilités
data augmentation — créer des ensembles de données synthétiques pour les tâches de vision par ordinateur telles que la classification et la reconnaissance d’images
innovative design — créer un design innovant pour les produits et les œuvres d’art

Passez à la section suivante pour la configuration et l’installation.

Il est fortement recommandé de créer un nouvel environnement virtuel.

Paquets Python

Activez-le et exécutez la commande suivante pour installer le diffusers module:

pip install diffusers

Pour la dernière version de développement de diffusersveuillez l’installer comme suit :

pip install git+https://github.com/huggingface/diffusers

Ensuite, exécutez la commande suivante pour installer le reste des dépendances :

pip install accelerate torchvision datasets tensorboard

Accélérer

Avant cela, exécutons la commande suivante pour configurer accelerate.

accelerate config

En fonction de votre configuration, vous pouvez utiliser la configuration suivante pour vous entraîner sur un seul GPU :

----------------------------------------------------------------------------------------------------------------------------
In which compute environment are you running?
This machine
----------------------------------------------------------------------------------------------------------------------------
Which type of machine are you using?
No distributed trainingDo you want to run your training on CPU only (even if a GPU is available)? [yes/NO]:
no
Do you wish to optimize your script with torch dynamo?[yes/NO]:
no
Do you want to use DeepSpeed? [yes/NO]: 
no
What GPU(s) (by id) should be used for training on this machine as a comma-seperated list? [all]:
all
----------------------------------------------------------------------------------------------------------------------------
Do you wish to use FP16 or BF16 (mixed precision)?
no
accelerate configuration saved at /home/wfng/.cache/huggingface/accelerate/default_config.yaml

Le référentiel officiel recommande un entraînement sans précision mixte comme précision mixte. Cependant, vous pouvez toujours vous entraîner avec une précision mitigée. Si vous rencontrez une erreur lors de la formation avec une précision mixte, vérifiez le script de formation et assurez-vous qu’il ne se copie pas lors de la génération d’exemples d’images pour l’inspection visuelle. Modifiez la ligne de code suivante

unet = copy.deepcopy(accelerator.unwrap_model(model))

pour

unet = accelerator.unwrap_model(model)

La configuration ci-dessus a été testée sur une seule GeForce RTX 2080 ti avec 12 Go de mémoire. Il est capable de former un modèle de génération d’image inconditionnel avec une taille de lot de 2 et une résolution de 256. Notez que le script de formation rencontrera une erreur de mémoire insuffisante lors de la formation avec une résolution de 512 sur un GPU de 12 Go.

Il existe deux manières de préparer les ensembles de données d’entraînement :

télécharger ou utiliser la plupart des ensembles de données d’images disponibles sur HuggingFace Hub
préparer des images de formation dans un dossier

Jeux de données sur HuggingFace Hub

Met le dataset_name argument au nom de jeu de données unique qui est disponible sur HuggingFace Hub. Il téléchargera les fichiers sur le .cache dossier automatiquement lors de la première exécution. Par la suite, le script de formation réutilisera la version cache des ensembles de données.

Jetez un oeil à l’exemple suivant qui utilise le huggan/pokemon ensembles de données de HuggingFace Hub.

accelerate launch train_unconditional.py 
--dataset_name="huggan/pokemon" 
...

Les jeux de données ci-dessus sont pris de Kaggle qui vient avec Attribution 4.0 International (CC BY 4.0) Licence.

Images personnalisées dans un dossier

Pour charger des ensembles de données locaux, placez toutes les images d’entraînement dans un dossier. Jetez un œil à la structure de dossiers suivante comme référence :

data/xxx.png
data/xxy.png
data/train/xxz.png
data/eval/yyz.png

Il est recommandé d’avoir environ 1 000 images d’entraînement comme référence. Cependant, cela devrait fonctionner tel quel quel que soit le nombre d’ensembles de données d’apprentissage tant que les ensembles de données sont de haute qualité.

Le script de formation identifiera toutes les images du dossier de manière récursive. Réglez simplement le train_data_dir argument au dossier correspondant. Par exemple:

accelerate launch train_unconditional.py 
--train_data_dir="data" 
...

Accéder à l’officiel train_unconditional.py script de formation et enregistrez-le localement dans le répertoire de travail. Le script de formation lui-même est basé sur la dernière version de développement.

Le script signalera une erreur si la version actuelle de diffusers ne correspond pas à la version attendue. Localisez le check_min_version fonction et commentez-la (uniquement applicable si vous utilisez une ancienne version de diffusers):

...
# check_min_version("0.13.0.dev0")

Jeux de données sur HuggingFace Hub

Pour vous entraîner sur des ensembles de données disponibles sur HuggingFace Hub, exécutez simplement la commande suivante pour démarrer l’entraînement :

accelerate launch train_unconditional.py 
--dataset_name="huggan/pokemon" 
--resolution=256 
--output_dir="output-256" 
--train_batch_size=2 
--num_epochs=100 
--gradient_accumulation_steps=1 
--use_ema 
--learning_rate=1e-4 
--lr_warmup_steps=500 
--mixed_precision=no

Remplace le dataset_name avec les ensembles de données souhaités disponibles sur HuggingFace Hub.

resolution — La résolution des images d’entrée, toutes les images des ensembles de données de train/validation seront redimensionnées en conséquence. Une résolution plus élevée nécessite plus de mémoire pendant l’entraînement. Par exemple, réglez-le sur 256 pour former un modèle qui génère des images 256 x 256.
train_batch_size — Taille du lot (par appareil) pour le chargeur de données d’apprentissage. Réduisez la taille du lot pour éviter les erreurs de mémoire insuffisante pendant la formation.
num_epochs — Le nombre d’époques d’entraînement. La valeur par défaut est 100. Vous devriez obtenir un résultat raisonnable à environ 50 époques pour des images d’entraînement de 10 000.
checkpointing_steps — Enregistrer un point de contrôle de l’état de la formation toutes les X mises à jour. Ces points de contrôle ne conviennent qu’à la reprise. La valeur par défaut est 500. Réglez-la sur une valeur plus élevée pour réduire le nombre de points de contrôle enregistrés.

Images personnalisées dans un dossier

Assurez-vous de préparer toutes les images de formation dans un dossier. Par exemple, en supposant que la structure actuelle du répertoire de travail est la suivante :

|- data (folder)
|  |- xxx.png
|  |- xxy.png
|  |- ...
|- train_unconditional.py

Le data contient toutes les images de formation pertinentes pour ce didacticiel.

Exécutez la commande suivante pour commencer à entraîner un modèle de génération d’images inconditionnel à l’aide d’ensembles de données personnalisés :

accelerate launch train_unconditional.py 
--train_data_dir="data" 
--resolution=256 
--output_dir="output-256" 
--train_batch_size=2 
--num_epochs=100 
--gradient_accumulation_steps=1 
--use_ema 
--learning_rate=1e-4 
--lr_warmup_steps=500 
--mixed_precision=no

En fonction du nombre total d’images d’entraînement, l’achèvement de l’entraînement peut prendre un certain temps.

Ignorer le retournement horizontal

Notez que le script de formation effectuera un retournement horizontal aléatoire en interne lors de l’étape de prétraitement de l’image. Par conséquent, les images de sortie finiront par faire face à une direction différente même si les ensembles de données d’apprentissage se composent uniquement de caractères faisant face à une direction fixe.

Étant donné que la formation existante ne vient pas avec un argument pour définir dynamiquement un retournement aléatoire, supprimez simplement le RandomHorizontalFlip() appel de fonction à partir des lignes de code suivantes pour empêcher le retournement horizontal aléatoire lors du prétraitement de l’image :

augmentations = Compose(
[
Resize(args.resolution, interpolation=InterpolationMode.BILINEAR),
CenterCrop(args.resolution),
RandomHorizontalFlip(),
ToTensor(),
Normalize([0.5], [0.5]),
]
)

Le code final devrait être le suivant :

augmentations = Compose(
[
Resize(args.resolution, interpolation=InterpolationMode.BILINEAR),
CenterCrop(args.resolution),
ToTensor(),
Normalize([0.5], [0.5]),
]
)

Notez que l’entraînement sans retournement horizontal peut affecter les performances du modèle.

Enregistrer le modèle à chaque époque N

Par défaut, le script enregistrera un modèle une fois toutes les 10 époques. Utilisez le save_model_epochs argument pour changer la valeur par défaut.

accelerate launch train_unconditional.py 
...
--save_model_epochs=5 
...

Il écrasera les fichiers à output_dir. Pour ceux qui souhaitent conserver tous les modèles enregistrés, il suffit de modifier la ligne de code suivante :

pipeline.save_pretrained(args.output_dir)

pour:

pipeline.save_pretrained(os.path.join(args.output_dir, f"epoch-{epoch}"))

Se référer au validation suivante pour plus d’informations sur le correctif.

Ce faisant, le script enregistrera les modèles dans des dossiers séparés dans le output_dir.

Par exemple:

|- data (folder)
|  |- xxx.png
|  |- xxy.png
|  |- ...
|- output-256
|  |- epoch-10
|  |  |- scheduler
|  |  |- unet
|  |  |- model_index.json
|  |- epoch-20
|  |- ...
|  |- epoch-50
|- train_unconditional.py

Dans le même répertoire de travail, créez un nouveau fichier Python appelé inference.py et ajoutez le code suivant à l’intérieur:

from diffusers import DDIMPipeline, DDIMSchedulerdevice = "cuda"
# load model and scheduler
pipeline = DDIMPipeline.from_pretrained('./output-256/epoch-10', local_files_only=True)
pipeline.scheduler = DDIMScheduler.from_config(pipeline.scheduler.config)
pipeline.to(device)
# generate image
image = pipeline(num_inference_steps=50).images[0]
# save image
image.save("image.png")

Le script ci-dessus est basé sur le pipeline DDIM au lieu de DDPM car le processus de génération d’image est beaucoup plus rapide.

Exécutez la commande suivante pour générer des images de manière inconditionnelle :

python inference.py

Il générera une seule image à chaque exécution. Réglez simplement le batch_size paramètre pour générer N nombre d’images par exécution.

Notez que la consommation de mémoire augmentera à mesure que batch_size augmente. Inférence avec batch_size 1 nécessite environ 4 Go de mémoire lors de l’inférence avec batch_size 4 nécessite environ 10 Go de mémoire.

Par exemple, le code suivant générera 4 images par exécution :

...# generate images
images = pipeline(num_inference_steps=50, batch_size=4).images
# save images
count = 0
for image in images:
count += 1
image.save(f"image-{count}.png")

Voici quelques exemples de résultats de ma formation locale :

Notez que certaines des sorties générées présentent des défauts majeurs. La génération d’images inconditionnelle produit souvent une sortie inattendue qui peut être un avantage pour la créativité.

En fonction des images d’entraînement, certains ensembles de données peuvent ne pas être en mesure de converger correctement même après un entraînement de 100 époques.

Récapitulons quelques-uns des points d’apprentissage de cet article.

Ce didacticiel a commencé par une brève introduction à la génération d’images inconditionnelle et à ses cas d’utilisation.

Ensuite, il est passé aux processus de configuration et d’installation. Cela comprend l’installation du diffusers paquet avec pip et configuration du accelerate module.

Par la suite, il a expliqué comment préparer les ensembles de données soit en utilisant les ensembles de données disponibles sur le HuggingFace Hub, soit via des ensembles de données personnalisés dans un dossier.

Ensuite, il a expliqué en détail l’ensemble du processus de formation, qui comprend certains des arguments de formation utiles.

Enfin, il a exploré comment effectuer une inférence à l’aide du modèle formé sur mesure pour la génération d’images inconditionnelle.

Merci d’avoir lu cet article. N’hésitez pas à consulter mes autres articles. Bonne journée à venir !

Télécharger ici