1. Giới thiệu
Tổng quan
Cloud Run mới bổ sung tính năng hỗ trợ GPU. Tính năng này hiện đang ở giai đoạn dùng thử công khai (có trong danh sách chờ). Nếu bạn muốn dùng thử tính năng này, hãy điền vào biểu mẫu này để tham gia danh sách chờ. Cloud Run là một nền tảng vùng chứa trên Google Cloud, giúp bạn dễ dàng chạy mã trong vùng chứa mà không cần quản lý một cụm.
Hiện tại, GPU mà chúng tôi cung cấp là GPU Nvidia L4 với 24 GB vRAM. Mỗi phiên bản Cloud Run có một GPU và tính năng tự động mở rộng quy mô của Cloud Run vẫn được áp dụng. Điều này bao gồm việc mở rộng quy mô lên đến 5 phiên bản (có thể tăng hạn mức), cũng như giảm quy mô xuống 0 phiên bản khi không có yêu cầu.
Trong lớp học lập trình này, bạn sẽ tạo và triển khai một ứng dụng TorchServe sử dụng mô hình khuếch tán ổn định XL để tạo hình ảnh từ một câu lệnh văn bản. Hình ảnh được tạo sẽ được trả về cho người gọi dưới dạng một chuỗi được mã hoá base64.
Ví dụ này dựa trên Chạy mô hình Stable Diffusion bằng Huggingface Diffusers trong Torchserve. Lớp học lập trình này hướng dẫn bạn cách sửa đổi ví dụ này để hoạt động với Cloud Run.
Kiến thức bạn sẽ học được
- Cách chạy mô hình Stable Diffusion XL trên Cloud Run bằng GPU
2. Bật API và đặt các biến môi trường
Để có thể bắt đầu sử dụng lớp học lập trình này, bạn cần bật một số API. Lớp học lập trình này yêu cầu bạn sử dụng các API sau. Bạn có thể bật các API đó bằng cách chạy lệnh sau:
gcloud services enable run.googleapis.com \
storage.googleapis.com \
cloudbuild.googleapis.com
Sau đó, bạn có thể thiết lập các biến môi trường sẽ được dùng trong suốt lớp học lập trình này.
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
Giá trị bạn đặt cho REPOSITORY là cho kho lưu trữ Artifact Registry nơi bản dựng hình ảnh của bạn sẽ được lưu trữ. Bạn có thể sử dụng một tài khoản hiện có hoặc tạo một tài khoản mới:
gcloud artifacts repositories create $REPOSITORY \
--location=us-central1 \
--repository-format=docker
3. Tạo ứng dụng Torchserve
Trước tiên, hãy tạo một thư mục cho mã nguồn và chuyển đến thư mục đó.
mkdir stable-diffusion-codelab && cd $_
Tạo tệp config.properties. Đây là tệp cấu hình cho 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
Xin lưu ý rằng trong ví dụ này, địa chỉ nghe http://0.0.0.0 được dùng để hoạt động trên Cloud Run. Cổng mặc định cho Cloud Run là cổng 8080.
Tạo tệp requirements.txt.
python-dotenv accelerate transformers diffusers numpy google-cloud-storage nvgpu
Tạo một tệp có tên là 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
Tạo một tệp có tên là start.sh. Tệp này được dùng làm điểm truy cập trong vùng chứa để khởi động 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
Sau đó, chạy lệnh sau để biến tệp này thành tệp thực thi.
chmod 755 start.sh
Tạo 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. Thiết lập Cloud NAT
Cloud NAT cho phép bạn có băng thông cao hơn để truy cập vào Internet và tải mô hình xuống từ HuggingFace, điều này sẽ giúp tăng tốc đáng kể thời gian triển khai.
Để sử dụng Cloud NAT, hãy chạy lệnh sau để bật một phiên bản 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. Tạo và triển khai dịch vụ Cloud Run
Gửi mã của bạn đến Cloud Build.
gcloud builds submit --tag $IMAGE
Tiếp theo, hãy triển khai lên 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. Kiểm thử dịch vụ
Bạn có thể kiểm thử dịch vụ bằng cách chạy các lệnh sau:
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
Nhớ thêm tiêu đề uỷ quyền vào lệnh curl nếu Cloud Run được định cấu hình để yêu cầu xác thực.
Bạn sẽ thấy tệp image.jpg xuất hiện trong thư mục hiện tại. Bạn có thể mở hình ảnh này trong Cloud Shell Editor để xem hình ảnh một chú mèo đang ngồi trên cây.
7. Xin chúc mừng!
Chúc mừng bạn đã hoàn thành lớp học lập trình này!
Bạn nên xem tài liệu về GPU Cloud Run.
Nội dung đã đề cập
- Cách chạy mô hình Stable Diffusion XL trên Cloud Run bằng GPU
8. Dọn dẹp
Để tránh bị tính phí ngoài ý muốn (ví dụ: nếu vô tình gọi lệnh này nhiều lần hơn hạn mức gọi Cloud Run hằng tháng của bạn trong cấp miễn phí), bạn có thể xoá lệnh Cloud Run này hoặc xoá dự án mà bạn đã tạo ở Bước 2.
Để xoá tác vụ Cloud Run, hãy truy cập vào Cloud Run Cloud Console tại https://console.cloud.google.com/run/ rồi xoá dịch vụ gpu-torchserve.
Bạn cũng nên xoá cấu hình Cloud NAT.
Nếu chọn xoá toàn bộ dự án, bạn có thể truy cập vào https://console.cloud.google.com/cloud-resource-manager, chọn dự án bạn đã tạo ở Bước 2 rồi chọn Xoá. Nếu xoá dự án, bạn sẽ cần thay đổi dự án trong Cloud SDK. Bạn có thể xem danh sách tất cả các dự án có sẵn bằng cách chạy gcloud projects list.