Cách chạy TorchServe và Stable Diffusion trên GPU Cloud Run

Cách chạy TorchServe và Stable Diffusion trên GPU Cloud Run

Thông tin về lớp học lập trình này

subjectLần cập nhật gần đây nhất: thg 9 16, 2024
account_circleTác giả: Một nhân viên của Google

1. Giới thiệu

Tổng quan

Gần đây, Cloud Run đã thêm 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 theo 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 một vùng chứa mà không cần quản lý cụm.

Hiện tại, chúng tôi cung cấp 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 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 tối đa 5 phiên bản (có thể tăng hạn mức) cũng như thu hẹp quy mô xuống 0 phiên bản khi không có yêu cầu nào.

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 phương thức lan truyề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 phương thức 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 lan truyền ổn định bằng cách sử dụng Trình khuếch tán Huggingface 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 biến môi trường

Trước khi 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 sử dụng trong suốt lớp học lập trình này.

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. Tạo ứng dụng Torchserve

Trước tiên, hãy tạo một thư mục cho mã nguồn và cd vào 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("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

Tạo một tệp có tên 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 đó, hãy 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 Internet và tải mô hình xuống từ HuggingFace, 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 thực thể 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ụ này 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

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 trong Trình chỉnh sửa Cloud Shell để xem hình ảnh một con 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!

Bạn nên tham khảo 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í do nhầm lẫn (ví dụ: nếu công việc Cloud Run này vô tình được gọi nhiều lần hơn mức phân bổ số lần gọi Cloud Run hằng tháng trong cấp miễn phí), bạn có thể xoá công việc Cloud Run hoặc xoá dự án mà bạn đã tạo ở Bước 2.

Để xoá công việc trên Cloud Run, hãy truy cập vào Cloud Console của Cloud Run 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 SDK trên đám mây. Bạn có thể xem danh sách tất cả dự án hiện có bằng cách chạy gcloud projects list.