1. Introduzione
Panoramica
Cloud Run ha recentemente aggiunto il supporto GPU. È disponibile come anteprima pubblica con lista d'attesa. Se ti interessa provare la funzionalità, compila questo modulo per entrare nella lista d'attesa. Cloud Run è una piattaforma di container su Google Cloud che semplifica l'esecuzione del codice in un container, senza richiedere la gestione di un cluster.
Oggi, le GPU che rendiamo disponibili sono le GPU Nvidia L4 con 24 GB di vRAM. C'è una GPU per istanza Cloud Run e la scalabilità automatica di Cloud Run è ancora applicabile. Ciò include lo scale out fino a 5 istanze (con aumento della quota disponibile), nonché lo scale down fino a zero istanze quando non ci sono richieste.
In questo codelab, creerai e implementerai un'app TorchServe che utilizza Stable Diffusion XL per generare immagini da un prompt di testo. L'immagine generata viene restituita al chiamante come stringa con codifica base64.
Questo esempio si basa su Esecuzione del modello Stable Diffusion utilizzando Huggingface Diffusers in TorchServe. Questo codelab mostra come modificare questo esempio per utilizzarlo con Cloud Run.
Cosa imparerai a fare
- Come eseguire un modello Stable Diffusion XL su Cloud Run utilizzando le GPU
2. Abilita le API e imposta le variabili di ambiente
Prima di poter iniziare a utilizzare questo codelab, devi abilitare diverse API. Questo codelab richiede l'utilizzo delle seguenti API. Puoi abilitare queste API eseguendo il seguente comando:
gcloud services enable run.googleapis.com \
storage.googleapis.com \
cloudbuild.googleapis.com
Poi puoi impostare le variabili di ambiente che verranno utilizzate durante questo codelab.
PROJECT_ID=<YOUR_PROJECT_ID> REPOSITORY=<YOUR_REPOSITORY_ID> NETWORK_NAME=default REGION=us-central1 IMAGE=us-central1-docker.pkg.dev/$PROJECT_ID/$REPOSITORY/gpu-torchserve
Il valore impostato per REPOSITORY è per il repository Artifact Registry in cui verrà archiviata la build dell'immagine. Puoi utilizzarne uno esistente o crearne uno nuovo:
gcloud artifacts repositories create $REPOSITORY \
--location=us-central1 \
--repository-format=docker
3. Crea l'app Torchserve
Innanzitutto, crea una directory per il codice sorgente e accedi tramite cd.
mkdir stable-diffusion-codelab && cd $_
Crea un file config.properties. Questo è il file di configurazione per TorchServe.
inference_address=http://0.0.0.0:8080 enable_envvars_config=true min_workers=1 max_workers=1 default_workers_per_model=1 default_response_timeout=1000 load_models=all max_response_size=655350000 # to enable authorization, see https://github.com/pytorch/serve/blob/master/docs/token_authorization_api.md#how-to-set-and-disable-token-authorization disable_token_authorization=true
Tieni presente che in questo esempio viene utilizzato l'indirizzo di ascolto http://0.0.0.0 per lavorare su Cloud Run. La porta predefinita per Cloud Run è la porta 8080.
Crea un file requirements.txt.
python-dotenv accelerate transformers diffusers numpy google-cloud-storage nvgpu
Crea un file denominato stable_diffusion_handler.py
from abc import ABC
import base64
import datetime
import io
import logging
import os
from diffusers import StableDiffusionXLImg2ImgPipeline
from diffusers import StableDiffusionXLPipeline
from google.cloud import storage
import numpy as np
from PIL import Image
import torch
from ts.torch_handler.base_handler import BaseHandler
logger = logging.getLogger(__name__)
def image_to_base64(image: Image.Image) -> str:
"""Convert a PIL image to a base64 string."""
buffer = io.BytesIO()
image.save(buffer, format="JPEG")
image_str = base64.b64encode(buffer.getvalue()).decode("utf-8")
return image_str
class DiffusersHandler(BaseHandler, ABC):
"""Diffusers handler class for text to image generation."""
def __init__(self):
self.initialized = False
def initialize(self, ctx):
"""In this initialize function, the Stable Diffusion model is loaded and
initialized here.
Args:
ctx (context): It is a JSON Object containing information pertaining to
the model artifacts parameters.
"""
logger.info("Initialize DiffusersHandler")
self.manifest = ctx.manifest
properties = ctx.system_properties
model_dir = properties.get("model_dir")
model_name = os.environ["MODEL_NAME"]
model_refiner = os.environ["MODEL_REFINER"]
self.bucket = None
logger.info(
"GPU device count: %s",
torch.cuda.device_count(),
)
logger.info(
"select the GPU device, cuda is available: %s",
torch.cuda.is_available(),
)
self.device = torch.device(
"cuda:" + str(properties.get("gpu_id"))
if torch.cuda.is_available() and properties.get("gpu_id") is not None
else "cpu"
)
logger.info("Device used: %s", self.device)
# open the pipeline to the inferenece model
# this is generating the image
logger.info("Downloading model %s", model_name)
self.pipeline = StableDiffusionXLPipeline.from_pretrained(
model_name,
variant="fp16",
torch_dtype=torch.float16,
use_safetensors=True,
).to(self.device)
logger.info("done downloading model %s", model_name)
# open the pipeline to the refiner
# refiner is used to remove artifacts from the image
logger.info("Downloading refiner %s", model_refiner)
self.refiner = StableDiffusionXLImg2ImgPipeline.from_pretrained(
model_refiner,
variant="fp16",
torch_dtype=torch.float16,
use_safetensors=True,
).to(self.device)
logger.info("done downloading refiner %s", model_refiner)
self.n_steps = 40
self.high_noise_frac = 0.8
self.initialized = True
# Commonly used basic negative prompts.
logger.info("using negative_prompt")
self.negative_prompt = ("worst quality, normal quality, low quality, low res, blurry")
# this handles the user request
def preprocess(self, requests):
"""Basic text preprocessing, of the user's prompt.
Args:
requests (str): The Input data in the form of text is passed on to the
preprocess function.
Returns:
list : The preprocess function returns a list of prompts.
"""
logger.info("Process request started")
inputs = []
for _, data in enumerate(requests):
input_text = data.get("data")
if input_text is None:
input_text = data.get("body")
if isinstance(input_text, (bytes, bytearray)):
input_text = input_text.decode("utf-8")
logger.info("Received text: '%s'", input_text)
inputs.append(input_text)
return inputs
def inference(self, inputs):
"""Generates the image relevant to the received text.
Args:
input_batch (list): List of Text from the pre-process function is passed
here
Returns:
list : It returns a list of the generate images for the input text
"""
logger.info("Inference request started")
# Handling inference for sequence_classification.
image = self.pipeline(
prompt=inputs,
negative_prompt=self.negative_prompt,
num_inference_steps=self.n_steps,
denoising_end=self.high_noise_frac,
output_type="latent",
).images
logger.info("Done model")
image = self.refiner(
prompt=inputs,
negative_prompt=self.negative_prompt,
num_inference_steps=self.n_steps,
denoising_start=self.high_noise_frac,
image=image,
).images
logger.info("Done refiner")
return image
def postprocess(self, inference_output):
"""Post Process Function converts the generated image into Torchserve readable format.
Args:
inference_output (list): It contains the generated image of the input
text.
Returns:
(list): Returns a list of the images.
"""
logger.info("Post process request started")
images = []
response_size = 0
for image in inference_output:
# Save image to GCS
if self.bucket:
image.save("temp.jpg")
# Create a blob object
blob = self.bucket.blob(
datetime.datetime.now().strftime("%Y%m%d_%H%M%S") + ".jpg"
)
# Upload the file
blob.upload_from_filename("temp.jpg")
# to see the image, encode to base64
encoded = image_to_base64(image)
response_size += len(encoded)
images.append(encoded)
logger.info("Images %d, response size: %d", len(images), response_size)
return images
Crea un file denominato start.sh. Questo file viene utilizzato come punto di ingresso nel container per avviare TorchServe.
#!/bin/bash
echo "starting the server"
# start the server. By default torchserve runs in backaround, and start.sh will immediately terminate when done
# so use --foreground to keep torchserve running in foreground while start.sh is running in a container
torchserve --start --ts-config config.properties --models "stable_diffusion=${MAR_FILE_NAME}.mar" --model-store ${MAR_STORE_PATH} --foreground
Poi esegui questo comando per renderlo un file eseguibile.
chmod 755 start.sh
Crea un dockerfile.
# pick a version of torchserve to avoid any future breaking changes
# docker pull pytorch/torchserve:0.11.1-cpp-dev-gpu
FROM pytorch/torchserve:0.11.1-cpp-dev-gpu AS base
USER root
WORKDIR /home/model-server
COPY requirements.txt ./
RUN pip install --upgrade -r ./requirements.txt
# Stage 1 build the serving container.
FROM base AS serve-gcs
ENV MODEL_NAME='stabilityai/stable-diffusion-xl-base-1.0'
ENV MODEL_REFINER='stabilityai/stable-diffusion-xl-refiner-1.0'
ENV MAR_STORE_PATH='/home/model-server/model-store'
ENV MAR_FILE_NAME='model'
RUN mkdir -p $MAR_STORE_PATH
COPY config.properties ./
COPY stable_diffusion_handler.py ./
COPY start.sh ./
# creates the mar file used by torchserve
RUN torch-model-archiver --force --model-name ${MAR_FILE_NAME} --version 1.0 --handler stable_diffusion_handler.py -r requirements.txt --export-path ${MAR_STORE_PATH}
# entrypoint
CMD ["./start.sh"]
4. Configura Cloud NAT
Cloud NAT ti consente di avere una larghezza di banda maggiore per accedere a internet e scaricare il modello da HuggingFace, il che velocizzerà notevolmente i tempi di deployment.
Per utilizzare Cloud NAT, esegui questo comando per abilitare un'istanza Cloud NAT:
gcloud compute routers create nat-router --network $NETWORK_NAME --region us-central1 gcloud compute routers nats create vm-nat --router=nat-router --region=us-central1 --auto-allocate-nat-external-ips --nat-all-subnet-ip-ranges
5. Crea ed esegui il deployment del servizio Cloud Run
Invia il codice a Cloud Build.
gcloud builds submit --tag $IMAGE
Passaggio successivo: esegui il deployment in Cloud Run
gcloud beta run deploy gpu-torchserve \ --image=$IMAGE \ --cpu=8 --memory=32Gi \ --gpu=1 --no-cpu-throttling --gpu-type=nvidia-l4 \ --allow-unauthenticated \ --region us-central1 \ --project $PROJECT_ID \ --execution-environment=gen2 \ --max-instances 1 \ --network $NETWORK_NAME \ --vpc-egress all-traffic
6. Testare il servizio
Puoi testare il servizio eseguendo questi comandi:
PROMPT_TEXT="a cat sitting in a magnolia tree" SERVICE_URL=$(gcloud run services describe gpu-torchserve --region $REGION --format 'value(status.url)') time curl $SERVICE_URL/predictions/stable_diffusion -d "data=$PROMPT_TEXT" | base64 --decode > image.jpg
Assicurati di aggiungere le intestazioni di autorizzazione al comando curl se Cloud Run è configurato per richiedere l'autenticazione.
Nella directory attuale verrà visualizzato il file image.jpg. Puoi aprire l'immagine nell'editor di Cloud Shell per vedere l'immagine di un gatto seduto su un albero.
7. Complimenti!
Congratulazioni per aver completato il codelab.
Ti consigliamo di consultare la documentazione sulle GPU di Cloud Run.
Argomenti trattati
- Come eseguire un modello Stable Diffusion XL su Cloud Run utilizzando le GPU
8. Esegui la pulizia
Per evitare addebiti involontari (ad esempio, se questo job Cloud Run viene richiamato inavvertitamente più volte rispetto all'allocazione mensile di chiamate Cloud Run nel livello senza costi), puoi eliminare il job Cloud Run o il progetto che hai creato nel passaggio 2.
Per eliminare il job Cloud Run, vai alla console Cloud Run all'indirizzo https://console.cloud.google.com/run/ ed elimina il servizio gpu-torchserve.
Ti consigliamo anche di eliminare la configurazione di Cloud NAT.
Se scegli di eliminare l'intero progetto, puoi andare alla pagina https://console.cloud.google.com/cloud-resource-manager, selezionare il progetto che hai creato nel passaggio 2 e scegliere Elimina. Se elimini il progetto, dovrai cambiare progetto in Cloud SDK. Puoi visualizzare l'elenco di tutti i progetti disponibili eseguendo gcloud projects list.