dalle flow
1.0.0
Un humain dans la boucle ? flux de travail pour créer des images HD à partir de texte
Dall · e Flow est un flux de travail interactif pour générer des images à haute définition à partir de l'invite de texte. Tout d'abord, il exploite Dall · E-Mega, GLID-3 XL et diffusion stable pour générer des candidats d'image, puis appelle Clip-as-Service pour classer les candidats à l'invite. Le candidat préféré est alimenté à Glid-3 XL pour la diffusion, qui enrichit souvent la texture et le fond. Enfin, le candidat est augmenté à 1024x1024 via Swinir.
Le flux de Dall · e est construit avec Jina dans une architecture client-serveur, ce qui lui donne une grande évolutivité, un streaming non bloquant et une interface pythonique moderne. Le client peut interagir avec le serveur via GRPC / WebSocket / HTTP avec TLS.
Pourquoi humain dans la boucle? L'art génératif est un processus créatif. Alors que les avancées récentes de Dall · e se déchaînent la créativité des gens, un UX / UI-sorti-sortie unique verrouille l'imagination à une seule possibilité, ce qui est mauvais, peu importe à quel point ce résultat unique est bon. Le flux de Dall · e est une alternative à la ligne unique, en formalisant l'art génératif en tant que procédure itérative.
Le flux de Dall · e est dans l'architecture client-serveur.
grpcs://api.clip.jina.ai:2096 (nécessite jina >= v3.11.0 ), vous devez d'abord obtenir un jeton d'accès à partir d'ici. Voir Utiliser le clip-as-service pour plus de détails.flow_parser.py .grpcs://dalle-flow.dev.jina.ai . Toutes les connexions sont maintenant avec le cryptage TLS, veuillez rouvrir le cahier dans Google Colab.p2.x8large .ViT-L/14@336px à partir de clip-as-service, steps 100->200 .
L'utilisation du client est super facile. Les étapes suivantes sont mieux exécutées dans Jupyter Notebook ou Google Colab.
Vous devrez d'abord installer Docarray et Jina:
pip install " docarray[common]>=0.13.5 " jinaNous avons fourni un serveur de démonstration à jouer:
️ En raison des demandes massives, notre serveur peut être un retard en réponse. Pourtant, nous sommes très confiants pour garder le temps de disponibilité élevé. Vous pouvez également déployer votre propre serveur en suivant les instructions ici.
server_url = 'grpcs://dalle-flow.dev.jina.ai'Définissons maintenant l'invite:
prompt = 'an oil painting of a humanoid robot playing chess in the style of Matisse'Soudissons-le au serveur et visualisons les résultats:
from docarray import Document
doc = Document ( text = prompt ). post ( server_url , parameters = { 'num_images' : 8 })
da = doc . matches
da . plot_image_sprites ( fig_size = ( 10 , 10 ), show_index = True ) Ici, nous générons 24 candidats, 8 à partir de dalle-méga, 8 à partir de GLID3 XL et 8 à partir de diffusion stable, ceci est tel que défini dans num_images , qui prend environ environ 2 minutes. Vous pouvez utiliser une valeur plus petite si elle est trop longue pour vous.
Les 24 candidats sont triés par Clip-as-Service, avec Index- 0 comme le meilleur candidat jugé par Clip. Bien sûr, vous pouvez penser différemment. Remarquez le numéro dans le coin supérieur gauche? Sélectionnez celui que vous aimez le plus et obtenez une meilleure vue:
fav_id = 3
fav = da [ fav_id ]
fav . embedding = doc . embedding
fav . display ()
Soumissionons maintenant les candidats sélectionnés au serveur pour diffusion.
diffused = fav . post ( f' { server_url } ' , parameters = { 'skip_rate' : 0.5 , 'num_images' : 36 }, target_executor = 'diffusion' ). matches
diffused . plot_image_sprites ( fig_size = ( 10 , 10 ), show_index = True ) Cela donnera 36 images basées sur l'image sélectionnée. Vous pouvez permettre au modèle d'improviser davantage en donnant skip_rate une valeur proche de zéro, ou une valeur proche d'un pour forcer sa proximité avec l'image donnée. Toute la procédure dure environ 2 minutes.
Sélectionnez l'image que vous aimez le plus et donnez-lui de plus près:
dfav_id = 34
fav = diffused [ dfav_id ]
fav . display ()
Enfin, soumettez-vous au serveur pour la dernière étape: augmente à 1024 x 1024px.
fav = fav . post ( f' { server_url } /upscale' )
fav . display ()C'est ça! C'est celui-là . Si ce n'est pas satisfait, veuillez répéter la procédure.
BTW, Docarray est une structure de données puissante et facile à utiliser pour les données non structurées. Il est super productif pour les scientifiques des données qui travaillent dans un domaine cross / multimodal. Pour en savoir plus sur Docarray, veuillez consulter les documents.
Vous pouvez héberger votre propre serveur en suivant les instructions ci-dessous.
Le flux de Dall · E nécessite un GPU avec 21 Go de VRAM à son apogée. Tous les services sont pressés dans ce GPU, cela comprend (à peu près)
config.yml , 512x512)Les astuces raisonnables suivantes peuvent être utilisées pour réduire davantage VRAM:
Il nécessite au moins 50 Go d'espace gratuit sur le disque dur, principalement pour télécharger des modèles pré-entraînés.
Internet à grande vitesse est requis. Internet lent / instable peut lancer un délai de délai frustrant lors du téléchargement des modèles.
L'environnement uniquement du processeur n'est pas testé et ne fonctionnera probablement pas. Google Colab lance probablement OOM et ne fonctionnera donc pas non plus.
Si vous avez installé Jina, l'organigramme ci-dessus peut être généré via:
# pip install jina
jina export flowchart flow.yml flow.svgSi vous souhaitez utiliser une diffusion stable, vous devrez d'abord enregistrer un compte sur le site Web HuggingFace et accepter les termes et conditions du modèle. Après vous être connecté, vous pouvez trouver la version du modèle requise en allant ici:
Compvis / sd-v1-5-painting.ckpt
Dans la section Téléchargez les poids , cliquez sur le lien pour sd-v1-x.ckpt . Les derniers poids au moment de la rédaction sont sd-v1-5.ckpt .
Utilisateurs de Docker : placez ce fichier dans un dossier nommé ldm/stable-diffusion-v1 et renommez-le model.ckpt . Suivez soigneusement les instructions ci-dessous car SD n'est pas activé par défaut.
Utilisateurs natifs : placez ce fichier dans dalle/stable-diffusion/models/ldm/stable-diffusion-v1/model.ckpt après avoir terminé le reste des étapes sous "Run nativement". Suivez soigneusement les instructions ci-dessous car SD n'est pas activé par défaut.
Nous avons fourni une image docker prédéfinie qui peut être tirée directement.
docker pull jinaai/dalle-flow:latestNous avons fourni un dockerfile qui vous permet d'exécuter un serveur hors de la boîte.
Notre dockerfile utilise CUDA 11.6 comme image de base, vous voudrez peut-être l'ajuster en fonction de votre système.
git clone https://github.com/jina-ai/dalle-flow.git
cd dalle-flow
docker build --build-arg GROUP_ID= $( id -g ${USER} ) --build-arg USER_ID= $( id -u ${USER} ) -t jinaai/dalle-flow .Le bâtiment prendra 10 minutes avec une vitesse Internet moyenne, ce qui se traduit par une image Docker de 18 Go.
Pour l'exécuter, faites simplement:
docker run -p 51005:51005
-it
-v $HOME /.cache:/home/dalle/.cache
--gpus all
jinaai/dalle-flowAlternativement, vous pouvez également exécuter avec certains workflows activés ou désactivés pour éviter les plantages hors mémoire. Pour ce faire, passer l'une de ces variables d'environnement:
DISABLE_DALLE_MEGA
DISABLE_GLID3XL
DISABLE_SWINIR
ENABLE_STABLE_DIFFUSION
ENABLE_CLIPSEG
ENABLE_REALESRGAN
Par exemple, si vous souhaitez désactiver les workflows GLID3XL, exécutez:
docker run -e DISABLE_GLID3XL= ' 1 '
-p 51005:51005
-it
-v $HOME /.cache:/home/dalle/.cache
--gpus all
jinaai/dalle-flow-v $HOME/.cache:/root/.cache évite le téléchargement de modèle répété sur chaque exécution docker.-p 51005:51005 est votre port public hôte. Assurez-vous que les gens peuvent accéder à ce port si vous servez publiquement. Le deuxième parmi de celui-ci est le port défini dans Flow.yml.ENABLE_STABLE_DIFFUSION .ENABLE_CLIPSEG .ENABLE_REALESRGAN . La diffusion stable ne peut être activée que si vous avez téléchargé les poids et les rendre disponibles en tant que volume virtuel tout en activant l'indicateur environnemental ( ENABLE_STABLE_DIFFUSION ) pour SD .
Vous auriez dû auparavant mettre les poids dans un dossier nommé ldm/stable-diffusion-v1 et les étiqueter model.ckpt . Remplacez YOUR_MODEL_PATH/ldm ci-dessous par le chemin de votre propre système pour tuer les poids dans l'image Docker.
docker run -e ENABLE_STABLE_DIFFUSION= " 1 "
-e DISABLE_DALLE_MEGA= " 1 "
-e DISABLE_GLID3XL= " 1 "
-p 51005:51005
-it
-v YOUR_MODEL_PATH/ldm:/dalle/stable-diffusion/models/ldm/
-v $HOME /.cache:/home/dalle/.cache
--gpus all
jinaai/dalle-flowVous devriez voir l'écran comme suivant une fois en cours d'exécution:
Notez que contrairement à la course native, l'exécution à l'intérieur de Docker peut donner une barre de progrès, des journaux de couleur et des impressions moins vifs. Cela est dû aux limites du terminal dans un conteneur Docker. Cela n'affecte pas l'utilisation réelle.
L'exécution native nécessite des étapes manuelles, mais il est souvent plus facile de déboguer.
mkdir dalle && cd dalle
git clone https://github.com/jina-ai/dalle-flow.git
git clone https://github.com/jina-ai/SwinIR.git
git clone --branch v0.0.15 https://github.com/AmericanPresidentJimmyCarter/stable-diffusion.git
git clone https://github.com/CompVis/latent-diffusion.git
git clone https://github.com/jina-ai/glid-3-xl.git
git clone https://github.com/timojl/clipseg.gitVous devriez avoir la structure du dossier suivant:
dalle/
|
|-- Real-ESRGAN/
|-- SwinIR/
|-- clipseg/
|-- dalle-flow/
|-- glid-3-xl/
|-- latent-diffusion/
|-- stable-diffusion/
cd dalle-flow
python3 -m virtualenv env
source env/bin/activate && cd -
pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu116
pip install numpy tqdm pytorch_lightning einops numpy omegaconf
pip install https://github.com/crowsonkb/k-diffusion/archive/master.zip
pip install git+https://github.com/AmericanPresidentJimmyCarter/[email protected]
pip install basicsr facexlib gfpgan
pip install realesrgan
pip install https://github.com/AmericanPresidentJimmyCarter/xformers-builds/raw/master/cu116/xformers-0.0.14.dev0-cp310-cp310-linux_x86_64.whl &&
cd latent-diffusion && pip install -e . && cd -
cd stable-diffusion && pip install -e . && cd -
cd SwinIR && pip install -e . && cd -
cd glid-3-xl && pip install -e . && cd -
cd clipseg && pip install -e . && cd -Il y a des modèles de couple que nous devons télécharger pour GLID-3-XL si vous utilisez cela:
cd glid-3-xl
wget https://dall-3.com/models/glid-3-xl/bert.pt
wget https://dall-3.com/models/glid-3-xl/kl-f8.pt
wget https://dall-3.com/models/glid-3-xl/finetune.pt
cd - clipseg et RealESRGAN vous obligent à définir un chemin de dossier de cache correct, généralement quelque chose comme $ home /.
cd dalle-flow
pip install -r requirements.txt
pip install jax~=0.3.24 Vous êtes maintenant sous dalle-flow/ , exécutez la commande suivante:
# Optionally disable some generative models with the following flags when
# using flow_parser.py:
# --disable-dalle-mega
# --disable-glid3xl
# --disable-swinir
# --enable-stable-diffusion
python flow_parser.py
jina flow --uses flow.tmp.ymlVous devriez voir cet écran immédiatement:
Au premier départ, il faudra ~ 8 minutes pour télécharger le modèle MEGA DALL · E et d'autres modèles nécessaires. Les courses de procédure ne devraient prendre que environ 1 minute pour atteindre le message de réussite.
Quand tout sera prêt, vous verrez:
Bravo! Vous devriez maintenant pouvoir exécuter le client.
Vous pouvez modifier et étendre le flux de serveur comme vous le souhaitez, par exemple, modifier le modèle, ajoutant de la persistance ou même publication automatique à Instagram / Opensesea. Avec Jina et Docarray, vous pouvez facilement rendre le nuage de flux de Dall et prêt pour la production.
Pour réduire l'utilisation de VRAM, vous pouvez utiliser le CLIP-as-service comme exécuteur externe disponible gratuitement sur grpcs://api.clip.jina.ai:2096 .
Tout d'abord, assurez-vous d'avoir créé un jeton d'accès à partir du site Web de la console ou de la CLI comme suivant
jina auth token create < name of PAT > -e < expiration days > Ensuite, vous devez modifier les configurations liées à l'exécuteur ( host , port , external , tls et grpc_metadata ) de flow.yml .
...
- name : clip_encoder
uses : jinahub+docker://CLIPTorchEncoder/latest-gpu
host : ' api.clip.jina.ai '
port : 2096
tls : true
external : true
grpc_metadata :
authorization : " <your access token> "
needs : [gateway]
...
- name : rerank
uses : jinahub+docker://CLIPTorchEncoder/latest-gpu
host : ' api.clip.jina.ai '
port : 2096
uses_requests :
' / ' : rank
tls : true
external : true
grpc_metadata :
authorization : " <your access token> "
needs : [dalle, diffusion] Vous pouvez également utiliser le flow_parser.py pour générer et exécuter automatiquement le flux avec en utilisant le CLIP-as-service comme exécuteur externe:
python flow_parser.py --cas-token " <your access token>'
jina flow --uses flow.tmp.yml
️ grpc_metadatan'est disponible qu'après Jinav3.11.0. Si vous utilisez une version plus ancienne, veuillez passer à la dernière version.
Maintenant, vous pouvez utiliser le CLIP-as-service dans votre flux.
Le flux de Dall · e est soutenu par Jina AI et sous licence sous Apache-2.0. Nous embauchons activement des ingénieurs d'IA, des ingénieurs de solution pour construire le prochain écosystème de recherche neuronale en open source.
