Lea nuestro artículo sobre

class="img-responsive

.

Este artículo proporciona una guía para desplegar el modelo Stable Diffusion, un popular modelo de generación de imágenes, en Google Cloud utilizando Vertex AI. La guía cubre la configuración y descarga de pesos, TorchServe para el despliegue, el servidor TorchServe desplegado en un endpoint Vertex y el guardado automático del historial de imágenes en GCS.

Introducción

Stable Diffusion es un modelo de generación de imágenes. Se puso en marcha en 2022 y ha ganado popularidad por su capacidad de generar imágenes de alta calidad a partir de descripciones de texto. Al igual que otros modelos de generación de imágenes, como Dall-E, Stable Diffusion utiliza técnicas de aprendizaje automático para generar imágenes a partir de una entrada determinada.

Moët Hennessy, la división de vinos y licores del conglomerado de lujo LVMH, gestiona una cartera de más de 26 marcas emblemáticas como Moët & Chandon, Hennessy y Veuve Clicquot. Moët Hennessy ha colaborado con Artefact para investigar los posibles usos de la tecnología punta en la generación de contenidos de marketing. Con especial atención a la privacidad y la seguridad, el equipo decidió explorar el despliegue de Stable Diffusion en Google Cloud Platform (GCP) para permitir a Moët Hennessy ajustar y ejecutar el modelo dentro de su propia infraestructura, proporcionando una experiencia sin fisuras desde el ajuste del modelo hasta la exposición de la API.

Antes de empezar, es importante tener en cuenta que este artículo asume que usted tiene conocimientos previos de Google Cloud Platform (GCP) y específicamente de Vertex AI. Esto incluye conceptos como el registro de modelos y los puntos finales de Vertex. Además, es necesario tener experiencia previa con Docker para seguir algunos de los pasos. Si no estás familiarizado con estos conceptos, se recomienda que te familiarices con ellos antes de continuar.
Además, para poder descargar Stable Diffusion weights necesitas tener una cuenta huggingface, si aún no la tienes puedes crearla fácilmente en la web de huggingface.
Dicho esto, ¡comencemos!

Instalación y descarga de pesos

Recomiendo clonar elrepositorio de github que he preparado para seguir los pasos del artículo.

Siempre es importante crear un entorno virtual para instalar los paquetes. Personalmente, usaré anaconda e instalaré el requirements.txt con cada dependencia:

conda create -n stable_diffusion - no-default-packages python=3.8 -y
conda activar stable_diffusion
pip install -r src/requisitos.txt

Ya está listo para descargar los pesos de Stable Diffusion, en este artículo utilizaremos Stable Diffusion 1.5. Necesitas aceptar la licencia en la página del modelo, de lo contrario tendrás errores al descargar los pesos del modelo.
Ve a tu cuenta → configuración → token de acceso → nuevo token (acceso de lectura).

Ve a tu cuenta → configuración → token de acceso → nuevo token (acceso de lectura).

Puedes añadir el token como una variable de entorno. Personalmente, recomiendo usar un archivo .env y cargar la variable de entorno usando la librería python-dotenv.
Tienes que navegar a `src/stable_diffusion` y ejecutar:

python descargar_modelo.py

Esto descargará los pesos dentro de

`src/stable_diffusion/external_files/model_weights`.

Marco Torchserve

Torchserve es un framework para servir modelos PyTorch. Le permite desplegar modelos PyTorch en un entorno de producción y proporciona características tales como versionado de modelos y servicio multi-modelo. Está diseñado para ser fácil de usar y le permite centrarse en la construcción y despliegue de sus modelos, en lugar de preocuparse por la infraestructura.

1. Crear un manejador que respete el formato TorchServe

Un manejador personalizado es una clase Python que define cómo pre-procesar la entrada data, cómo ejecutar el modelo, y cómo post-procesar la salida. Para crear un manejador personalizado para su modelo, necesitará crear una clase Python que siga el formato TorchServe.
Un manejador personalizado para Difusión Estable ya está dado dentro del repositorio TorchServe. Pero el endpoint Vertex espera un formato específico para las peticiones, así que necesitamos adaptar el método preprocess() del manejador para tener en cuenta el formato Vertex. Puede utilizar la versión modificada del manejador llamado `stable_diffusion_handler.py` dado dentro del repositorio github de este artículo.

