1. Введение
Обзор
В Cloud Run недавно добавили поддержку графических процессоров (GPU). Она доступна в режиме публичного предварительного просмотра (с возможностью ожидания). Если вы заинтересованы в тестировании этой функции, заполните эту форму , чтобы присоединиться к списку ожидания. Cloud Run — это контейнерная платформа на Google Cloud, которая упрощает запуск кода в контейнере, не требуя управления кластером.
Сегодня мы предоставляем только графические процессоры Nvidia L4 с 24 ГБ видеопамяти. На каждый экземпляр Cloud Run приходится один графический процессор, и автоматическое масштабирование Cloud Run по-прежнему применяется. Это включает масштабирование до 5 экземпляров (с возможностью увеличения квоты), а также масштабирование до нуля экземпляров при отсутствии запросов.
В этом практическом задании вы создадите и развернете приложение TorchServe, которое использует Stable Difference XL для генерации изображений на основе текстового запроса. Сгенерированное изображение возвращается вызывающей стороне в виде строки, закодированной в Base64.
Этот пример основан на модели стабильного распространения звука с использованием диффузоров Huggingface в Torchserve . В этом практическом руководстве показано, как модифицировать этот пример для работы с Cloud Run.
Что вы узнаете
- Как запустить модель Stable Diffusion XL в Cloud Run с использованием графических процессоров.
2. Включите API и установите переменные среды.
Прежде чем начать использовать этот практический пример, вам потребуется включить несколько API. Для работы с этим практическим примером необходимы следующие API. Вы можете включить эти API, выполнив следующую команду:
gcloud services enable run.googleapis.com \
storage.googleapis.com \
cloudbuild.googleapis.com
Затем вы можете установить переменные окружения, которые будут использоваться на протяжении всего этого практического занятия.
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 относится к репозиторию реестра артефактов, где будет храниться ваша сборка образа. Вы можете использовать существующий репозиторий или создать новый:
gcloud artifacts repositories create $REPOSITORY \
--location=us-central1 \
--repository-format=docker
3. Создайте приложение Torchserve.
Сначала создайте директорию для исходного кода и перейдите в неё с помощью команды `cd`.
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
Обратите внимание, что в этом примере для работы в Cloud Run используется адрес прослушивания http://0.0.0.0. Порт по умолчанию для Cloud Run — 8080.
Создайте файл 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. Настройка облачного NAT
Облачный 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, чтобы увидеть кошку, сидящую на дереве.
7. Поздравляем!
Поздравляем с завершением практического занятия!
Мы рекомендуем ознакомиться с документацией по Cloud Run GPUs .
Что мы рассмотрели
- Как запустить модель Stable Diffusion XL в Cloud Run с использованием графических процессоров.
8. Уборка
Чтобы избежать непреднамеренных списаний средств (например, если это задание Cloud Run будет случайно запущено больше раз, чем предусмотрено вашим ежемесячным лимитом на запуск заданий Cloud Run в бесплатном тарифе ), вы можете либо удалить задание Cloud Run, либо удалить проект, созданный на шаге 2.
Чтобы удалить задание Cloud Run, перейдите в консоль Cloud Run по адресу https://console.cloud.google.com/run/ и удалите службу gpu-torchserve .
Вам также потребуется удалить конфигурацию Cloud NAT .
Если вы решите удалить весь проект, перейдите по ссылке https://console.cloud.google.com/cloud-resource-manager , выберите проект, созданный на шаге 2, и нажмите «Удалить». После удаления проекта вам потребуется изменить проекты в вашем Cloud SDK. Список всех доступных проектов можно просмотреть, выполнив gcloud projects list .