Lisez notre article sur

class="img-responsive

.

Cet article fournit un guide pour le déploiement du modèle Stable Diffusion, un modèle populaire de génération d'images, sur Google Cloud à l'aide de Vertex AI. Le guide couvre l'installation et le téléchargement des poids, TorchServe pour le déploiement, le serveur TorchServe déployé sur un point d'extrémité Vertex et la sauvegarde automatique de l'historique de l'image sur GCS.

Introduction

Stable Diffusion est un modèle de génération d'images. Il a été mis en open source en 2022 et a gagné en popularité grâce à sa capacité à générer des images de haute qualité à partir de descriptions textuelles. Comme d'autres modèles de génération d'images, tels que Dall-E, Stable Diffusion utilise des techniques d'apprentissage automatique pour générer des images à partir d'une entrée donnée.

Moët Hennessy, la division vins et spiritueux du conglomérat de luxe LVMH, gère un portefeuille de plus de 26 marques emblématiques telles que Moët & Chandon, Hennessy et Veuve Clicquot. Moët Hennessy a collaboré avec Artefact pour étudier les utilisations potentielles des technologies de pointe dans la génération de contenu marketing. En mettant l'accent sur la confidentialité et la sécurité, l'équipe a décidé d'explorer le déploiement de Stable Diffusion sur Google Cloud Platform (GCP) pour permettre à Moët Hennessy d'affiner et d'exécuter le modèle au sein de sa propre infrastructure, en fournissant une expérience transparente de l'affinage du modèle à l'exposition de l'API.

Avant de commencer, il est important de noter que cet article suppose que vous avez une connaissance préalable de Google Cloud Platform (GCP) et plus particulièrement de Vertex AI. Cela inclut des concepts tels que le registre de modèles et les points de terminaison Vertex. En outre, vous devez avoir une expérience préalable de Docker pour suivre certaines des étapes. Si vous n'êtes pas familier avec ces concepts, il est recommandé de vous familiariser avec eux avant de continuer.
De plus, pour télécharger les poids de diffusion stables, vous devez avoir un compte huggingface, si vous n'en avez pas encore, vous pouvez en créer un facilement sur le site web de huggingface.
Ceci étant dit, commençons !

Installation et téléchargement des poids

Je recommande de cloner ledépôt github que j'ai préparé afin de suivre les étapes de l'article.

Il est toujours important de créer un environnement virtuel pour installer les paquets. Personnellement, j'utiliserai anaconda et j'installerai le fichier requirements.txt avec chaque dépendance :

conda create -n stable_diffusion - no-default-packages python=3.8 -y
conda activate stable_diffusion
pip install -r src/requirements.txt

Vous êtes maintenant prêt à télécharger les poids de Stable Diffusion, dans cet article nous utiliserons Stable Diffusion 1.5. Vous devez accepter la licence sur la page du modèle, sinon vous aurez des erreurs lors du téléchargement des poids du modèle.
Allez dans votre compte → paramètres → jeton d'accès → nouveau jeton (accès en lecture)

Allez dans votre compte → paramètres → jeton d'accès → nouveau jeton (accès en lecture)

Vous pouvez ajouter le jeton en tant que variable d'environnement. Personnellement, je recommande d'utiliser un fichier .env et de charger la variable d'environnement en utilisant la bibliothèque python-dotenv.
Vous devez naviguer jusqu'à `src/stable_diffusion` et lancer :

python download_model.py

Cette opération permet de télécharger les poids à l'intérieur

`src/stable_diffusion/external_files/model_weights`.

Cadre de Torchserve

Torchserve est un cadre pour servir les modèles PyTorch. Il vous permet de déployer des modèles PyTorch dans un environnement de production et offre des fonctionnalités telles que le versionnement des modèles et le service multi-modèle. Il est conçu pour être facile à utiliser et vous permet de vous concentrer sur la construction et le déploiement de vos modèles, plutôt que de vous préoccuper de l'infrastructure.

1. Création d'un gestionnaire respectant le format TorchServe

Un gestionnaire personnalisé est une classe Python qui définit comment prétraiter l'entrée data, comment exécuter le modèle et comment post-traiter la sortie. Pour créer un gestionnaire personnalisé pour votre modèle, vous devrez créer une classe Python qui suit le format TorchServe.
Un gestionnaire personnalisé pour la diffusion stable est déjà fourni dans le référentiel TorchServe. Mais le point de terminaison Vertex attend un format spécifique pour les requêtes, nous devons donc adapter la méthode preprocess() du handler pour prendre en compte le format Vertex. Vous pouvez utiliser la version modifiée du handler nommée `stable_diffusion_handler.py` donnée dans le dépôt github de cet article.

