Stable Diffusion implementeren op Vertex AI

Stable Diffusion is een model voor het genereren van afbeeldingen. Het werd in 2022 als open source vrijgegeven en is populair geworden vanwege zijn vermogen om op basis van tekstbeschrijvingen afbeeldingen van hoge kwaliteit te genereren. Net als andere modellen voor het genereren van afbeeldingen, zoals Dall-E, maakt Stable Diffusion gebruik van machine learning-technieken om afbeeldingen te genereren op basis van een bepaalde invoer.

Moët Hennessy, de wijn- en sterkedrankdivisie van luxeconcern LVMH, beheert een portfolio van meer dan 26 iconische merken, zoals Moët & Chandon, Hennessy en Veuve Clicquot. Moët Hennessy heeft samengewerkt met Artefact om de mogelijke toepassingen van geavanceerde technologie bij het genereren van marketingcontent te onderzoeken. Met de nadruk op privacy en beveiliging besloot het team de implementatie van Stable Diffusion op Google Cloud (GCP) te verkennen, zodat Moët Hennessy het model binnen hun eigen infrastructuur kan afstemmen en uitvoeren, wat een naadloze ervaring biedt, van het afstemmen van het model tot de API-blootstelling.

Voordat je begint, is het belangrijk om te weten dat dit artikel ervan uitgaat dat je al enige kennis hebt van Google Cloud (GCP) en met name van Vertex AI. Dit omvat begrippen zoals het modelregister en Vertex-eindpunten. Daarnaast moet je enige ervaring hebben met Docker om bepaalde stappen te kunnen volgen. Als je niet bekend bent met deze begrippen, is het raadzaam je hier eerst in te verdiepen voordat je verdergaat.
Om Stable Diffusion-gewichten te downloaden, moet je bovendien een Hugging Face-account hebben. Als je er nog geen hebt, kun je er eenvoudig een aanmaken opde website van Hugging Face.
Dat gezegd hebbende, laten we beginnen!

Ik raad je aan deGitHub-repositorydie ik heb aangemaakt te klonen, zodat je de stappen in het artikel kunt volgen.

Het is altijd belangrijk om een virtuele omgeving te creëren om de pakketten te installeren. Zelf gebruik ik Anaconda en installeer ik het bestand requirements.txt met alle afhankelijkheden:

Je bent nu klaar om de modelgewichten van Stable Diffusion te downloaden. In dit artikel gebruiken weStable Diffusion 1.5. Je moet de licentie op de modelpagina accepteren, anders krijg je foutmeldingen bij het downloaden van de modelgewichten.
Ga naar je account → instellingen → toegangstoken → nieuw token (leestoegang)

Je kunt het token als omgevingsvariabele toevoegen. Persoonlijk raad ik aan om een .env-bestand te gebruiken en de omgevingsvariabele te laden met behulp van depython-dotenv-bibliotheek.
Je moet naar `src/stable_diffusion` gaan en het volgende uitvoeren:

Hiermee worden de gewichten gedownload

Torchserveis een framework voor het aanbieden van PyTorch-modellen. Hiermee kun je PyTorch-modellen in een productieomgeving implementeren en beschik je over functies zoals modelversiebeheer en het aanbieden van meerdere modellen. Het is ontworpen om gebruiksvriendelijk te zijn, zodat je je kunt concentreren op het bouwen en implementeren van je modellen, in plaats van je zorgen te maken over de infrastructuur.

Een aangepaste handler is een Python-klasse die bepaalt hoe data moeten worden voorbewerkt, hoe het model moet worden uitgevoerd en hoe de uitvoer moet worden nabewerkt. Om een aangepaste handler voor je model te maken, moet je een Python-klasse aanmaken die voldoet aan het TorchServe-formaat.
Een aangepaste handler voor Stable Diffusion is al opgenomen in de TorchServe-repository. Maar het Vertex-eindpunt verwacht een specifiek formaat voor de verzoeken, dus we moeten de preprocess()-methode van de handler aanpassen aan het Vertex-formaat. U kunt de aangepaste versie van de handler met de naam `stable_diffusion_handler.py` gebruiken die is opgenomen in de GitHub-repository van dit artikel.

Zodra je je aangepaste handler hebt gemaakt, moet je deze samen met eventuele afhankelijkheden en het model zelf met behulp van de tool `model-archiver` in een .mar-bestand verpakken. De tool `model-archiver` is een opdrachtregelprogramma waarmee je je model, handler en afhankelijkheden in één enkel bestand kunt verpakken.

Hierdoor wordt een .mar-bestand met de naam output.mar aangemaakt dat je model, handler en afhankelijkheden bevat.

Het kan zijn dat je het pad moet aanpassen, afhankelijk van waar de bestanden op je computer staan:

Zodra je je .mar-bestand hebt aangemaakt, kun je de TorchServe-server starten met het commando torchserve. Hiervoor moet je het volgende commando uitvoeren:

