1. Einführung
Übersicht
Cloud Run unterstützt seit Kurzem GPUs. Sie ist als öffentliche Vorschau mit Warteliste verfügbar. Wenn Sie die Funktion ausprobieren möchten, füllen Sie dieses Formular aus, um sich auf die Warteliste setzen zu lassen. Cloud Run ist eine Containerplattform in Google Cloud, mit der Sie Ihren Code ganz einfach in einem Container ausführen können, ohne einen Cluster verwalten zu müssen.
Derzeit stellen wir NVIDIA L4-GPUs mit 24 GB vRAM zur Verfügung. Es gibt eine GPU pro Cloud Run-Instanz und das Autoscaling von Cloud Run gilt weiterhin. Dazu gehört das Hochskalieren auf bis zu 5 Instanzen (mit Kontingenterhöhung) sowie das Herunterskalieren auf null Instanzen, wenn keine Anfragen vorhanden sind.
In diesem Codelab erstellen und stellen Sie eine TorchServe-App bereit, die Stable Diffusion XL verwendet, um Bilder aus einem Text-Prompt zu generieren. Das generierte Bild wird als base64-codierter String an den Aufrufer zurückgegeben.
Dieses Beispiel basiert auf Running Stable diffusion model using Huggingface Diffusers in Torchserve. In diesem Codelab erfahren Sie, wie Sie dieses Beispiel für die Verwendung mit Cloud Run ändern.
Lerninhalte
- Stable Diffusion XL-Modell mit GPUs in Cloud Run ausführen
2. APIs aktivieren und Umgebungsvariablen festlegen
Bevor Sie mit diesem Codelab beginnen können, müssen Sie mehrere APIs aktivieren. Für dieses Codelab müssen Sie die folgenden APIs verwenden. Sie können diese APIs mit dem folgenden Befehl aktivieren:
gcloud services enable run.googleapis.com \
storage.googleapis.com \
cloudbuild.googleapis.com
Anschließend können Sie Umgebungsvariablen festlegen, die in diesem Codelab verwendet werden.
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
Der Wert, den Sie für REPOSITORY festlegen, gilt für das Artifact Registry-Repository, in dem Ihr Image-Build gespeichert wird. Sie können einen vorhandenen verwenden oder einen neuen erstellen:
gcloud artifacts repositories create $REPOSITORY \
--location=us-central1 \
--repository-format=docker
3. Torchserve-App erstellen
Erstellen Sie zuerst ein Verzeichnis für den Quellcode und wechseln Sie in dieses Verzeichnis.
mkdir stable-diffusion-codelab && cd $_
Erstellen Sie eine config.properties-Datei. Dies ist die Konfigurationsdatei für 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
In diesem Beispiel wird die Listening-Adresse http://0.0.0.0 verwendet, um in Cloud Run zu arbeiten. Der Standardport für Cloud Run ist Port 8080.
Erstellen Sie eine requirements.txt-Datei.
python-dotenv accelerate transformers diffusers numpy google-cloud-storage nvgpu
Erstellen Sie eine Datei mit dem Namen 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
Erstellen Sie eine Datei mit dem Namen start.sh. Diese Datei wird als Einstiegspunkt im Container verwendet, um TorchServe zu starten.
#!/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
Führen Sie dann den folgenden Befehl aus, um daraus eine ausführbare Datei zu machen.
chmod 755 start.sh
Erstellen Sie einen 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. Cloud NAT einrichten
Mit Cloud NAT haben Sie eine höhere Bandbreite für den Internetzugriff und das Herunterladen des Modells von HuggingFace, was die Bereitstellungszeiten erheblich verkürzt.
Wenn Sie Cloud NAT verwenden möchten, führen Sie den folgenden Befehl aus, um eine Cloud NAT-Instanz zu aktivieren:
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. Cloud Run-Dienst erstellen und bereitstellen
Senden Sie Ihren Code an Cloud Build.
gcloud builds submit --tag $IMAGE
Als Nächstes in Cloud Run bereitstellen
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. Dienst testen
Sie können den Dienst mit den folgenden Befehlen testen:
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
Fügen Sie dem curl-Befehl Autorisierungsheader hinzu, wenn für Cloud Run eine Authentifizierung erforderlich ist.
Die Datei image.jpg wird in Ihrem aktuellen Verzeichnis angezeigt. Sie können das Bild im Cloud Shell-Editor öffnen, um das Bild einer Katze zu sehen, die auf einem Baum sitzt.
7. Glückwunsch!
Herzlichen Glückwunsch zum Abschluss des Codelabs!
Wir empfehlen, die Dokumentation zu Cloud Run-GPUs zu lesen.
Behandelte Themen
- Stable Diffusion XL-Modell mit GPUs in Cloud Run ausführen
8. Bereinigen
Damit keine unbeabsichtigten Gebühren anfallen (z. B. wenn dieser Cloud Run-Job unbeabsichtigt öfter aufgerufen wird als Ihre monatliche Cloud Run-Aufrufkontingent im Free-Tier), können Sie entweder den Cloud Run-Job oder das Projekt löschen, das Sie in Schritt 2 erstellt haben.
Wenn Sie den Cloud Run-Job löschen möchten, rufen Sie die Cloud Run Cloud Console unter https://console.cloud.google.com/run/ auf und löschen Sie den gpu-torchserve-Dienst.
Sie sollten auch Ihre Cloud NAT-Konfiguration löschen.
Wenn Sie das gesamte Projekt löschen möchten, rufen Sie https://console.cloud.google.com/cloud-resource-manager auf, wählen Sie das Projekt aus, das Sie in Schritt 2 erstellt haben, und klicken Sie auf „Löschen“. Wenn Sie das Projekt löschen, müssen Sie das Projekt in Ihrem Cloud SDK ändern. Sie können die Liste aller verfügbaren Projekte mit gcloud projects list aufrufen.