Cómo ejecutar TorchServe y Stable Diffusion en GPUs de Cloud Run

Cómo ejecutar TorchServe y Stable Diffusion en GPUs de Cloud Run

Acerca de este codelab

subjectÚltima actualización: sept 16, 2024
account_circleEscrito por un Googler

1. Introducción

Recientemente, Cloud Run agregó compatibilidad con GPU. Está disponible como versión preliminar pública en lista de espera. Si te interesa probar la función, completa este formulario para unirte a la lista de espera. Cloud Run es una plataforma de contenedores en Google Cloud que te permite ejecutar tu código en un contenedor de forma sencilla, sin necesidad de administrar un clúster.

Actualmente, las GPU que ponemos a disposición son las GPU NVIDIA L4 con 24 GB de vRAM. Hay una GPU por instancia de Cloud Run, y el ajuste de escala automático de Cloud Run se sigue aplicando. Esto incluye el escalamiento horizontal hasta 5 instancias (con aumento de cuota disponible), así como la reducción a cero instancias cuando no hay solicitudes.

En este codelab, crearás y, luego, implementarás una app de TorchServe que use stable diffusion XL para generar imágenes a partir de una instrucción de texto. La imagen generada se muestra al llamador como una cadena codificada en base64.

Este ejemplo se basa en Cómo ejecutar el modelo de difusión estable con difusores de Huggingface en Torchserve. En este codelab, se muestra cómo modificar este ejemplo para que funcione con Cloud Run.

Qué aprenderás

  • Cómo ejecutar un modelo de Stable Diffusion XL en Cloud Run con GPUs

2. Habilita las APIs y establece variables de entorno

Antes de comenzar a usar este codelab, deberás habilitar varias APIs. Para este codelab, debes usar las siguientes APIs. Para habilitar esas APIs, ejecuta el siguiente comando:

gcloud services enable run.googleapis.com \
    storage.googleapis.com \
    cloudbuild.googleapis.com \

Luego, puedes configurar las variables de entorno que se usarán en este codelab.

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. Crea la app de Torchserve

Primero, crea un directorio para el código fuente y ábrelo con el comando cd.

mkdir stable-diffusion-codelab && cd $_

Crea un archivo config.properties. Este es el archivo de configuración de 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

Ten en cuenta que, en este ejemplo, se usa la dirección de escucha http://0.0.0.0 para trabajar en Cloud Run. El puerto predeterminado de Cloud Run es el 8080.

Crea un archivo requirements.txt.

python-dotenv
accelerate
transformers
diffusers
numpy
google-cloud-storage
nvgpu

Crea un archivo llamado 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

Crea un archivo llamado start.sh. Este archivo se usa como punto de entrada en el contenedor para iniciar 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

Luego, ejecuta el siguiente comando para convertirlo en un archivo ejecutable.

chmod 755 start.sh

Crea una 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. Configura Cloud NAT

Cloud NAT te permite tener un ancho de banda más alto para acceder a Internet y descargar el modelo de HuggingFace, lo que acelerará significativamente los tiempos de implementación.

Para usar Cloud NAT, ejecuta el siguiente comando para habilitar una instancia de 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. Compila y, luego, implementa el servicio de Cloud Run

Envía tu código a Cloud Build.

gcloud builds submit --tag $IMAGE

A continuación, realiza la implementación en 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. Prueba el servicio

Para probar el servicio, ejecuta los siguientes comandos:

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

Verás que el archivo image.jpg aparece en tu directorio actual. Puedes abrir la imagen en el editor de Cloud Shell para ver la imagen de un gato sentado en un árbol.

7. ¡Felicitaciones!

¡Felicitaciones por completar el codelab!

Te recomendamos que revises la documentación sobre las GPU de Cloud Run.

Temas abordados

  • Cómo ejecutar un modelo de Stable Diffusion XL en Cloud Run con GPUs

8. Realiza una limpieza

Para evitar cargos imprevistos (por ejemplo, si este trabajo de Cloud Run se invoca por error más veces que tu asignación mensual de invocaciones de Cloud Run en el nivel gratuito), puedes borrar el trabajo de Cloud Run o el proyecto que creaste en el paso 2.

Para borrar el trabajo de Cloud Run, ve a la consola de Cloud Run en https://console.cloud.google.com/run/ y borra el servicio gpu-torchserve.

También te recomendamos que borres la configuración de Cloud NAT.

Si decides borrar todo el proyecto, puedes ir a https://console.cloud.google.com/cloud-resource-manager, seleccionar el proyecto que creaste en el paso 2 y elegir Borrar. Si borras el proyecto, deberás cambiar los proyectos en tu SDK de Cloud. Para ver la lista de todos los proyectos disponibles, ejecuta gcloud projects list.