1. מבוא
סקירה כללית
לאחרונה נוספה ל-Cloud Run תמיכה ב-GPU. התכונה זמינה ב-Public Preview, אבל צריך להירשם לרשימת המתנה כדי להשתמש בה. אם אתם רוצים לנסות את התכונה, אתם יכולים למלא את הטופס הזה כדי להצטרף לרשימת ההמתנה. Cloud Run היא פלטפורמת קונטיינרים ב-Google Cloud שמאפשרת להריץ את הקוד בקונטיינר בקלות, בלי צורך לנהל אשכול.
היום, מעבדי ה-GPU שאנחנו מציעים הם מעבדי Nvidia L4 עם 24GB של vRAM. יש GPU אחד לכל מכונה של Cloud Run, והתכונה 'התאמה אוטומטית לעומס' של Cloud Run עדיין חלה. זה כולל הרחבה של עד 5 מופעים (עם אפשרות להגדלת המכסה), וגם צמצום של עד אפס מופעים כשאין בקשות.
ב-Codelab הזה תלמדו איך ליצור ולפרוס אפליקציית TorchServe שמשתמשת ב-Stable Diffusion XL כדי ליצור תמונות מהנחיה טקסטואלית. התמונה שנוצרה מוחזרת למתקשר כמחרוזת מקודדת ב-Base64.
הדוגמה הזו מבוססת על הפעלת מודל דיפוזיה יציב באמצעות Huggingface Diffusers ב-Torchserve. ה-Codelab הזה מראה לכם איך לשנות את הדוגמה הזו כדי שהיא תפעל עם Cloud Run.
מה תלמדו
- איך מריצים מודל Stable Diffusion XL ב-Cloud Run באמצעות מעבדי GPU
2. הפעלת ממשקי API והגדרת משתני סביבה
לפני שמתחילים להשתמש ב-codelab הזה, צריך להפעיל כמה ממשקי API. ב-codelab הזה צריך להשתמש בממשקי ה-API הבאים. כדי להפעיל את ממשקי ה-API האלה, מריצים את הפקודה הבאה:
gcloud services enable run.googleapis.com \
storage.googleapis.com \
cloudbuild.googleapis.com
לאחר מכן תוכלו להגדיר משתני סביבה שישמשו אתכם לאורך כל ה-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
הערך שאתם מגדירים עבור REPOSITORY הוא מאגר Artifact Registry שבו יישמר קובץ האימג' שלכם. אפשר להשתמש בתווית קיימת או ליצור תווית חדשה:
gcloud artifacts repositories create $REPOSITORY \
--location=us-central1 \
--repository-format=docker
3. יצירת אפליקציית Torchserve
קודם יוצרים ספרייה לקוד המקור ועוברים לספרייה הזו.
mkdir stable-diffusion-codelab && cd $_
יוצרים קובץ config.properties. זהו קובץ התצורה של 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
שימו לב שבדוגמה הזו נעשה שימוש בכתובת ההאזנה http://0.0.0.0 כדי לעבוד ב-Cloud Run. יציאה 8080 היא יציאת ברירת המחדל ב-Cloud Run.
יוצרים קובץ requirements.txt.
python-dotenv accelerate transformers diffusers numpy google-cloud-storage nvgpu
יוצרים קובץ בשם 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
יוצרים קובץ בשם start.sh. הקובץ הזה משמש כנקודת כניסה בקונטיינר להפעלת 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
לאחר מכן מריצים את הפקודה הבאה כדי להפוך אותו לקובץ הפעלה.
chmod 755 start.sh
יצירת 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
Cloud NAT מאפשר לכם ליהנות מרוחב פס גבוה יותר כדי לגשת לאינטרנט ולהוריד את המודל מ-HuggingFace, וכך לקצר משמעותית את זמני הפריסה.
כדי להשתמש ב-Cloud NAT, מריצים את הפקודה הבאה כדי להפעיל מכונת 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. פיתוח ופריסה של שירות Cloud Run
שולחים את הקוד ל-Cloud Build.
gcloud builds submit --tag $IMAGE
לאחר מכן, פורסים ב-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. בדיקת השירות
כדי לבדוק את השירות, מריצים את הפקודות הבאות:
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
אם Cloud Run מוגדר לדרוש אימות, צריך להוסיף כותרות הרשאה לפקודת ה-curl.
קובץ image.jpg יופיע בספרייה הנוכחית. אפשר לפתוח את התמונה ב-Cloud Shell Editor כדי לראות תמונה של חתול שיושב על עץ.
7. מעולה!
כל הכבוד, סיימתם את ה-Codelab!
מומלץ לעיין במסמכי התיעוד בנושא GPU ב-Cloud Run.
מה נכלל
- איך מריצים מודל Stable Diffusion XL ב-Cloud Run באמצעות מעבדי GPU
8. הסרת המשאבים
כדי להימנע מחיובים לא מכוונים (לדוגמה, אם הפעלתם את עבודת Cloud Run יותר פעמים מההקצאה החודשית של הפעלות Cloud Run בחשבון בחינם), אתם יכולים למחוק את עבודת Cloud Run או את הפרויקט שיצרתם בשלב 2.
כדי למחוק את עבודת Cloud Run, נכנסים ל-Cloud Run Cloud Console בכתובת https://console.cloud.google.com/run/ ומוחקים את שירות gpu-torchserve.
כדאי גם למחוק את ההגדרה של Cloud NAT.
אם אתם רוצים למחוק את הפרויקט כולו, אתם יכולים להיכנס לכתובת https://console.cloud.google.com/cloud-resource-manager, לבחור את הפרויקט שיצרתם בשלב 2 וללחוץ על 'מחיקה'. אם תמחקו את הפרויקט, תצטרכו לשנות את הפרויקטים ב-Cloud SDK. כדי לראות את רשימת כל הפרויקטים הזמינים, מריצים את הפקודה gcloud projects list.