2. Creación del archivo .mar

Una vez que haya creado su controlador personalizado, tendrá que empaquetarlo junto con cualquier dependencia y el propio modelo en un archivo .mar utilizando la herramienta model-archiver. La herramienta model-archiver es una herramienta de línea de comandos que permite empaquetar el modelo, el controlador y las dependencias en un único archivo.

Esto creará un archivo .mar llamado output.mar que contiene tu modelo, manejador y dependencias.

Es posible que tenga que modificar la ruta en función de la ubicación de los archivos en su equipo:

torch-model-archiver
-model-name stable-diffusion
-versión 1.0
-manejador stable_diffusion/stable_diffusion_handler.py
-ruta de exportación stable_diffusion/model-store
-extra-files stable_diffusion/external_files

3. Ejecutar su servidor TorchServe

Una vez que haya creado su fichero .mar, puede iniciar el servidor TorchServe utilizando el comando torchserve. Para hacer esto, necesitará ejecutar el siguiente comando:

torchserve
- iniciar
- ts-config=config.properties
- models=estable_diffusion.mar
- model-store=estable_diffusion/model-store

El config.properties le permite especificar las configuraciones de su servidor TorchServe, como el puerto para la inferencia, comprobaciones de salud, número de trabajadores, etc..
AVISO: Todos los scripts deben ejecutarse donde se encuentra el fichero para evitar errores de ruta.

Ejecutar el servidor TorchServe localmente

Es importante probar el código localmente antes de empezar a dockerizar nuestro despliegue, ya he preparado un script bash que creará el archivo .mar e iniciará el servidor TorchServe.

Puede ejecutarlo con :


bash serve_locally.sh

Necesitas esperar unos minutos para que el servidor se inicialice y el trabajador cargue el modelo, puedes empezar a ejecutar la inferencia si ves el siguiente log:

2023-01-05T15:34:52,842 [DEBUG] W-9000-stable-diffusion_1.0
org.pytorch.serve.wlm.WorkerThread- W-9000-stable-diffusion_1.0
Cambio de estado WORKER_STARTED -> WORKER_MODEL_LOADED

A continuación, puede utilizar el siguiente código para realizar solicitudes de inferencia a su modelo:

importar peticiones
prompt = "foto de un astronauta montando a caballo en marte"
URL = "http://localhost:7080/predictions/stable-diffusion"
response = requests.post(URL, data=prompt)

Puede comprobar que el servidor ha recibido su solicitud consultando los registros del servidor:

2023-01-05T15:35:43,765 [INFO ] W-9000-stable-diffusion_1.0-stdout
MODEL_LOG - Backend recibido inferencia en: 1672929343

Stable Diffusion requiere una GPU para funcionar sin problemas, por lo que no tendrá ninguna salida por el momento. Puede detener el servidor torchserve con `torhcserve -stop`.

Dockerizar torchserve

Su servidor TorchServe está funcionando localmente, para desplegar Stable Diffusion en Vertex AI, necesitará dockerizarlo. Esto significa crear una imagen Docker que contenga el modelo, el manejador personalizado, y todas las dependencias necesarias. Esto es simplemente todos los pasos que hemos hecho anteriormente dentro de un Dockerfile.
Por suerte, ya está preparado y listo para usar aquí : Dockerfile.

Es importante ejecutar el contenedor localmente para comprobar que funciona correctamente. Voy a construirlo localmente, pero puedes construirlo con cloud build y tirarlo en tu máquina.

Cree la imagen localmente (necesita que se ejecute el demonio Docker):

build -t servir_sd .

La construcción de la imagen tardará entre 20 y 30 minutos, la fase de construcción es larga porque los pesos del modelo necesitan ser copiados dentro de la imagen antes de ser empaquetados por el model-archiver.

Puede ejecutar un contenedor docker y escuchar en el puerto 7080 con:

docker run -p 7080:7080 serve_sd

Para comprobar que todo funciona correctamente, puedes esperar a que el worker haya cargado el modelo y ejecutar el mismo código de inferencia que antes, ya que estamos utilizando el mismo puerto 7080.