In het bestand `config.properties` kunt u de configuratie van uw TorchServe-server instellen, zoals de poort voor inferentie, statuscontroles, het aantal workers, enz.
WAARSCHUWING: Alle scripts moeten worden uitgevoerd vanuit de map waar het bestand zich bevindt om padfouten te voorkomen.

Het is belangrijk om de code lokaal te testen voordat we beginnen met het omzetten van onze implementatie naar Docker. Ik heb al een Bash-script opgesteld dat het .mar-bestand aanmaakt en de TorchServe-server start.

Je kunt het uitvoeren met:

Je moet een paar minuten wachten totdat de server is opgestart en de worker het model heeft geladen. Je kunt beginnen met het uitvoeren van inferentie zodra je het volgende logbericht ziet:

Je kunt vervolgens de volgende code gebruiken om inferentieverzoeken naar je model te sturen:

Je kunt controleren of de server je verzoek heeft ontvangen door de serverlogboeken te bekijken:

Stable Diffusion heeft een GPU nodig om soepel te werken, dus je krijgt voorlopig geen uitvoer te zien. Je kunt de torchserve-server stoppen met `torchserve –stop`.

Je TorchServe-server werkt lokaal. Om Stable Diffusion op Vertex AI te implementeren, moet je het in Docker verpakken. Dit houdt in dat je een Docker-image moet maken dat het model, de aangepaste handler en alle benodigde afhankelijkheden bevat. Dit zijn simpelweg alle stappen die we hierboven hebben doorlopen, maar dan in een Dockerfile.
Gelukkig is het hier al klaargemaakt en klaar voor gebruik:Dockerfile.

Het is belangrijk om de container lokaal uit te voeren om te controleren of deze goed werkt. Ik ga hem lokaal bouwen, maar je kunt hem ook met cloud bouwen en vervolgens naar je computer ophalen.

Bouw de image lokaal (hiervoor moet de Docker-daemon actief zijn):

Het bouwen van de image duurt 20 tot 30 minuten; deze fase duurt lang omdat de gewichten van het model eerst naar de image moeten worden gekopieerd voordat deze door de model-archiver kan worden verpakt.

Je kunt een Docker-container starten en luisteren op poort 7080 met:

Om te controleren of alles goed werkt, kun je wachten tot de worker het model heeft geladen en vervolgens dezelfde inferentiecode uitvoeren als eerder, aangezien we dezelfde poort 7080 gebruiken.

Nu het Dockerfile klaar is en werkt, moeten we het volgende doen:

Dit is precies wat het bash-script`deploy.sh` gaat doen; je kunt het uitvoeren met:

De installatie duurt ongeveer 1 uur bij een goede internetverbinding:

Nadat het model met succes aan het eindpunt is gekoppeld, kunt u het eindpunt opvragen met de volgende code:

PROJECT_NAME = ""
REGION = ""
ENDPOINT_ID = ""
aip.init(project=PROJECT_NAME, location=REGION)
endpoint = aip.Endpoint(endpoint_name=ENDPOINT_ID)
text_input = """Een fles gerijpte en exclusieve cognac
staat op een reflecterend oppervlak, voor een levendige bar,
hypergedetailleerd, 4K, bokeh"""

def query_endpoint(endpoint, text_input):
payload =
response = endpoint.predict(instances=[payload])
return response

Een fles gerijpte en exclusieve cognac staat op een glanzend oppervlak, voor een levendige bar, hypergedetailleerd, 4K, bokeh — Stable Diffusion 1.5

De inferentie duurt op een T4-GPU tussen de 10 en 15 seconden. Je kunt de snelheid verhogen door een krachtigere GPU te kiezen; hiervoor kun je de variabele `ACCELERATOR_TYPE` in ` deploy.sh` aanpassen.

Misschien wilt u de geschiedenis van de afbeeldingen bijhouden, of ondervindt u problemen vanwege de maximale bestandsgrootte van 1,5 MB voor het antwoord van het eindpunt. In dat geval raad ik u aan de post-process-methode van de handler te gebruiken om de afbeelding op te slaan in GCS en alleen het GCS-pad van de afbeelding terug te sturen.

Gelukkig heb ik al een handler gemaakt die dit voor je regelt; als je overschakelt van `stable_diffusion_handler.py` naar `stable_diffusion_handler_gcs.py`, zou dat moeten werken.

WAARSCHUWING: Voordat u de implementatie met de nieuwe handler uitvoert, moet u het volgende doen:

In dit artikel wordt een uitgebreide handleiding gegeven voor het implementeren van het Stable Diffusion-model op Google Cloud met behulp van Vertex AI.

De gids behandelde essentiële stappen zoals:

Het is belangrijk om te onthouden dat, hoewel het Vertex-eindpunt een effectieve oplossing kan zijn, het geen schaalverkleining tot 0 instanties ondersteunt, wat tot hogere kosten kan leiden omdat de GPU in gebruik blijft.

Nu de implementatie van het Stable Diffusion-model is voltooid, onderzoeken we momenteel verdere mogelijkheden, zoals het afstemmen van het model op specifieke producten van Moët Hennessy, om de mogelijkheden van het model nog verder te verbeteren.