Lea nuestro artículo sobre

.

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

Introducción

La difusión estable es un modelo de generación de imágenes. Fue de código abierto en 2022 y ha ganado popularidad por su capacidad para 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 icónicas como Moët & Chandon, Hennessy y Veuve Clicquot. Moët Hennessy ha colaborado con Artefact para investigar los usos potenciales de la tecnología punta en la generación de contenidos de marketing. Con un enfoque en 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 afinar y ejecutar el modelo dentro de su propia infraestructura, proporcionando una experiencia sin fisuras desde la puesta a punto 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á familiarizado con estos conceptos, se recomienda que se familiarice con ellos antes de continuar.
Además, para poder descargar los pesos de Difusión Estable necesita tener una cuenta huggingface, si aún no tiene una puede crearla fácilmente en Sitio web de huggingface.
Dicho esto, ¡comencemos!

Instalación y descarga de pesos

Recomiendo clonar el grepositorio ithub Me preparé para seguir los pasos del artículo.

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

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

Ya está listo para descargar los pesos de Difusión Estable, en este artículo utilizaremos Difusión estable 1,5. Debe aceptar la licencia en la página del modelo, de lo contrario tendrá errores al descargar los pesos del modelo.
Vaya a su cuenta → configuración → token de acceso → nuevo token (acceso de lectura).

Go to your account → settings → access token → new token (read access)

Puede añadir el token como una variable de entorno. Personalmente, recomiendo utilizar un archivo .env y cargar la variable de entorno utilizando la función biblioteca python-dotenv.
Debe navegar hasta `src/stable_diffusion` y ejecutar:

python descargar_modelo.py

Esto descargará los pesos dentro

`src/stable_diffusion/external_files/model_weights`.

Marco Torchserve

Torchserve es un marco para servir modelos PyTorch. Le permite desplegar modelos PyTorch en un entorno de producción y proporciona características como el versionado de modelos y el servicio multimodelo. 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. Creación de un manipulador que respete el formato TorchServe

Un manejador personalizado es una clase Python que define cómo preprocesar la entrada data, cómo ejecutar el modelo y cómo postprocesar la salida. Para crear un manejador personalizado para su modelo, necesitará crear una clase Python que siga el formato TorchServe.
Ya se proporciona un manejador personalizado para Difusión Estable dentro del repositorio TorchServe. Pero el punto final Vertex espera un formato específico para las peticiones, por lo que necesitamos adaptar el método preprocess() del manejador para tener en cuenta el formato Vertex. Puede utilizar la versión modificada del manejador llamada `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 manejador 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 le permite empaquetar su modelo, manejador y dependencias en un único archivo.

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

Puede que tenga que editar la ruta en función de dónde se encuentren los archivos en su máquina:

antorcha-modelo-archiver
-nombre-del-modelo difusión-estable
-versión 1.0
-handler difusión_estable/stable_diffusion_handler.py
-ruta de exportación difusión_estable/almacén_de_modelos
-archivos_externos stable_diffusion/external_files

3. Ejecutar su servidor TorchServe

Una vez que haya creado su archivo .mar, puede iniciar el servidor TorchServe utilizando el comando torchserve. Para ello, deberá ejecutar el siguiente comando:

torchserve
- empezar
- ts-config=config.properties
- models=difusión-estable.mar
- model-store=difusión_estable/model-store

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

Ejecute 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 servir_localmente.sh

Debe esperar unos minutos a que el servidor se inicialice y el trabajador cargue el modelo, puede empezar a ejecutar la inferencia si ve el siguiente registro:

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 código siguiente para realizar solicitudes de inferencia a su modelo:

solicitudes de importación
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

La difusión estable 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 funciona 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 puede construirlo con cloud build y ejecutarlo en su máquina.

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

build -t serve_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 tienen que copiarse 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, puede esperar a que el trabajador 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:

  • Construya la imagen utilizando Cloud Build dentro del registro de contenedores de google (gcr)
  • Cargue 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 deploy.sh script bash va a hacer, puede 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 su 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

  • Adjuntar el modelo al punto final lleva de 30 a 40 minutos

Una vez que el modelo se ha adjuntado correctamente al punto final, puede consultar el punto final 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(endpoint_name=ENDPOINT_ID)
text_input = """Una botella de coñac añejo y exclusivo
de pie sobre una superficie reflectante, frente a una barra vibrante,
hiperdetallado, 4K, bokeh"""

def query_endpoint(endpoint, text_input):
carga útil =
response = endpoint.predict(instances=[payload])
devolver respuesta

imagen = query_endpoint(endpoint, text_input)

Una botella de coñac añejo y exclusivo se alza sobre una superficie reflectante, delante de un bar vibrante, hiperdetallado, 4K, bokeh - Difusión estable 1.5

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

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

Es posible que desee hacer 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 punto final. En este caso, le recomiendo que utilice el método de posprocesamiento 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 manejador que hace precisamente esto por usted, cambiando de stable_diffusion_handler.py a stable_diffusion_handler_gcs.py debería servir.

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

  • Cree un cubo 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 punto final dentro del archivo deploy.sh. Necesita una cuenta de servicio con permisos de PROPIETARIO de GCS.

Conclusión

En este artículo se ofrece una guía completa para implantar el modelo de difusión estable en Google Cloud Platform utilizando Vertex AI.

La guía cubría pasos esenciales como:

  • Uso de TorchServe para el despliegue
  • Creación y modificación de un manipulador personalizado para la difusión estable
  • Despliegue del modelo utilizando el registro de modelos Vertex y los puntos finales Vertex

Es importante recordar que, aunque el punto final Vertex 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 realizado el despliegue del modelo de difusión estable, actualmente 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.

Medio Blog por Artefact.

Este artículo se publicó inicialmente en Medium.com.
¡Síganos en nuestro Medium Blog !