1. Wprowadzenie
Przegląd
Usługa Cloud Run niedawno zyskała obsługę procesorów graficznych. Jest ona dostępna w ramach publicznej wersji przedpremierowej, do której można dołączyć po zapisaniu się na listę oczekujących. Jeśli chcesz wypróbować tę funkcję, wypełnij ten formularz, aby dołączyć do listy oczekujących. Cloud Run to platforma kontenerowa w Google Cloud, która ułatwia uruchamianie kodu w kontenerze bez konieczności zarządzania klastrem.
Obecnie udostępniamy procesory graficzne Nvidia L4 z 24 GB pamięci vRAM. Na każdą instancję Cloud Run przypada 1 procesor graficzny, a autoskalowanie Cloud Run nadal obowiązuje. Obejmuje to skalowanie w górę do 5 instancji (z możliwością zwiększenia limitu) oraz skalowanie w dół do 0 instancji, gdy nie ma żadnych żądań.
W tym ćwiczeniu utworzysz i wdrożysz aplikację TorchServe, która używa stabilnej dyfuzji XL do generowania obrazów na podstawie promptu tekstowego. Wygenerowany obraz jest zwracany do wywołującego jako ciąg tekstowy zakodowany w formacie Base64.
Ten przykład jest oparty na artykule Running Stable diffusion model using Huggingface Diffusers in Torchserve (Uruchamianie modelu dyfuzyjnego Stable Diffusion przy użyciu Huggingface Diffusers w Torchserve). W tym laboratorium dowiesz się, jak zmodyfikować ten przykład, aby działał w Cloud Run.
Czego się nauczysz
- Jak uruchomić model Stable Diffusion XL w Cloud Run przy użyciu GPU
2. Włączanie interfejsów API i ustawianie zmiennych środowiskowych
Zanim zaczniesz korzystać z tego samouczka, musisz włączyć kilka interfejsów API. Ten przewodnik wymaga użycia tych interfejsów API: Możesz włączyć te interfejsy API, uruchamiając to polecenie:
gcloud services enable run.googleapis.com \
storage.googleapis.com \
cloudbuild.googleapis.com
Następnie możesz ustawić zmienne środowiskowe, których będziesz używać podczas naszych ćwiczeń z programowania.
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
Wartość ustawiona dla REPOSITORY dotyczy repozytorium Artifact Registry, w którym będzie przechowywana kompilacja obrazu. Możesz użyć istniejącego lub utworzyć nowy:
gcloud artifacts repositories create $REPOSITORY \
--location=us-central1 \
--repository-format=docker
3. Tworzenie aplikacji Torchserve
Najpierw utwórz katalog kodu źródłowego i przejdź do niego.
mkdir stable-diffusion-codelab && cd $_
Utwórz plik config.properties. Jest to plik konfiguracji 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
Pamiętaj, że w tym przykładzie używany jest adres nasłuchiwania http://0.0.0.0, aby działać w Cloud Run. Domyślny port Cloud Run to 8080.
Utwórz plik requirements.txt.
python-dotenv accelerate transformers diffusers numpy google-cloud-storage nvgpu
Utwórz plik o nazwie 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
Utwórz plik o nazwie start.sh. Ten plik jest używany jako punkt wejścia w kontenerze do uruchamiania 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
Następnie uruchom to polecenie, aby przekształcić go w plik wykonywalny.
chmod 755 start.sh
Utwórz 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. Konfigurowanie Cloud NAT
Cloud NAT umożliwia uzyskanie większej przepustowości dostępu do internetu i pobieranie modelu z HuggingFace, co znacznie przyspiesza wdrażanie.
Aby używać usługi Cloud NAT, uruchom to polecenie, aby włączyć instancję 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. Kompilowanie i wdrażanie usługi Cloud Run
Prześlij kod do Cloud Build.
gcloud builds submit --tag $IMAGE
Następnie wdróż w 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. Testowanie usługi
Możesz przetestować usługę, uruchamiając te polecenia:
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
Jeśli usługa Cloud Run jest skonfigurowana tak, aby wymagać uwierzytelniania, pamiętaj o dodaniu nagłówków autoryzacji do polecenia curl.
W bieżącym katalogu pojawi się plik image.jpg. Możesz otworzyć obraz w edytorze Cloud Shell, aby zobaczyć kota siedzącego na drzewie.
7. Gratulacje!
Gratulujemy ukończenia ćwiczenia!
Zalecamy zapoznanie się z dokumentacją dotyczącą procesorów graficznych Cloud Run.
Omówione zagadnienia
- Jak uruchomić model Stable Diffusion XL w Cloud Run przy użyciu GPU
8. Czyszczenie danych
Aby uniknąć przypadkowych opłat (np. jeśli to zadanie Cloud Run zostanie przypadkowo wywołane więcej razy niż miesięczny limit wywołań Cloud Run w warstwie bezpłatnej), możesz usunąć zadanie Cloud Run lub projekt utworzony w kroku 2.
Aby usunąć zadanie Cloud Run, otwórz Cloud Run w Cloud Console na stronie https://console.cloud.google.com/run/ i usuń usługę gpu-torchserve.
Warto też usunąć konfigurację Cloud NAT.
Jeśli zdecydujesz się usunąć cały projekt, otwórz stronę https://console.cloud.google.com/cloud-resource-manager, wybierz projekt utworzony w kroku 2 i kliknij Usuń. Jeśli usuniesz projekt, musisz zmienić projekty w Cloud SDK. Listę wszystkich dostępnych projektów możesz wyświetlić, uruchamiając polecenie gcloud projects list.