2. Création du fichier .mar

Une fois que vous avez créé votre gestionnaire personnalisé, vous devez l'empaqueter avec toutes les dépendances et le modèle lui-même dans un fichier .mar à l'aide de l'outil model-archiver. L'outil model-archiver est un outil en ligne de commande qui vous permet d'empaqueter votre modèle, votre gestionnaire et vos dépendances dans un seul fichier.

Cela créera un fichier .mar appelé output.mar qui contiendra votre modèle, votre gestionnaire et vos dépendances.

Vous devrez peut-être modifier le chemin d'accès en fonction de l'emplacement des fichiers sur votre machine :

torch-model-archiver
-model-name stable-diffusion
-version 1.0
-handler stable_diffusion/stable_diffusion_handler.py
-export-path stable_diffusion/model-store
-extra-files stable_diffusion/external_files

3. Exécution du serveur TorchServe

Une fois que vous avez créé votre fichier .mar, vous pouvez démarrer le serveur TorchServe à l'aide de la commande torchserve. Pour ce faire, vous devez exécuter la commande suivante :

torchserve
- démarrer
- ts-config=config.properties
- models=stable-diffusion.mar
- model-store=stable_diffusion/model-store

Les config.properties vous permettent de spécifier les configurations de votre serveur TorchServe, comme le port pour l'inférence, les contrôles de santé, le nombre de travailleurs, etc.
ATTENTION : Tous les scripts doivent être exécutés à l'endroit où se trouve le fichier afin d'éviter toute erreur de chemin.

Exécuter le serveur TorchServe localement

Il est important de tester le code localement avant de commencer à dockeriser notre déploiement, j'ai déjà préparé un script bash qui va créer le fichier .mar et démarrer le serveur TorchServe.

Vous pouvez l'exécuter avec :


bash serve_locally.sh

Vous devez attendre quelques minutes pour que le serveur s'initialise et que le travailleur charge le modèle. Vous pouvez commencer à exécuter l'inférence si vous voyez le journal suivant :

2023-01-05T15:34:52,842 [DEBUG] W-9000-stable-diffusion_1.0
org.pytorch.serve.wlm.WorkerThread- W-9000-stable-diffusion_1.0
Changement d'état WORKER_STARTED -> WORKER_MODEL_LOADED

Vous pouvez ensuite utiliser le code suivant pour faire des demandes d'inférence à votre modèle :

demandes d'importation
prompt = "une photo d'un astronaute à cheval sur mars"
URL = "http://localhost:7080/predictions/stable-diffusion"
response = requests.post(URL, data=prompt)

Vous pouvez vérifier que le serveur a bien reçu votre demande en consultant les journaux du serveur :

2023-01-05T15:35:43,765 [INFO ] W-9000-stable-diffusion_1.0-stdout
MODEL_LOG - Le backend a reçu l'inférence à : 1672929343

Stable Diffusion nécessite un GPU pour fonctionner correctement, donc vous n'aurez pas de sortie pour le moment. Vous pouvez arrêter le serveur torchserve avec `torhcserve -stop`.

Dockerize torchserve

Votre serveur TorchServe fonctionne localement, pour déployer Stable Diffusion sur Vertex AI, vous devrez le dockeriser. Cela signifie créer une image Docker qui contient le modèle, le custom handler, et toutes les dépendances nécessaires. Il s'agit simplement de toutes les étapes que nous avons effectuées ci-dessus à l'intérieur d'un fichier Docker.
Heureusement, il est déjà préparé et prêt à l'emploi ici : Dockerfile.

Il est important d'exécuter le conteneur localement pour vérifier qu'il fonctionne correctement. Je vais le construire localement, mais vous pouvez le construire avec cloud build et le tirer sur votre machine.

Construisez l'image localement (vous devez lancer le démon Docker) :

build -t serve_sd .

La construction de l'image prendra 20 à 30 minutes, la phase de construction est longue car les poids du modèle doivent être copiés à l'intérieur de l'image avant d'être emballés par l'archiveur de modèles.

Vous pouvez lancer un conteneur docker et écouter sur le port 7080 avec :

docker run -p 7080:7080 serve_sd