Despliegue en Vertex AI

Ahora que el Dockerfile está listo y funcionando, necesitamos:

  • Construir la imagen usando Cloud Build dentro de google container registry (gcr)
  • Cargar la imagen de nuestro modelo personalizado dentro del registro de modelos de Vertex AI

  • Crear un punto final Vertex AI
  • Adjuntar el modelo al punto final

Esto es exactamente lo que el script bash deploy.sh va a hacer, puedes ejecutarlo con:

bash deploy.sh

El despliegue tarda alrededor de 1 hora con una buena velocidad de Internet:

  • El envío de los 8 GB de pesos del modelo a Cloud Build puede tardar desde unos minutos hasta horas, dependiendo de la velocidad de Internet.
  • Construir la imagen lleva unos 20 minutos

  • Cargar el modelo lleva unos 5 minutos

  • Crear el punto final lleva unos 5 minutos

  • La conexión del modelo al punto final dura entre 30 y 40 minutos.

Una vez que el modelo se ha adjuntado correctamente al endpoint, puede consultar el endpoint con el siguiente código:

from google.cloud import aiplatform as aip

NOMBRE_PROYECTO = ""
REGIÓN = ""
ENDPOINT_ID = ""
aip.init(proyecto=NOMBRE_PROYECTO, ubicación=REGIÓN)
endpoint = aip.Endpoint(nombre_endpoint=ID_ENDPOINT)
text_input = """Una botella de coñac añejo y exclusivo
se alza sobre una superficie reflectante, frente a un vibrante bar,
hiperdetallado, 4K, bokeh""

def query_endpoint(endpoint, text_input):
payload = {“data”: text_input}
response = endpoint.predict(instances=[payload])
return response

image = query_endpoint(endpoint, text_input)
class="img-responsive

Una botella de coñac añejo y exclusivo sobre una superficie reflectante, delante de un bar vibrante, hiperdetallado, 4K, bokeh - Stable Diffusion 1.5

La inferencia debería tardar entre 10 y 15 segundos en la GPU T4. Puedes mejorar la velocidad eligiendo una GPU mejor, puedes cambiar la variable ACCELERATOR_TYPE dentro de deploy.sh.

Opcional: Si el tamaño de la imagen es demasiado grande para el endpoint, o si desea almacenar el historial de imágenes.

Es posible que desee realizar un seguimiento del historial de las imágenes, o que esté teniendo errores debido al límite de tamaño de 1,5 MB para la respuesta del endpoint. En este caso, recomiendo utilizar el método de post-proceso del manejador para guardar la imagen dentro de GCS y devolver sólo la ruta GCS de la imagen.

Por suerte, ya he preparado un handler que hace justamente esto por ti, cambiando de stable_diffusion_handler.py a stable_diffusion_handler_gcs.py debería funcionar.

ADVERTENCIA: Antes de ejecutar el despliegue con el nuevo controlador, es necesario:

  • Crear un bucket GCS que almacenará las imágenes

  • Edite el nombre del nuevo cubo GCS y la carpeta dentro de src/stable_diffusion/external_files/config.py

  • Cambie la cuenta de servicio utilizada por el endpoint dentro del archivo deploy.sh. Necesita una cuenta de servicio con permisos GCS OWNER.

Conclusión

En este artículo, se ha proporcionado una guía completa para desplegar el modelo Stable Diffusion en Google Cloud Platform utilizando Vertex AI.

La guía abarcaba pasos esenciales como:

  • Uso de TorchServe para el despliegue
  • Creación y modificación de un controlador personalizado para la difusión estable
  • Despliegue del modelo mediante el registro de modelos Vertex y Vertex Endpoints

Es importante recordar que, aunque Vertex Endpoint puede ser una solución eficaz, no admite el escalado a 0 instancias, lo que podría suponer un aumento de los costes al seguir utilizándose la GPU.

Además, una vez finalizado el despliegue del modelo de difusión estable, estamos explorando otras posibilidades, como el ajuste del modelo en productos específicos de Moet Hennessy para mejorar aún más las capacidades del modelo.

class="img-responsive

Blog de Medium por Artefact.

Este artículo fue publicado inicialmente en Medium.com.
¡Síganos en nuestro blog de Medium!