1. Giriş
Genel Bakış
Cloud Run'a kısa süre önce GPU desteği eklendi. Bu özellik, bekleme listesindeki herkese açık bir önizleme olarak kullanılabilir. Özelliği denemek istiyorsanız bekleme listesine katılmak için bu formu doldurun. Cloud Run, Google Cloud'daki bir kapsayıcı platformudur. Bu platform, bir küme yönetmenize gerek kalmadan kodunuzu bir kapsayıcıda çalıştırmayı kolaylaştırır.
Şu anda kullanıma sunduğumuz GPU'lar, 24 GB vRAM'e sahip Nvidia L4 GPU'lardır. Her Cloud Run örneği için bir GPU vardır ve Cloud Run otomatik ölçeklendirmesi geçerli olmaya devam eder. Bu, 5 taneye kadar ölçeklendirme (kota artışı kullanılabilir) ve istek olmadığında sıfır örneğe ölçeklendirmeyi içerir.
Bu codelab'de, metin isteminden resim oluşturmak için stable diffusion XL kullanan bir TorchServe uygulaması oluşturup dağıtacaksınız. Oluşturulan resim, arayana base64 kodlu bir dize olarak döndürülür.
Bu örnek, Torchserve'de Huggingface Diffusers'ı kullanarak kararlı difüzyon modelini çalıştırma başlıklı makaleyi temel almaktadır. Bu kod laboratuvarında, bu örneği Cloud Run ile çalışacak şekilde nasıl değiştireceğiniz gösterilmektedir.
Neler öğreneceksiniz?
- GPU'ları kullanarak Cloud Run'da kararlı difüzyon XL modeli çalıştırma
2. API'leri Etkinleştirme ve Ortam Değişkenlerini Ayarlama
Bu kod laboratuvarını kullanmaya başlamadan önce etkinleştirmeniz gereken birkaç API vardır. Bu kod laboratuvarının çalışması için aşağıdaki API'lerin kullanılması gerekir. Aşağıdaki komutu çalıştırarak bu API'leri etkinleştirebilirsiniz:
gcloud services enable run.googleapis.com \
storage.googleapis.com \
cloudbuild.googleapis.com \
Ardından, bu codelab boyunca kullanılacak ortam değişkenlerini ayarlayabilirsiniz.
PROJECT_ID=<YOUR_PROJECT_ID> REPOSITORY=repo NETWORK_NAME=default REGION=us-central1 IMAGE=us-central1-docker.pkg.dev/$PROJECT_ID/$REPOSITORY/gpu-torchserve
3. Torchserve uygulamasını oluşturma
Öncelikle kaynak kod için bir dizin oluşturun ve cd komutunu kullanarak bu dizine gidin.
mkdir stable-diffusion-codelab && cd $_
config.properties dosyası oluşturun. Bu, TorchServe'in yapılandırma dosyasıdır.
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
Bu örnekte, Cloud Run'da çalışmak için http://0.0.0.0 dinleme adresi kullanıldığını unutmayın. Cloud Run için varsayılan bağlantı noktası 8080'dir.
requirements.txt dosyası oluşturun.
python-dotenv accelerate transformers diffusers numpy google-cloud-storage nvgpu
stable_diffusion_handler.py adlı bir dosya oluşturun
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("Donwloading 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 donwloading model %s", model_name)
# open the pipeline to the refiner
# refiner is used to remove artifacts from the image
logger.info("Donwloading 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 donwloading 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 adlı bir dosya oluşturun. Bu dosya, TorchServe'i başlatmak için kapsayıcıda giriş noktası olarak kullanılır.
#!/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
Ardından, yürütülebilir bir dosya haline getirmek için aşağıdaki komutu çalıştırın.
chmod 755 start.sh
Bir dockerfile oluşturun.
# 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'i ayarlama
Cloud NAT, internete erişmek ve modeli HuggingFace'tan indirmek için daha yüksek bant genişliğine sahip olmanızı sağlar. Bu da dağıtım sürelerinizi önemli ölçüde kısaltır.
Cloud NAT'i kullanmak için bir Cloud NAT örneğini etkinleştirmek üzere aşağıdaki komutu çalıştırın:
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 hizmetini derleyip dağıtma
Kodunuzu Cloud Build'e gönderin.
gcloud builds submit --tag $IMAGE
Ardından, Cloud Run'a dağıtın
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. Hizmeti test etme
Aşağıdaki komutları çalıştırarak hizmeti test edebilirsiniz:
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
Geçerli dizininizde image.jpg dosyası gösterilir. Bir ağaçta oturan bir kedinin resmini görmek için resmi Cloud Shell Düzenleyici'de açabilirsiniz.
7. Tebrikler!
Codelab'i tamamladığınız için tebrikler.
Cloud Run GPU'ları ile ilgili dokümanları incelemenizi öneririz.
Ele aldığımız konular
- GPU'ları kullanarak Cloud Run'da kararlı difüzyon XL modeli çalıştırma
8. Temizleme
Yanlışlıkla yapılan ödemeleri önlemek için (örneğin, bu Cloud Run işi yanlışlıkla ücretsiz kademede aylık Cloud Run çağrısı tahsisatınızdan daha fazla kez çağrılırsa) Cloud Run işini veya 2. adımda oluşturduğunuz projeyi silebilirsiniz.
Cloud Run işini silmek için https://console.cloud.google.com/run/ adresindeki Cloud Run Cloud Console'a gidin ve gpu-torchserve hizmetini silin.
Ayrıca Cloud NAT yapılandırmanızı da silmeniz gerekir.
Projenin tamamını silmeyi seçerseniz https://console.cloud.google.com/cloud-resource-manager adresine gidip 2. adımda oluşturduğunuz projeyi seçin ve Sil'i tıklayın. Projeyi silerseniz Cloud SDK'nızdaki projeleri değiştirmeniz gerekir. gcloud projects list komutunu çalıştırarak mevcut tüm projelerin listesini görüntüleyebilirsiniz.