Pour vérifier que tout fonctionne correctement, vous pouvez attendre que le travailleur ait chargé le modèle et exécuter le même code d'inférence que précédemment puisque nous utilisons le même port 7080.

Déploiement sur Vertex AI

Maintenant que le fichier Docker est prêt et fonctionne, nous devons :

  • Construire l'image en utilisant Cloud Build dans google container registry (gcr)
  • Télécharger l'image de notre modèle personnalisé dans le registre de modèles de Vertex AI.

  • Créer un point de terminaison Vertex AI
  • Attacher le modèle à l'extrémité

C'est exactement ce que le script bash deploy.sh va faire, vous pouvez le lancer avec :

bash deploy.sh

Le déploiement prend environ 1 heure avec un bon débit internet :

  • L'envoi des 8 Go de poids des modèles à Cloud Build peut prendre de quelques minutes à quelques heures, en fonction de votre vitesse d'accès à Internet.
  • La construction de l'image prend environ 20 minutes

  • Le téléchargement du modèle prend environ 5 minutes

  • La création du point d'accès prend environ 5 minutes

  • La fixation du modèle au point d'extrémité prend de 30 à 40 minutes.

Une fois que le modèle est attaché avec succès au point de terminaison, vous pouvez interroger le point de terminaison à l'aide du code suivant :

from google.cloud import aiplatform as aip

NOM_DU_PROJET = ""
REGION = ""
ENDPOINT_ID = ""
aip.init(project=PROJECT_NAME, location=REGION)
endpoint = aip.Endpoint(endpoint_name=ENDPOINT_ID)
text_input = """Une bouteille de cognac vieillie et exclusive
sur une surface réfléchissante, devant un bar animé,
hyper détaillé, 4K, bokeh"""

def query_endpoint(endpoint, text_input):
payload = {“data”: text_input}
response = endpoint.predict(instances=[payload])
return response

image = query_endpoint(endpoint, text_input)
class="img-responsive

Une bouteille de cognac vieillie et exclusive est posée sur une surface réfléchissante, devant un bar animé, hyper détaillé, 4K, bokeh - Stable Diffusion 1.5

L'inférence devrait prendre entre 10 et 15 secondes sur un GPU T4. Vous pouvez améliorer la vitesse en choisissant un meilleur GPU, vous pouvez changer la variable ACCELERATOR_TYPE dans deploy.sh.

Facultatif : si la taille de l'image est trop importante pour le terminal ou si vous souhaitez conserver l'historique de l'image.

Il se peut que vous souhaitiez conserver l'historique des images ou que vous rencontriez des erreurs dues à la limite de taille de 1,5 Mo pour la réponse du point de terminaison. Dans ce cas, je recommande d'utiliser la méthode de post-traitement du gestionnaire pour enregistrer l'image dans GCS et ne renvoyer que le chemin GCS de l'image.

Heureusement, j'ai déjà préparé un handler qui fait cela pour vous, en passant de stable_diffusion_handler.py à stable_diffusion_handler_gcs.py.

AVERTISSEMENT : Avant d'exécuter le déploiement avec le nouveau gestionnaire, vous devez.. :

  • Créer un panier GCS qui stockera les images

  • Modifier le nom du nouveau seau GCS et du dossier dans src/stable_diffusion/external_files/config.py

  • Modifiez le compte de service utilisé par le point final dans le fichier deploy.sh. Vous avez besoin d'un compte de service avec les permissions GCS OWNER.

Conclusion

Dans cet article, un guide complet est fourni pour déployer le modèle Stable Diffusion sur Google Cloud Platform à l'aide de Vertex AI.

Le guide couvre les étapes essentielles telles que

  • Utilisation de TorchServe pour le déploiement
  • Création et modification d'un gestionnaire personnalisé pour la diffusion stable
  • Déploiement du modèle à l'aide du registre de modèles Vertex et des points de terminaison Vertex

Il est important de rappeler que si Vertex endpoint peut être une solution efficace, il ne permet pas de réduire le nombre d'instances à 0, ce qui pourrait entraîner une augmentation des coûts car le GPU reste utilisé.

En outre, le déploiement du modèle de diffusion stable étant achevé, nous explorons actuellement d'autres possibilités telles que le réglage fin du modèle sur des produits spécifiques de Moet Hennessy afin d'améliorer encore les capacités du modèle.

class="img-responsive

Moyen Blog par Artefact.

Cet article a été initialement publié sur Medium.com.
Suivez-nous sur notre Medium Blog !