1. Pengantar
Ringkasan
Cloud Run baru-baru ini menambahkan dukungan GPU. Fitur ini tersedia sebagai pratinjau publik dalam daftar tunggu. Jika Anda tertarik untuk mencoba fitur ini, isi formulir ini untuk bergabung ke daftar tunggu. Cloud Run adalah platform container di Google Cloud yang memudahkan Anda menjalankan kode dalam container, tanpa mengharuskan Anda mengelola cluster.
Saat ini, GPU yang kami sediakan adalah GPU Nvidia L4 dengan vRAM 24 GB. Ada satu GPU per instance Cloud Run, dan penskalaan otomatis Cloud Run masih berlaku. Hal ini mencakup penskalaan keluar hingga 5 instance (dengan penambahan kuota yang tersedia), serta penskalaan ke bawah hingga nol instance jika tidak ada permintaan.
Dalam codelab ini, Anda akan membuat dan men-deploy aplikasi TorchServe yang menggunakan difusi XL stabil untuk menghasilkan gambar dari perintah teks. Gambar yang dihasilkan ditampilkan kepada pemanggil sebagai string berenkode base64.
Contoh ini didasarkan pada Menjalankan model difusi Stabil menggunakan Diffuser Huggingface di Torchserve. Codelab ini menunjukkan cara mengubah contoh ini agar berfungsi dengan Cloud Run.
Yang akan Anda pelajari
- Cara menjalankan model Stable Diffusion XL di Cloud Run menggunakan GPU
2. Mengaktifkan API dan Menetapkan Variabel Lingkungan
Sebelum Anda dapat mulai menggunakan codelab ini, ada beberapa API yang perlu diaktifkan. Codelab ini memerlukan penggunaan API berikut. Anda dapat mengaktifkan API tersebut dengan menjalankan perintah berikut:
gcloud services enable run.googleapis.com \
storage.googleapis.com \
cloudbuild.googleapis.com
Kemudian, Anda dapat menetapkan variabel lingkungan yang akan digunakan di seluruh codelab ini.
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
Nilai yang Anda tetapkan untuk REPOSITORY adalah untuk repositori Artifact Registry tempat build image Anda akan disimpan. Anda dapat menggunakan yang sudah ada atau membuat yang baru:
gcloud artifacts repositories create $REPOSITORY \
--location=us-central1 \
--repository-format=docker
3. Membuat aplikasi Torchserve
Pertama, buat direktori untuk kode sumber dan cd ke direktori tersebut.
mkdir stable-diffusion-codelab && cd $_
Buat file config.properties. Ini adalah file konfigurasi untuk 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
Perhatikan bahwa dalam contoh ini, alamat pemrosesan http://0.0.0.0 digunakan untuk berfungsi di Cloud Run. Port default untuk Cloud Run adalah port 8080.
Buat file requirements.txt.
python-dotenv accelerate transformers diffusers numpy google-cloud-storage nvgpu
Buat file bernama 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
Buat file bernama start.sh File ini digunakan sebagai titik entri dalam penampung untuk memulai 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
Kemudian, jalankan perintah berikut untuk menjadikannya file yang dapat dieksekusi.
chmod 755 start.sh
Buat 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. Menyiapkan Cloud NAT
Cloud NAT memungkinkan Anda memiliki bandwidth yang lebih tinggi untuk mengakses internet dan mendownload model dari HuggingFace, yang akan mempercepat waktu deployment Anda secara signifikan.
Untuk menggunakan Cloud NAT, jalankan perintah berikut untuk mengaktifkan instance 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. Mem-build dan men-deploy layanan Cloud Run
Kirimkan kode Anda ke Cloud Build.
gcloud builds submit --tag $IMAGE
Selanjutnya, deploy ke 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. Menguji layanan
Anda dapat menguji layanan dengan menjalankan perintah berikut:
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
Pastikan untuk menambahkan header otorisasi ke perintah curl jika Cloud Run dikonfigurasi untuk mewajibkan autentikasi.
Anda akan melihat file image.jpg muncul di direktori saat ini. Anda dapat membuka gambar di Cloud Shell Editor untuk melihat gambar kucing yang sedang duduk di pohon.
7. Selamat!
Selamat, Anda telah menyelesaikan codelab.
Sebaiknya tinjau dokumentasi tentang GPU Cloud Run.
Yang telah kita bahas
- Cara menjalankan model Stable Diffusion XL di Cloud Run menggunakan GPU
8. Pembersihan
Untuk menghindari tagihan yang tidak disengaja, (misalnya, jika tugas Cloud Run ini tidak sengaja dipanggil lebih dari alokasi pemanggilan Cloud Run bulanan Anda di paket gratis), Anda dapat menghapus tugas Cloud Run atau menghapus project yang Anda buat di Langkah 2.
Untuk menghapus tugas Cloud Run, buka Cloud Console Cloud Run di https://console.cloud.google.com/run/ dan hapus layanan gpu-torchserve.
Anda juga dapat menghapus konfigurasi Cloud NAT.
Jika memilih untuk menghapus seluruh project, Anda dapat membuka https://console.cloud.google.com/cloud-resource-manager, memilih project yang Anda buat di Langkah 2, lalu memilih Hapus. Jika menghapus project, Anda harus mengubah project di Cloud SDK. Anda dapat melihat daftar semua project yang tersedia dengan menjalankan gcloud projects list.