discoart
v0.12.1
On peut également générer du code Python exécutable directement à partir de la configuration :
from discoart . config import export_python
export_python ( da ) Si vous êtes un utilisateur de Google Colab gratuit, la perte de sessions de temps en temps est un problème. Ou parfois, vous arrêtez simplement l'exécution car la première image n'est pas assez bonne et une interruption du clavier empêchera .create() de renvoyer un résultat. Dans tous les cas, vous pouvez facilement récupérer les résultats en extrayant le dernier ID de session.
Recherchez l'ID de session. Il apparaît en haut de l'image. 
Extrayez le résultat via cet identifiant sur n'importe quelle machine à tout moment , pas nécessairement sur Google Colab :
from docarray import DocumentArray
da = DocumentArray . pull ( 'discoart-3205998582' ) Considérez un document comme une donnée autonome avec une configuration et une image, on peut l'utiliser comme état initial pour l'exécution future. Ses .tags seront utilisés comme paramètres initiaux ; .uri s’il est présenté sera utilisé comme image initiale.
from discoart import create
from docarray import DocumentArray
da = DocumentArray . pull ( 'discoart-3205998582' )
create (
init_document = da [ 0 ],
cut_ic_pow = 0.5 ,
tv_scale = 600 ,
cut_overview = '[12]*1000' ,
cut_innercut = '[12]*1000' ,
use_secondary_model = False ,
)Si vous souhaitez simplement initialiser à partir d'un ID DocArray connu, alors simplement :
from discoart import create
create ( init_document = 'discoart-3205998582' ) Vous pouvez définir des variables d'environnement pour contrôler le méta-comportement de DiscoArt. Les variables d'environnement doivent être définies avant d'importer DiscoArt, soit en Bash, soit en Python via os.environ .
DISCOART_LOG_LEVEL= ' DEBUG ' # more verbose logs
DISCOART_OPTOUT_CLOUD_BACKUP= ' 1 ' # opt-out from cloud backup
DISCOART_DISABLE_IPYTHON= ' 1 ' # disable ipython dependency
DISCOART_DISABLE_RESULT_SUMMARY= ' 1 ' # disable result summary after the run ends
DISCOART_DEFAULT_PARAMETERS_YAML= ' path/to/your-default.yml ' # use a custom default parameters file
DISCOART_CUT_SCHEDULES_YAML= ' path/to/your-schedules.yml ' # use a custom cut schedules file
DISCOART_MODELS_YAML= ' path/to/your-models.yml ' # use a custom list of models file
DISCOART_OUTPUT_DIR= ' path/to/your-output-dir ' # use a custom output directory for all images and results
DISCOART_CACHE_DIR= ' path/to/your-cache-dir ' # use a custom cache directory for models and downloads
DISCOART_DISABLE_REMOTE_MODELS= ' 1 ' # disable the listing of diffusion models on Github, remote diffusion models allows user to use latest models without updating the codebase.
DISCOART_REMOTE_MODELS_URL= ' https://yourdomain/models.yml ' # use a custom remote URL for fetching models list
DISCOART_DISABLE_CHECK_MODEL_SHA= ' 1 ' # disable checking local model SHA matches the remote model SHA
DISCOART_DISABLE_TQDM= ' 1 ' # disable tqdm progress bar on diffusion DiscoArt fournit deux commandes create et config qui vous permettent d'exécuter DiscoArt à partir de la CLI.
python -m discoart create my.yml qui crée des œuvres d'art à partir du fichier de configuration YAML my.yml . Vous pouvez également faire :
cat config.yml | python -m discoart create Alors, comment puis-je avoir mon propre my.yml et à quoi ressemble-t-il ? Voilà la deuxième commande :
python -m discoart config my.yml qui crée la configuration YAML par défaut et les exporte vers my.yml . Vous pouvez maintenant le modifier et l'exécuter avec la commande python -m discoart create .
Si aucun chemin de sortie n'est spécifié, alors python -m discoart config imprimera la configuration par défaut sur la sortie standard.
Pour obtenir de l'aide sur une commande, ajoutez --help à la fin, par exemple :
python -m discoart create --help usage: python -m discoart create [-h] [YAML_CONFIG_FILE]
positional arguments:
YAML_CONFIG_FILE The YAML config file to use, default is stdin.
optional arguments:
-h, --help show this help message and exit
Servir DiscoArt est super simple. Exécutez simplement la commande suivante :
python -m discoart serveVous verrez :
Maintenant, envoyez la demande au serveur via curl/Javascript, par exemple
curl
-X POST http://0.0.0.0:51001/post
-H ' Content-Type: application/json '
-d ' {"execEndpoint":"/create", "parameters": {"text_prompts": ["A beautiful painting of a singular lighthouse", "yellow color scheme"]}} 'C'est ça.
Vous pouvez bien sûr transmettre tous les paramètres acceptés par la fonction create() dans le JSON.
Nous savons déjà que la fonction create est lente, même sur GPU, cela peut prendre 10 minutes pour terminer une illustration. Cela signifie qu'après l'envoi de la demande ci-dessus, le client devra attendre 10 minutes pour recevoir la réponse. Il n'y a rien de mal à ce comportement étant donné que tout fonctionne de manière synchrone. Cependant, dans la pratique, le client peut s'attendre à une progression ou à des résultats intermédiaires au lieu d'attendre la fin.
Le point de terminaison /result est conçu à cet effet. Il renverra les résultats intermédiaires dès qu'ils seront disponibles. Tout ce dont vous avez besoin est de spécifier name_docarray dans les paramètres de la requête comme vous l'avez spécifié dans /create endpoint. Voici un exemple :
Créons mydisco-123 en envoyant la requête suivante au point de terminaison /create :
curl
-X POST http://0.0.0.0:51001/post
-H ' Content-Type: application/json '
-d ' {"execEndpoint":"/create", "parameters": {"name_docarray": "mydisco-123", "text_prompts": ["A beautiful painting of a singular lighthouse", "yellow color scheme"]}} ' Maintenant que la requête ci-dessus est en cours de traitement sur le serveur, vous pouvez vérifier périodiquement la progression mydisco-123 en envoyant la requête suivante au point de terminaison /result :
curl
-X POST http://0.0.0.0:51001/post
-H ' Content-Type: application/json '
-d ' {"execEndpoint":"/result", "parameters": {"name_docarray": "mydisco-123"}} 'Un JSON sera renvoyé avec une progression à jour, avec une image comme DataURI, une perte, des étapes, etc. Le schéma JSON de Document/DocumentArray est décrit ici.
Notez que /result ne sera pas bloqué par /create grâce au routage intelligent de Jina Gateway. Pour en savoir plus sur ces points de terminaison, vous pouvez consulter ReDoc ou l'interface utilisateur Swagger intégrée au serveur.
Envoyer à /skip , pour ignorer l'exécution en cours et passer à l'exécution suivante comme défini dans n_batches :
curl
-X POST http://0.0.0.0:51001/post
-H ' Content-Type: application/json '
-d ' {"execEndpoint":"/skip"} ' Envoyer à /stop , pour arrêter l'exécution en cours, annuler toutes les exécutions n_batches :
curl
-X POST http://0.0.0.0:51001/post
-H ' Content-Type: application/json '
-d ' {"execEndpoint":"/stop"} '/create Il est possible d'avoir un point de terminaison /create débloqué : la requête client vers /create sera immédiatement renvoyée, sans attendre la fin des résultats. Vous devez maintenant vous fier entièrement à /result pour interroger le résultat.
Pour activer cette fonctionnalité :
flow.yml par défaut dans myflow.yml ;floating: false par floating: true dans la section exécuteur discoart ;python -m discoart serve myflow.yml Attention, la vitesse des requêtes est désormais sous votre contrôle . Autrement dit, si le client envoie 10 requêtes /create en une seconde, alors le serveur lancera 10 create() en parallèle ! Cela peut facilement conduire à un MOO. Par conséquent, la suggestion n'active cette fonctionnalité que si vous êtes sûr que le client n'envoie pas trop de requêtes, par exemple si vous contrôlez le taux de requêtes du client ; ou vous utilisez DiscoArt derrière un BFF (backend pour frontend).
Si vous disposez de plusieurs GPU et que vous souhaitez exécuter plusieurs instances DiscoArt en parallèle en exploitant les GPU de manière multiplexée dans le temps, vous pouvez copier-coller le fichier flow.yml par défaut et le modifier comme suit :
jtype : Flow
with :
protocol : http
monitoring : true
port : 51001
port_monitoring : 51002 # prometheus monitoring port
env :
JINA_LOG_LEVEL : debug
DISCOART_DISABLE_IPYTHON : 1
DISCOART_DISABLE_RESULT_SUMMARY : 1
executors :
- name : discoart
uses : DiscoArtExecutor
env :
CUDA_VISIBLE_DEVICES : RR0:3 # change this if you have multiple GPU
replicas : 3 # change this if you have larger VRAM
- name : poller
uses : ResultPoller Ici, replicas: 3 indique la création de trois instances DiscoArt, CUDA_VISIBLE_DEVICES: RR0:3 s'assure qu'elles utilisent les trois premiers GPU de manière alternée.
Nommez- myflow.yml , puis exécutez
python -m discoart serve myflow.ymlGrâce à Jina, il y a des tonnes de choses que vous pouvez personnaliser ! Vous pouvez modifier le numéro de port ; changer le protocole en gRPC/Websockets ; ajouter le cryptage TLS ; activer/désactiver la surveillance Prometheus ; vous pouvez également l'exporter vers le bundle de déploiement Kubernetes simplement via :
jina export kubernetes myflow.ymlPour plus de fonctionnalités et de configurations YAML, veuillez consulter la documentation Jina.
Passer de la passerelle HTTP à la passerelle gRPC est simple :
jtype : Flow
with :
protocol : grpc
...puis redémarrez le serveur.
L'utilisation de la passerelle gRPC présente de nombreux avantages :
En général, si vous utilisez le serveur DiscoArt derrière un BFF (backend pour frontend) ou si votre serveur DiscoArt ne dessert pas directement le trafic HTTP des utilisateurs finaux, vous devez alors utiliser le protocole gRPC.
Pour communiquer avec un serveur gRPC DiscoArt, on peut utiliser un client Jina :
# !pip install jina
from jina import Client
c = Client ( host = 'grpc://0.0.0.0:51001' )
da = c . post (
'/create' ,
parameters = {
'name_docarray' : 'mydisco-123' ,
'text_prompts' : [
'A beautiful painting of a singular lighthouse' ,
'yellow color scheme' ,
],
},
)
# check intermediate results
da = c . post ( '/result' , parameters = { 'name_docarray' : 'mydisco-123' }) Pour utiliser un Document/DocumentArray existant comme document d'initialisation pour create :
from jina import Client
c = Client ( host = 'grpc://0.0.0.0:51001' )
old_da = create (...)
da = c . post (
'/create' ,
old_da , # this can be a DocumentArray or a single Document
parameters = {
'width_height' : [ 1024 , 768 ],
},
) Cela équivaut à exécuter create(init_document=old_da, width_height=[1024, 768]) sur le serveur. Note:
init_document .init_document est un DocumentArray, alors le premier document du tableau sera utilisé comme document d'initialisation.Bien que cela ne soit pas recommandé, il est également possible d'utiliser Google Colab pour héberger le serveur DiscoArt. Veuillez consulter les tutoriels suivants :
Nous fournissons une image Docker prédéfinie pour exécuter DiscoArt prêt à l'emploi. Pour mettre à jour l'image Docker vers la dernière version :
docker pull jinaai/discoart:latestLe point d'entrée par défaut démarre un notebook Jupyter
# docker build . -t jinaai/discoart # if you want to build yourself
docker run -p 51000:8888 -v $( pwd ) :/home/jovyan/ -v $HOME /.cache:/root/.cache --gpus all jinaai/discoart Vous pouvez maintenant visiter http://127.0.0.1:51000 pour accéder au bloc-notes
Vous pouvez l'utiliser sur le sous-système Windows pour Linux (WSL). Consultez le guide officiel ici.
# Make sure you install Windows 11 or Windows 10, version 21H2
docker run -p 8888:8888 -v $HOME /.cache:/root/.cache --gpus all jinaai/discoart # docker build . -t jinaai/discoart # if you want to build yourself
docker run --entrypoint " python " -p 51001:51001 -v $( pwd ) :/home/jovyan/ -v $HOME /.cache:/root/.cache --gpus all jinaai/discoart -m discoart serve Votre serveur DiscoArt fonctionne désormais sur http://127.0.0.1:51001 .
Les images Docker sont construites sur chaque version, on peut donc les verrouiller sur une version spécifique, par exemple 0.5.1 :
docker run -p 51000:8888 -v $( pwd ) :/home/jovyan/ -v $HOME /.cache:/root/.cache --gpus all jinaai/discoart:0.5.1Vient ensuite la création.
? Si vous êtes déjà utilisateur DD : vous êtes prêt à partir ! Il n'y a pas d'apprentissage supplémentaire, DiscoArt respecte la même sémantique de paramètres que DD5.6. Alors libérez votre créativité ! En savoir plus sur leurs différences ici.
Vous pouvez toujours le faire from discoart import cheatsheet; cheatsheet() pour vérifier tous les paramètres nouveaux/modifiés.
? Si vous êtes un DALL·E Flow ou un nouvel utilisateur : vous souhaiterez peut-être procéder étape par étape, car Disco Diffusion fonctionne d'une manière très différente de DALL·E. Il est beaucoup plus avancé et puissant : par exemple, Disco Diffusion peut accepter des invites textuelles pondérées et structurées ; il peut s'initialiser à partir d'une image avec un bruit contrôlé ; et il y a bien plus de paramètres que l'on peut modifier. Une invite impatiente comme "armchair avocado" ne vous apportera que confusion et frustration. Je vous recommande fortement de consulter les ressources suivantes avant d'essayer votre propre invite :
DiscoArt est soutenu par Jina AI et sous licence MIT. Nous recrutons activement des ingénieurs en IA et des ingénieurs en solutions pour créer le prochain écosystème de recherche neuronale en open source.
