ai art generator
1.0.0
Juste une note que j'ai lancé Dream Factory, une mise à niveau significative de celui-ci. Il dispose d'une interface graphique (en option), d'une véritable prise en charge multi-GPU simultanée, d'une galerie intégrée avec prise en charge complète des métadonnées EXIF et de nombreuses autres nouvelles fonctionnalités.
J'ai abandonné le support de VQGAN et Disco Diffusion pour me concentrer sur la diffusion stable, donc si vous voulez VQGAN et/ou Disco Diffusion, vous devriez vous en tenir à cela pour le moment. Sinon j’encourage tout le monde à migrer vers Dream Factory ! Je continuerai à corriger les bugs sur ce dépôt, mais je n'ajouterai probablement pas de nouvelles fonctionnalités à l'avenir.
Pour automatiser localement la création de grands lots d’œuvres d’art générées par l’IA. Mettez votre (vos) GPU à profit pour créer des illustrations générées par l'IA 24h/24 et 7j/7 avec la possibilité d'automatiser de grandes files d'attente d'invites combinant des sujets, des styles/artistes sélectionnés par l'utilisateur et bien plus encore ! Plus d'informations sur les modèles disponibles après les exemples de photos.
Quelques exemples d'images que j'ai créées via ce processus (elles sont sélectionnées et affinées) : 
Notez que je n'ai pas créé ni formé les modèles utilisés dans ce projet, et que je n'ai pas non plus été impliqué dans le codage original. J'ai simplement modifié les versions originales de Colab pour qu'elles s'exécutent localement et j'ai ajouté une prise en charge de l'automatisation. Modèles actuellement pris en charge, avec des liens vers leurs implémentations d'origine :
Vous aurez besoin d'un GPU Nvidia, de préférence avec une quantité décente de VRAM. 12 Go de VRAM suffisent pour des images de sortie 512 x 512 selon le modèle et les paramètres, et 8 Go devraient suffire pour 384 x 384 (8 Go doivent être considérés comme un minimum raisonnable !). Pour générer des images 1 024 x 1 024, vous aurez besoin d'environ 24 Go de VRAM ou plus. La génération de petites images puis la mise à l'échelle via ESRGAN ou un autre package fournissent également de très bons résultats.
Il devrait être possible de fonctionner sur un GPU AMD, mais vous devrez être sous Linux pour installer la version ROCm de Pytorch. Je n'ai pas de GPU AMD à intégrer à une machine Linux, je ne l'ai donc pas testé moi-même.
Ces instructions ont été testées sur un ordinateur de bureau Windows 10 avec un GPU Nvidia 3080 Ti (12 Go de VRAM), ainsi que sur un système Ubuntu Server 20.04.3 avec un ancien GPU Nvidia Tesla M40 (24 Go de VRAM).
[1] Installez Anaconda, ouvrez le terminal racine et créez un nouvel environnement (et activez-le) :
conda create --name ai-art python=3.9
conda activate ai-art
[2] Installez Pytorch :
conda install pytorch torchvision torchaudio cudatoolkit=11.3 -c pytorch
Notez que vous pouvez personnaliser votre installation Pytorch en utilisant l'outil en ligne situé ici.
[3] Installez les autres packages Python requis :
conda install -c anaconda git urllib3
pip install transformers keyboard pillow ftfy regex tqdm omegaconf pytorch-lightning IPython kornia imageio imageio-ffmpeg einops torch_optimizer
[4] Clonez ce référentiel et basculez vers son répertoire :
git clone https://github.com/rbbrdckybk/ai-art-generator
cd ai-art-generator
Notez que les utilisateurs Linux peuvent avoir besoin de guillemets simples autour de l'URL dans la commande clone.
[5] Clonez les référentiels requis supplémentaires :
git clone https://github.com/openai/CLIP
git clone https://github.com/CompVis/taming-transformers
[6] Téléchargez les fichiers de point de contrôle du modèle pré-entraîné VQGAN par défaut :
mkdir checkpoints
curl -L -o checkpoints/vqgan_imagenet_f16_16384.yaml -C - "https://heibox.uni-heidelberg.de/d/a7530b09fed84f80a887/files/?p=%2Fconfigs%2Fmodel.yaml&dl=1"
curl -L -o checkpoints/vqgan_imagenet_f16_16384.ckpt -C - "https://heibox.uni-heidelberg.de/d/a7530b09fed84f80a887/files/?p=%2Fckpts%2Flast.ckpt&dl=1"
Notez que les utilisateurs de Linux doivent remplacer les guillemets doubles dans les commandes curl par des guillemets simples.
[7] (Facultatif) Téléchargez des modèles pré-entraînés supplémentaires :
Des modèles supplémentaires ne sont pas nécessaires, mais vous offrent plus d'options. Voici une bonne liste de modèles pré-entraînés disponibles.
Par exemple, si vous souhaitez également le modèle FFHQ (entraîné sur les visages) :
curl -L -o checkpoints/ffhq.yaml -C - "https://app.koofr.net/content/links/0fc005bf-3dca-4079-9d40-cdf38d42cd7a/files/get/2021-04-23T18-19-01-project.yaml?path=%2F2021-04-23T18-19-01_ffhq_transformer%2Fconfigs%2F2021-04-23T18-19-01-project.yaml&force"
curl -L -o checkpoints/ffhq.ckpt -C - "https://app.koofr.net/content/links/0fc005bf-3dca-4079-9d40-cdf38d42cd7a/files/get/last.ckpt?path=%2F2021-04-23T18-19-01_ffhq_transformer%2Fcheckpoints%2Flast.ckpt"
[8] (Facultatif) Testez VQGAN+CLIP :
python vqgan.py -s 128 128 -i 200 -p "a red apple" -o output/output.png
Vous devriez voir output.png créé dans le répertoire de sortie, qui devrait ressembler vaguement à une pomme.
[9] Installez les packages pour une diffusion guidée par CLIP (si vous n'êtes intéressé que par VQGAN+CLIP, vous pouvez tout ignorer d'ici à la fin) :
pip install ipywidgets omegaconf torch-fidelity einops wandb opencv-python matplotlib lpips datetime timm
conda install pandas
[10] Dépôts de clones pour une diffusion guidée par CLIP :
git clone https://github.com/crowsonkb/guided-diffusion
git clone https://github.com/assafshocher/ResizeRight
git clone https://github.com/CompVis/latent-diffusion
[11] Téléchargez les modèles nécessaires à la diffusion guidée par CLIP :
mkdir contentmodels
curl -L -o content/models/256x256_diffusion_uncond.pt -C - "https://openaipublic.blob.core.windows.net/diffusion/jul-2021/256x256_diffusion_uncond.pt"
curl -L -o content/models/512x512_diffusion_uncond_finetune_008100.pt -C - "http://batbot.tv/ai/models/guided-diffusion/512x512_diffusion_uncond_finetune_008100.pt"
curl -L -o content/models/secondary_model_imagenet_2.pth -C - "https://ipfs.pollinations.ai/ipfs/bafybeibaawhhk7fhyhvmm7x24zwwkeuocuizbqbcg5nqx64jq42j75rdiy/secondary_model_imagenet_2.pth"
mkdir contentmodelssuperres
curl -L -o content/models/superres/project.yaml -C - "https://heibox.uni-heidelberg.de/f/31a76b13ea27482981b4/?dl=1"
curl -L -o content/models/superres/last.ckpt -C - "https://heibox.uni-heidelberg.de/f/578df07c8fc04ffbadf3/?dl=1"
Notez que les utilisateurs de Linux doivent à nouveau remplacer les guillemets doubles dans les commandes curl par des guillemets simples et remplacer les barres obliques inverses de mkdir par des barres obliques.
[12] (Facultatif) Testez la diffusion guidée par CLIP :
python diffusion.py -s 128 128 -i 200 -p "a red apple" -o output.png
Vous devriez voir output.png créé dans le répertoire de sortie, qui devrait ressembler vaguement à une pomme.
[13] Dépôt Clone Stable Diffusion (si vous n'êtes pas intéressé par SD, vous pouvez tout ignorer d'ici à la fin) :
git clone https://github.com/rbbrdckybk/stable-diffusion
[14] Installez les dépendances supplémentaires requises par Stable Diffusion :
pip install diffusers
[15] Téléchargez le fichier de point de contrôle pré-entraîné Stable Diffusion :
mkdir stable-diffusionmodelsldmstable-diffusion-v1
curl -L -o stable-diffusion/models/ldm/stable-diffusion-v1/model.ckpt -C - "https://huggingface.co/CompVis/stable-diffusion-v-1-4-original/resolve/main/sd-v1-4.ckpt"
Si la commande curl ne télécharge pas le point de contrôle, il est bloqué derrière une connexion. Vous devrez vous inscrire ici (nécessite uniquement une adresse e-mail et un nom), puis vous pourrez télécharger le fichier de point de contrôle ici.
Après le téléchargement, vous devrez placer le fichier .ckpt dans le répertoire créé ci-dessus et le nommer model.ckpt .
[16] (Facultatif) Test de diffusion stable :
Le moyen le plus simple de tester SD est de créer un simple fichier d'invite avec !PROCESS = stablediff et un seul sujet. Voir example-prompts.txt et la section suivante pour plus d'informations. En supposant que vous créez d'abord un fichier d'invite simple appelé test.txt , vous pouvez tester en exécutant :
python make_art.py test.txt
Les images doivent être enregistrées dans le répertoire de sortie en cas de succès (organisées en sous-répertoires nommés pour la date et le fichier d'invite).
[17] Configurez ESRGAN/GFPGAN (si vous ne prévoyez pas de mettre à niveau les images, vous pouvez ignorer ceci et tout le reste) :
git clone https://github.com/xinntao/Real-ESRGAN
pip install basicsr facexlib gfpgan
cd Real-ESRGAN
curl -L -o experiments/pretrained_models/RealESRGAN_x4plus.pth -C - "https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth"
python setup.py develop
cd ..
Vous avez terminé !
Si vous rencontrez des erreurs en dehors d'une VRAM GPU insuffisante lors de l'exécution et que vous n'avez pas mis à jour votre installation depuis un certain temps, essayez de mettre à jour certains des packages les plus importants, par exemple :
pip install transformers -U
Essentiellement, il vous suffit de créer un fichier texte contenant les sujets et les styles que vous souhaitez utiliser pour générer des images. Si vous avez 5 sujets et 20 styles dans votre fichier d'invite, alors un total de 100 images de sortie seront créées (20 images de style pour chaque sujet).
Jetez un œil à example-prompts.txt pour voir à quoi devraient ressembler les fichiers d'invite. Vous pouvez tout ignorer sauf les zones [sujets] et [styles] pour le moment. Les lignes commençant par un « # » sont des commentaires et seront ignorées, ainsi que les lignes commençant par un « ! » sont des directives de paramètres et sont expliquées dans la section suivante. Pour l'instant, modifiez simplement les exemples de sujets et de styles avec ce que vous souhaitez utiliser.
Après avoir rempli example-prompts.txt à votre guise, vous pouvez simplement exécuter :
python make_art.py example-prompts.txt
En fonction de votre matériel et de vos paramètres, la création de chaque image prendra entre quelques secondes et quelques heures (sur du matériel plus ancien). Si vous pouvez exécuter Stable Diffusion, je le recommande fortement pour obtenir les meilleurs résultats, tant en termes de vitesse que de qualité d'image.
Les images de sortie sont créées par défaut dans le répertoire output/[date actuelle]-[nom du fichier d'invite]/ . Le répertoire de sortie contiendra un fichier JPG pour chaque image nommé en fonction du sujet et du style utilisés pour la créer. Ainsi, par exemple, si vous avez "un singe sur une moto" comme sujet et "par Picasso" comme style, l'image de sortie sera créée sous la forme sortie/[date actuelle]-[nom du fichier d'invite]/a. -monkey-on-a-motorcycle-by-picasso.jpg (les noms de fichiers varient un peu en fonction du processus utilisé).
Vous pouvez appuyer sur CTRL+SHIFT+P à tout moment pour suspendre l'exécution (la pause prendra effet lorsque le rendu de l'image actuelle sera terminé). Appuyez à nouveau sur CTRL+SHIFT+P pour reprendre la pause. Utile si vous l'exécutez sur votre ordinateur principal et que vous devez utiliser votre GPU pour autre chose pendant un certain temps. Vous pouvez également appuyer sur CTRL+SHIFT+R pour recharger le fichier d'invite si vous l'avez modifié (la file d'attente de travail actuelle sera supprimée et une nouvelle sera créée à partir du contenu de votre fichier d'invite). Notez que la saisie au clavier ne fonctionne que sous Windows.
Les paramètres utilisés pour créer chaque image sont enregistrés par défaut sous forme de métadonnées dans chaque fichier JPG de sortie. Vous pouvez relire les informations de métadonnées à l'aide de n'importe quel utilitaire EXIF, ou simplement en cliquant avec le bouton droit sur le fichier image dans l'Explorateur Windows et en sélectionnant « Propriétés », puis en cliquant sur le volet « Détails ». Le champ "commentaires" contient la commande utilisée pour créer l'image.
Des directives peuvent être incluses dans votre fichier d'invite pour modifier les paramètres de toutes les invites qui le suivent. Ces directives de paramètres sont spécifiées en les plaçant sur leur propre ligne à l'intérieur de la zone [subject] du fichier d'invite, au format suivant :
![paramètre à modifier] = [nouvelle valeur]
Pour [setting to change] , les directives valides sont :
Quelques exemples :
!PROCESS = vqgan
Cela définira le processus actuel de génération d’images IA. Les options valides sont vqgan pour VQGAN+CLIP, diffusion pour une diffusion guidée par CLIP (Disco Diffusion) ou stablediff pour Stable Diffusion.
!CUDA_DEVICE = 0
Cela forcera l'utilisation du GPU 0 (la valeur par défaut). Utile si vous disposez de plusieurs GPU : vous pouvez exécuter plusieurs instances, chacune avec son propre fichier d'invite spécifiant un ID GPU unique.
!WIDTH = 384
!HEIGHT = 384
Cela définira la taille de l’image de sortie sur 384x384. Une taille de sortie plus grande nécessite plus de VRAM GPU. Notez que pour une diffusion stable, ces valeurs doivent être des multiples de 64.
!TRANSFORMER = ffhq
Cela indiquera à VQGAN d'utiliser le transformateur FFHQ (un peu meilleur pour les visages), au lieu de la valeur par défaut (vqgan_imagenet_f16_16384). Vous pouvez suivre l'étape 7 des instructions de configuration ci-dessus pour obtenir le transformateur ffhq, ainsi qu'un lien vers plusieurs autres.
Tout ce que vous spécifiez ici DOIT exister dans le répertoire des points de contrôle en tant que fichier .ckpt et .yaml.
!INPUT_IMAGE = samples/face-input.jpg
Cela utilisera samples/face-input.jpg (ou toute autre image que vous spécifiez) comme image de départ, au lieu du bruit aléatoire par défaut. Les images d’entrée doivent avoir le même rapport hauteur/largeur que vos images de sortie pour de bons résultats. Notez que lors de l'utilisation avec Stable Diffusion, la taille de l'image de sortie sera la même que celle de votre image d'entrée (vos paramètres de hauteur/largeur seront ignorés).
!SEED = 42
Cela utilisera 42 comme valeur de départ d'entrée, au lieu d'un nombre aléatoire (la valeur par défaut). Utile pour la reproductibilité : lorsque tous les autres paramètres sont identiques, l'utilisation de la même valeur de départ devrait produire une image identique sur plusieurs analyses. Réglez sur rien ou sur -1 pour réinitialiser à l'aide d'une valeur aléatoire.
!INPUT_IMAGE =
Définir l’une de ces valeurs sur rien la ramènera à sa valeur par défaut. Ainsi, dans cet exemple, aucune image de départ ne sera utilisée.
!STEPS = 50
Définit le nombre d'étapes (similaire aux itérations) lors de l'utilisation de Stable Diffusion sur 50 (valeur par défaut). Des valeurs plus élevées prennent plus de temps et peuvent améliorer la qualité de l'image. Les valeurs supérieures à 100 produisent rarement des différences notables par rapport aux valeurs inférieures.
!SCALE = 7.5
Définit l'échelle de guidage lors de l'utilisation de la diffusion stable sur 7,5 (valeur par défaut). Des valeurs plus élevées (jusqu'à un certain point, au-delà d'environ 25 résultats peuvent être étranges) feront que la sortie adhèrera plus étroitement à votre invite.
!SAMPLES = 1
Définit le nombre de fois à échantillonner lors de l’utilisation de la diffusion stable sur 1 (valeur par défaut). Les valeurs supérieures à 1 entraîneront la création de plusieurs images de sortie pour chaque invite, avec un léger gain de temps par image. Il n'y a aucun coût en VRAM GPU requis pour incrémenter cela.
!STRENGTH = 0.75
Définit l'influence de l'image de départ sur 0,75 (valeur par défaut). Uniquement pertinent lors de l’utilisation de Stable Diffusion avec une image d’entrée. Les valeurs valides sont comprises entre 0 et 1, 1 correspondant à la destruction complète de l'image d'entrée et 0 correspondant au maintien de l'image de départ complètement intacte. Les valeurs comprises entre 0,25 et 0,75 ont tendance à donner des résultats intéressants.
!SD_LOW_MEMORY = no
Utiliser un dépôt forké avec des besoins en mémoire GPU bien inférieurs lors de l'utilisation de Stable Diffusion (oui/non) ? En définissant cette valeur sur oui, vous passerez à l'utilisation d'une version SD à mémoire optimisée qui vous permettra de créer des images de plus haute résolution avec beaucoup moins de mémoire GPU (les images 512 x 512 ne devraient nécessiter qu'environ 4 Go de VRAM). Le compromis est que l’inférence est beaucoup plus lente que le repo officiel par défaut. A titre de comparaison : sur un RTX 3060, la création d'une image 512x512 avec les paramètres par défaut prend environ 12 secondes ; avec !SD_LOW_MEMORY = yes , la même image prend plus d'une minute. Il est recommandé de désactiver cette option, sauf si vous disposez de moins de 8 Go de VRAM GPU ou si vous souhaitez expérimenter la création d'images plus grandes avant la mise à l'échelle.
!USE_UPSCALE = no
Mettre automatiquement à l'échelle les images créées avec Stable Diffusion (oui/non) ? Utilise ESRGAN/GFPGAN (voir les paramètres supplémentaires ci-dessous).
!UPSCALE_AMOUNT = 2
Dans quelle mesure mettre à l'échelle lorsque !USE_UPSCALE = yes . La valeur par défaut est 2,0x ; des valeurs plus élevées nécessitent plus de VRAM et de temps.
!UPSCALE_FACE_ENH = no
S'il faut ou non utiliser GFPGAN (vs ESRGAN par défaut) lors de la mise à l'échelle. GFPGAN fournit les meilleurs résultats avec les visages, mais peut donner des résultats légèrement moins bons s'il est utilisé sur des sujets autres que des visages.
!UPSCALE_KEEP_ORG = no
Conserver l'image originale non modifiée lors de la mise à l'échelle (oui/non) ? Si la valeur est non (valeur par défaut), l'image originale sera supprimée. Si la valeur est oui, l'image originale sera enregistrée dans un sous-répertoire /original du dossier de sortie de l'image.
!REPEAT = no
Lorsque toutes les tâches du fichier d'invite sont terminées, redémarrez en haut du fichier (oui/non) ? La valeur par défaut est non, ce qui mettra simplement fin à l'exécution lorsque toutes les tâches seront terminées.
À FAIRE : terminer les exemples de paramètres et ajouter des conseils/exemples d'utilisation, documenter random_art.py
