stable diffusion keras ft
1.0.0
Ce référentiel fournit du code pour une diffusion stable à réglage fin dans les keras. Il est adapté de ce script en étreignant le visage. Le modèle pré-formé utilisé pour le réglage fin provient de Kerascv. Pour connaître le modèle d'origine, consultez cette documentation.
Le code fourni dans ce référentiel est à des fins de recherche uniquement . Veuillez consulter cette section pour en savoir plus sur les cas d'utilisation potentiels et les limitations.
En chargeant ce modèle, vous acceptez la licence CreativeMl Open Rail-M à https://raw.githubusercontent.com/compvis/stable-diffusion/main/license.
Si vous cherchez simplement les ressources qui l'accompagnent de ce référentiel, voici les liens:
Table des matières :
Ce référentiel dispose d'un référentiel sœur (Keras-SD-Serving) qui couvre divers modèles de déploiement pour une diffusion stable.
Mise à jour du 13 janvier 2023 : Ce projet a obtenu la 2e place lors du tout premier concours de prix communautaire Keras organisé par Google.
Après le script original de Hugging Face, ce référentiel utilise également l'ensemble de données Pokémon. Mais il a été régénéré de mieux fonctionner avec tf.data . La version régénérée de l'ensemble de données est hébergée ici. Consultez ce lien pour plus de détails.
Le code de réglage fin est fourni dans finetune.py . Avant d'exécuter une formation, assurez-vous que les dépendances (reportez-vous à requirements.txt ) installées.
Vous pouvez lancer une formation avec les arguments par défaut en exécutant python finetune.py . Exécutez python finetune.py -h pour connaître les arguments de ligne de commande pris en charge. Vous pouvez activer la formation de précision mixte en passant le drapeau --mp .
Lorsque vous lancez une formation, un point de contrôle de modèle de diffusion ne sera généré par époque que si la perte actuelle est inférieure à la précédente.
Pour éviter l'OOM et une formation plus rapide, il est recommandé d'utiliser au moins un GPU V100. Nous avons utilisé un A100.
Quelques détails importants à noter :
Détails de la formation :
Nous avons affiné le modèle sur deux résolutions différentes: 256x256 et 512x512. Nous n'avons varié que la taille du lot et le nombre d'époches pour le réglage fin avec ces deux résolutions différentes. Comme nous n'avons pas utilisé l'accumulation de gradient, nous utilisons cet extrait de code pour dériver le nombre d'époches.
python finetune.py --batch_size 4 --num_epochs 577python finetune.py --img_height 512 --img_width 512 --batch_size 1 --num_epochs 72 --mpPour la résolution 256x256, nous avons intentionnellement réduit le nombre d'époches pour gagner du temps de calcul.
Poids affinés :
Vous pouvez trouver les poids du modèle de diffusion affinés ici.
L'ensemble de données Pokémon par défaut utilisé dans ce référentiel est livré avec la structure suivante:
pokemon_dataset/
data.csv
image_24.png
image_3.png
image_550.png
image_700.png
... data.csv ressemble à:
Tant que votre ensemble de données personnalisé suit cette structure, vous n'avez pas besoin de changer quoi que ce soit dans la base de code actuelle, à l'exception du dataset_archive .
Dans le cas où votre ensemble de données a plusieurs légendes par image, vous pouvez en sélectionner un dans le pool de légendes par image pendant la formation.
Sur la base de l'ensemble de données, vous devrez peut-être régler les hyperparamètres.
import keras_cv
import matplotlib . pyplot as plt
from tensorflow import keras
IMG_HEIGHT = IMG_WIDTH = 512
def plot_images ( images , title ):
plt . figure ( figsize = ( 20 , 20 ))
for i in range ( len ( images )):
ax = plt . subplot ( 1 , len ( images ), i + 1 )
plt . title ( title )
plt . imshow ( images [ i ])
plt . axis ( "off" )
# We just have to load the fine-tuned weights into the diffusion model.
weights_path = keras . utils . get_file (
origin = "https://huggingface.co/sayakpaul/kerascv_sd_pokemon_finetuned/resolve/main/ckpt_epochs_72_res_512_mp_True.h5"
)
pokemon_model = keras_cv . models . StableDiffusion (
img_height = IMG_HEIGHT , img_width = IMG_WIDTH
)
pokemon_model . diffusion_model . load_weights ( weights_path )
# Generate images.
generated_images = pokemon_model . text_to_image ( "Yoda" , batch_size = 3 )
plot_images ( generated_images , "Fine-tuned on the Pokemon dataset" ) Vous pouvez apporter votre weights_path (devrait être compatible avec le diffusion_model ) et réutiliser l'extrait de code.
Consultez ce carnet Colab pour jouer avec le code d'inférence.
Initialement, nous avons affiné le modèle sur une résolution de 256x256. Voici quelques résultats ainsi que des comparaisons avec les résultats du modèle d'origine.
| Images | Invite |
|---|---|
| Yoda | |
| chat robotique avec des ailes | |
| Bonjour Kitty |
Nous pouvons voir que le modèle affiné a des sorties plus stables que le modèle d'origine. Même si les résultats peuvent être esthétiquement améliorés, les effets de réglage fin sont visibles. De plus, nous avons suivi les mêmes hyperparamètres du script de Huging Face pour la résolution 256x256 (à part le nombre d'époches et la taille du lot). Avec de meilleurs hyperparamètres, les résultats s'amélioreront probablement.
Pour la résolution 512x512, nous observons quelque chose de similaire. Ainsi, nous avons expérimenté le paramètre unconditional_guidance_scale et remarqué que lorsqu'il est défini sur 40 (tout en gardant les autres arguments fixes), les résultats sont mieux sortis.
| Images | Invite |
|---|---|
| Yoda | |
| chat robotique avec des ailes | |
| Bonjour Kitty |
Remarque : le réglage fin sur le 512x512 est toujours en cours à ce jour. Mais il faut beaucoup de temps pour terminer une seule époque sans la présence d'une formation distribuée et d'une accumulation de gradient. Les résultats ci-dessus proviennent du point de contrôle dérivé après 60e époque.
Avec une recette similaire (mais formée pour plus d'étapes d'optimisation), les laboratoires lambda montrent des résultats incroyables.
