Entrega predicciones con Triton de NVIDIA

En esta página, se describe cómo entregar solicitudes de predicción con el servidor de inferencia de NVIDIA Triton mediante Vertex AI Prediction. El servidor de inferencia de Triton de NVIDIA (Triton) es una solución de entrega de inferencia de código abierto de NVIDIA optimizada para CPU y GPU y simplifica el proceso de entrega de inferencia.

Triton de NVIDIA en Vertex AI Prediction

Vertex AI Prediction admite la implementación de modelos en el servidor de inferencia de Triton que se ejecutan en un contenedor personalizado publicado por NVIDIA GPU Cloud (NGC): Imagen de servidor de Triton de NVIDIA. Las imágenes de Triton de NVIDIA tienen todos los paquetes y las configuraciones necesarios que cumplen con los requisitos de Vertex AI para las imágenes personalizadas de contenedor de entrega. La imagen contiene el servidor de inferencia de Triton compatible con los modelos de TensorFlow, PyTorch, TensorRT, ONNX y OpenVINO. La imagen también incluye el backend de FIL (Biblioteca de inferencia de bosque) que admite la ejecución de frameworks de AA, como XGBoost, LightGBM y Scikit-Learn.

Triton carga los modelos y expone los extremos de REST de administración de modelo, inferencia y estado que usan protocolos de inferencia estándar. Mientras se implementa un modelo en Vertex AI, Triton reconoce los entornos de Vertex AI y adopta el protocolo de Vertex AI Prediction para las verificaciones de estado y solicitudes de predicción.

En la siguiente lista, se describen las funciones clave y los casos prácticos del servidor de inferencia de Triton de NVIDIA:

  • Compatibilidad con varios frameworks de aprendizaje automático y aprendizaje profundo: Triton admite la implementación de varios modelos y una combinación de frameworks y formatos de modelo: backends de FIL, TensorFlow (modelo guardado y GraphDef), PyTorch (TorchScript), TensorRT, ONNX y OpenVINO para admitir frameworks como XGBoost, LightGBM, scikit-learn y cualquier formato de modelo personalizado de Python o C++.
  • Ejecución simultánea de varios modelos: Triton permite que varios modelos, varias instancias del mismo modelo o ambos se ejecuten de forma simultánea en el mismo recurso de procesamiento con cero o más GPU.
  • Ensamble de modelos (encadenamiento o canalización): el ensamble de Triton admite casos prácticos en los que varios modelos se componen como una canalización (o un DAG, grafo acíclico dirigido) con tensores de entrada y salida conectados entre ellos. Además, con un backend de Python de Triton, puedes incluir cualquier lógica de flujo de procesamiento previo, procesamiento posterior o control que se defina por secuencias de comandos de lógicas empresariales (BLS).
  • Ejecución en backends de GPU y CPU: Triton admite inferencia para modelos implementados en nodos con CPU y GPU.
  • Agrupación en lotes dinámica de solicitudes de predicción: En los modelos que admiten el procesamiento por lotes, Triton tiene algoritmos integrados de programación y agrupación en lotes. Estos algoritmos combinan de forma dinámica las solicitudes de inferencia individuales en lotes en el lado del servidor para mejorar la capacidad de procesamiento de la inferencia y aumentar el uso de la GPU.

Para obtener más información sobre el servidor de inferencia de Triton de NVIDIA, consulta la documentación de Triton.

Imágenes de contenedor de Triton de NVIDIA disponibles

En la siguiente tabla, se muestra lo siguiente:Imágenes de Triton Docker disponibles en el catálogo de NVIDIA NGC. Elige una imagen según el framework del modelo, el backend y el tamaño de la imagen de contenedor que uses.

xx y yy hacen referencia a versiones principales y secundarias de Triton, en ese orden.

Imagen de Triton de NVIDIA Admite
xx.yy-py3 Contenedor completo compatible con los modelos de TensorFlow, PyTorch, TensorRT, ONNX y OpenVINO
xx.yy-pyt-python-py3 Solo backends de PyTorch y Python
xx.yy-tf2-python-py3 Solo backends de TensorFlow 2.x y Python
xx.yy-py3-min Personaliza el contenedor de Triton según sea necesario

Comenzar: Entrega predicciones con Triton de NVIDIA

En la siguiente figura, se muestra la arquitectura de alto nivel de Triton en Vertex AI Prediction:

triton-on-vertex-ai-prediction

  • Un modelo de AA que entrega Triton se registra con Vertex AI Model Registry. Los metadatos del modelo hacen referencia a la ubicación de los artefactos del modelo en Cloud Storage, el contenedor de entrega personalizado y su configuración.
  • El modelo de Vertex AI Model Registry se implementa en un extremo de Vertex AI Prediction que ejecuta el servidor de inferencia de Triton como un contenedor personalizado en los nodos de procesamiento con CPU y GPU.
  • Las solicitudes de inferencia llegan al servidor de inferencia de Triton a través de un extremo de Vertex AI Prediction y se enrutan al programador adecuado.
  • El backend realiza inferencias mediante las entradas proporcionadas en las solicitudes por lotes y muestra una respuesta.
  • Triton proporciona extremos de estado de funcionamiento y preparación, que permiten la integración de Triton en entornos de implementación, como Vertex AI Prediction.

En este instructivo, se muestra cómo usar un contenedor personalizado que ejecuta el servidor de inferencia de Triton de NVIDIA para implementar un modelo de aprendizaje automático (AA) en Vertex AI Prediction, que entrega predicciones en línea. Implementas un contenedor que ejecuta Triton para entregar predicciones de un modelo de detección de objetos de TensorFlow Hub que se entrenó previamente en la Conjunto de datos COCO 2017. Luego, puedes usar Vertex AI Prediction para detectar objetos en una imagen.

También puedes ejecutar el instructivo en Vertex AI Workbench si sigues este notebook de Jupyter.

Antes de comenzar

  1. Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

  2. En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.

    Ir al selector de proyectos

  3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

  4. Habilita las API de Vertex AI API and Artifact Registry API.

    Habilita las API

    5.

  5. En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.

    Ir al selector de proyectos

  6. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

  7. Habilita las API de Vertex AI API and Artifact Registry API.

    Habilita las API

    8.

  8. En la consola de Google Cloud, activa Cloud Shell.

    Activar Cloud Shell

    En la parte inferior de la consola de Google Cloud, se inicia una sesión de Cloud Shell en la que se muestra una ventana de línea de comandos. Cloud Shell es un entorno de shell con Google Cloud CLI ya instalada y con valores ya establecidos para el proyecto actual. La sesión puede tardar unos segundos en inicializarse.

Durante este instructivo, te recomendamos que uses Cloud Shell para interactuar con Google Cloud. Si quieres usar un shell de Bash diferente en lugar de Cloud Shell, realiza la siguiente configuración adicional:

  1. Instala Google Cloud CLI.

  2. Para inicializar la CLI de gcloud, ejecuta el siguiente comando: 

    gcloud init
  3. Sigue la documentación de Artifact Registry para instalar Docker.

Compila y envía la imagen de contenedor

Para usar un contenedor personalizado, debes especificar una imagen de contenedor de Docker que cumpla con los requisitos de contenedores personalizados. En esta sección, se describe cómo crear la imagen del contenedor y enviarla a Artifact Registry.

Descarga artefactos de modelo

Los artefactos de modelo son archivos que crea el entrenamiento de AA que puedes usar para entregar predicciones. Contienen, como mínimo, la estructura y los pesos de tu modelo de AA entrenado. El formato de los artefactos del modelo depende del marco de trabajo de AA que uses para el entrenamiento.

Para este instructivo, en lugar de entrenar un modelo desde cero, descarga el modelo de detección de objetos de TensorFlow Hub que se entrenó en el conjunto de datos COCO 2017. Triton espera que el repositorio de modelos se organice en la siguiente estructura para entregar el formato de TensorFlow SavedModel:

└── model-repository-path
       └── model_name
              ├── config.pbtxt
              └── 1
                  └── model.savedmodel
                        └── <saved-model-files>

El archivo config.pbtxt describe la configuración del modelo. De forma predeterminada, se debe proporcionar el archivo de configuración del modelo que contiene la configuración necesaria. Sin embargo, si Triton se inicia con la opción --strict-model-config=false, en algunos casos, la configuración del modelo se puede generar de forma automática mediante Triton y no debe proporcionarse de forma explícita. En particular, los modelos de SavedModel de TensorFlow, TensorRT y ONNX no requieren un archivo de configuración del modelo, ya que Triton puede derivar toda la configuración necesaria de forma automática. Todos los demás tipos de modelos deben proporcionar un archivo de configuración del modelo.

# Download and organize model artifacts according to the Triton model repository spec
mkdir -p models/object_detector/1/model.savedmodel/
curl -L "https://tfhub.dev/tensorflow/faster_rcnn/resnet101_v1_640x640/1?tf-hub-format=compressed" | \
    tar -zxvC ./models/object_detector/1/model.savedmodel/
ls -ltr ./models/object_detector/1/model.savedmodel/

Después de descargar el modelo de forma local, el repositorio de modelos se organizará de la siguiente manera:

./models
└── object_detector
    └── 1
        └── model.savedmodel
            ├── saved_model.pb
            └── variables
                ├── variables.data-00000-of-00001
                └── variables.index

Copia los artefactos de modelo a un bucket de Cloud Storage

Los artefactos del modelo descargado, incluido el archivo de configuración del modelo, se envían a un bucket de Cloud Storage que especifica MODEL_ARTIFACTS_REPOSITORY, que se puede usar cuando creas el recurso del modelo de Vertex AI.

gsutil cp -r ./models/object_detector MODEL_ARTIFACTS_REPOSITORY/

Crea un repositorio de Artifact Registry

Crea un repositorio de Artifact Registry para almacenar la imagen de contenedor que crearás en la próxima sección.

Habilita el servicio de la API de Artifact Registry para tu proyecto.

gcloud services enable artifactregistry.googleapis.com

Ejecuta el siguiente comando en la shell para crear un repositorio de Artifact Registry:

gcloud artifacts repositories create getting-started-nvidia-triton \
 --repository-format=docker \
 --location=LOCATION \
 --description="NVIDIA Triton Docker repository"

Reemplaza LOCATION por la región en la que Artifact Registry almacena la imagen de contenedor. Más adelante, debes crear un recurso de modelo de Vertex AI en un extremo regional que coincida con esta región, por lo que debes elegir una región en la que Vertex AI tenga un extremo regional. como us-central1.

Después de completar la operación, el comando imprime el siguiente resultado:

Created repository [getting-started-nvidia-triton].

Compila la imagen del contenedor

NVIDIA proporciona imágenes de Docker a fin de compilar una imagen de contenedor que ejecuta Triton y se alinea con los requisitos de contenedor personalizados de Vertex AI para la entrega. Puedes extraer la imagen mediante docker y etiquetar la ruta de acceso de Artifact Registry a la que se enviará la imagen.

NGC_TRITON_IMAGE_URI="nvcr.io/nvidia/tritonserver:22.01-py3"
docker pull $NGC_TRITON_IMAGE_URI
docker tag $NGC_TRITON_IMAGE_URI LOCATION-docker.pkg.dev/PROJECT_ID/getting-started-nvidia-triton/vertex-triton-inference

Reemplaza lo siguiente:

  • LOCATION: la región de tu repositorio de Artifact Registry, como se especifica en una sección anterior
  • PROJECT_ID: El ID del proyecto de Google Cloud.

El comando puede ejecutarse durante varios minutos.

Prepara el archivo de carga útil para probar las solicitudes de predicción

Para enviar una solicitud de predicción al servidor del contenedor, prepara la carga útil con un archivo de imagen de muestra que use Python. Ejecuta la siguiente secuencia de comandos Python para generar el archivo de carga útil:

import json
import requests

# install required packages before running
# pip install pillow numpy --upgrade
from PIL import Image
import numpy as np

# method to generate payload from image url
def generate_payload(image_url):
    # download image from url and resize
    image_inputs = Image.open(requests.get(image_url, stream=True).raw)
    image_inputs = image_inputs.resize((200, 200))

    # convert image to numpy array
    image_tensor = np.asarray(image_inputs)
    # derive image shape
    image_shape = [1] + list(image_tensor.shape)

    # create payload request
    payload = {
        "id": "0",
        "inputs": [
            {
                "name": "input_tensor",
                "shape": image_shape,
                "datatype": "UINT8",
                "parameters": {},
                "data": image_tensor.tolist(),
            }
        ],
    }

    # save payload as json file
    payload_file = "instances.json"
    with open(payload_file, "w") as f:
        json.dump(payload, f)
    print(f"Payload generated at {payload_file}")

    return payload_file

if __name__ == '__main__':
  image_url = "https://github.com/tensorflow/models/raw/master/research/object_detection/test_images/image2.jpg"
  payload_file = generate_payload(image_url)

La secuencia de comandos de Python genera una carga útil y, luego, imprime la siguiente respuesta:

Payload generated at instances.json

Ejecuta el contenedor de forma local (opcional)

Antes de enviar tu imagen de contenedor a Artifact Registry para usarla con Vertex AI Prediction, puedes ejecutarla como un contenedor en tu entorno local a fin de verificar que el servidor funcione como se espera:

  1. Para ejecutar la imagen de contenedor de forma local, ejecuta el siguiente comando en la shell:

    docker run -t -d -p 8000:8000 --rm \
  --name=local_object_detector \
  -e AIP_MODE=True \
  LOCATION-docker.pkg.dev/PROJECT_ID/getting-started-nvidia-triton/vertex-triton-inference \
  --model-repository MODEL_ARTIFACTS_REPOSITORY \
  --strict-model-config=false

    Reemplaza lo siguiente, tal como lo hiciste en la sección anterior:

    • LOCATION: la región de tu repositorio de Artifact Registry, como se especifica en una sección anterior
    • PROJECT_ID: el ID del proyecto de Google Cloud
    • MODEL_ARTIFACTS_REPOSITORY: La ruta de acceso de Cloud Storage donde se encuentran los artefactos del modelo

    Este comando ejecuta un contenedor en modo desconectado, asignando el puerto 8000 del contenedor al puerto 8000 del entorno local. La imagen de Triton de NGC configura Triton para usar el puerto 8000.

  2. Para enviar una verificación de estado al servidor del contenedor, ejecuta el siguiente comando en tu shell:

    curl -s -o /dev/null -w "%{http_code}" http://localhost:8000/v2/health/ready

    Si se ejecuta de forma correcta, el servidor muestra el código de estado como 200.

  3. Ejecuta el siguiente comando para enviar una solicitud de predicción al servidor del contenedor mediante la carga útil ya generada y obtén respuestas de predicción:

    curl -X POST \
  -H "Content-Type: application/json" \
  -d @instances.json \
  localhost:8000/v2/models/object_detector/infer |
jq -c '.outputs[] | select(.name == "detection_classes")'

    Esta solicitud usa una de las imágenes de prueba que se incluyen en el ejemplo de detección de objetos de TensorFlow.

    Si se ejecuta de forma correcta, el servidor mostrará la siguiente predicción:

    {"name":"detection_classes","datatype":"FP32","shape":[1,300],"data":[38,1,...,44]}

  4. Para detener el contenedor, ejecuta el siguiente comando en la shell:

    docker stop local_object_detector

Envía la imagen del contenedor a Artifact Registry

Configurar Docker para acceder a Artifact Registry Luego, envía tu imagen de contenedor a tu repositorio de Artifact Registry.

  1. Si deseas permitir que tu instalación local de Docker se envíe a Artifact Registry en la región que seleccionaste, ejecuta el siguiente comando en tu shell:

    gcloud auth configure-docker LOCATION-docker.pkg.dev
    • Reemplaza LOCATION por la región en la que creaste tu repositorio en una sección anterior.

  2. Para enviar la imagen de contenedor que acabas de compilar a Artifact Registry, ejecuta el siguiente comando en tu shell:

    docker push LOCATION-docker.pkg.dev/PROJECT_ID/getting-started-nvidia-triton/vertex-triton-inference

    Reemplaza lo siguiente, tal como lo hiciste en la sección anterior:

    • LOCATION: la región de tu repositorio de Artifact Registry, como se especifica en una sección anterior
    • PROJECT_ID: el ID del proyecto de Google Cloud

Implementa el modelo

Crea un modelo

Para crear un Model recurso que use un contenedor personalizado que ejecute Triton, ejecuta el siguiente gcloud ai models upload comando:

gcloud ai models upload \
  --region=LOCATION \
  --display-name=DEPLOYED_MODEL_NAME \
  --container-image-uri=LOCATION-docker.pkg.dev/PROJECT_ID/getting-started-nvidia-triton/vertex-triton-inference \
  --artifact-uri=MODEL_ARTIFACTS_REPOSITORY \
  --container-args='--strict-model-config=false'
  • LOCATION_ID: la región en la que usas Vertex AI.
  • PROJECT_ID: el ID del proyecto de Google Cloud
  • DEPLOYED_MODEL_NAME: Un nombre para DeployedModel También puedes usar el nombre comercial de Model para DeployedModel.

El argumento --container-args='--strict-model-config=false' permite que Triton genere la configuración del modelo de forma automática.

Cree un extremo

Debes implementar el modelo en un extremo antes de que pueda usarse para entregar predicciones en línea. Si implementas un modelo en un extremo existente, puedes omitir este paso. En el siguiente ejemplo, se usa el comando gcloud ai endpoints create:

gcloud ai endpoints create \
  --region=LOCATION \
  --display-name=ENDPOINT_NAME

Reemplaza lo siguiente:

  • LOCATION_ID: la región en la que usas Vertex AI.
  • ENDPOINT_NAME: el nombre visible para el extremo.

La herramienta de la CLI de Google Cloud puede tardar unos segundos en crear el extremo.

Implementa el modelo en el extremo

Una vez que el extremo esté listo, implementa el modelo en el extremo. Cuando implementas un modelo en un extremo, el servicio asocia los recursos físicos con el modelo que ejecuta Triton para entregar predicciones en línea.

En el siguiente ejemplo, se usa el comando gcloud ai endpoints deploy-model para implementar Model en un endpoint que ejecute Triton en GPU a fin de acelerar la entrega de predicciones y sin dividir el tráfico entre varios recursos de DeployedModel:

ENDPOINT_ID=$(gcloud ai endpoints list \
   --region=LOCATION \
   --filter=display_name=ENDPOINT_NAME \
   --format="value(name)")

MODEL_ID=$(gcloud ai models list \
   --region=LOCATION \
   --filter=display_name=DEPLOYED_MODEL_NAME \
   --format="value(name)")

gcloud ai endpoints deploy-model $ENDPOINT_ID \
  --region=LOCATION \
  --model=$MODEL_ID \
  --display-name=DEPLOYED_MODEL_NAME \
  --machine-type=MACHINE_TYPE \
  --min-replica-count=MIN_REPLICA_COUNT \
  --max-replica-count=MAX_REPLICA_COUNT \
  --accelerator=count=ACCELERATOR_COUNT,type=ACCELERATOR_TYPE \
  --traffic-split=0=100

Reemplaza lo siguiente:

  • LOCATION_ID: la región en la que usas Vertex AI.
  • ENDPOINT_NAME: el nombre visible para el extremo.
  • DEPLOYED_MODEL_NAME: Un nombre para DeployedModel También puedes usar el nombre comercial de Model para DeployedModel.
  • MACHINE_TYPE: Opcional Los recursos de máquina que se usan para cada nodo de esta implementación. Su configuración predeterminada es n1-standard-2. Obtén más información sobre los tipos de máquinas.
  • MIN_REPLICA_COUNT: La cantidad mínima de nodos para esta implementación. El recuento de nodos se puede aumentar o disminuir según lo requiera la carga de predicción, hasta la cantidad máxima de nodos y nunca menos que esta cantidad.
  • MAX_REPLICA_COUNT: La cantidad máxima de nodos para esta implementación. El recuento de nodos se puede aumentar o disminuir según lo requiera la carga de predicción, hasta esta cantidad de nodos y nunca menos que la cantidad mínima de nodos.
  • ACCELERATOR_TYPE: Administra la configuración del acelerador para la entrega de GPU. Cuando se implementa un modelo con tipos de máquina de Compute Engine, también se puede seleccionar un acelerador de GPU y se debe especificar el tipo. Las opciones son 'nvidia-tesla-a100', 'nvidia-tesla-k80', 'nvidia-tesla-p100', 'nvidia-tesla-p4', 'nvidia-tesla-t4' y 'nvidia-tesla-v100'.
  • ACCELERATOR_COUNT: La cantidad de aceleradores que se deben conectar a cada máquina que ejecuta el trabajo. Por lo general, es 1. Si no se especifica, el valor predeterminado es 1.

La herramienta de Google Cloud CLI puede tardar unos segundos en implementar el modelo en el extremo. Cuando el modelo se implementa de forma correcta, este comando imprime el siguiente resultado:

  Deployed a model to the endpoint xxxxx. Id of the deployed model: xxxxx.

Obtén predicciones en línea del modelo implementado

Para invocar el modelo en el extremo de Vertex AI Prediction, formatea la solicitud de predicción mediante un objeto JSON de solicitud de inferencia estándar o un objeto JSON de solicitud de inferencia con una extensión binaria y envía una solicitud al extremo rawPredict de REST de Vertex AI Prediction.

En el siguiente ejemplo, se usa el comando gcloud ai endpoints raw-predict:

ENDPOINT_ID=$(gcloud ai endpoints list \
   --region=LOCATION \
   --filter=display_name=ENDPOINT_NAME \
   --format="value(name)")

gcloud ai endpoints raw-predict $ENDPOINT_ID \
  --region=LOCATION \
  --http-headers=Content-Type=application/json \
  --request @instances.json

Reemplaza lo siguiente:

  • LOCATION_ID: la región en la que usas Vertex AI.
  • ENDPOINT_NAME: el nombre visible para el extremo.

El extremo muestra la siguiente respuesta para una solicitud válida:

{
    "id": "0",
    "model_name": "object_detector",
    "model_version": "1",
    "outputs": [{
        "name": "detection_anchor_indices",
        "datatype": "FP32",
        "shape": [1, 300],
        "data": [2.0, 1.0, 0.0, 3.0, 26.0, 11.0, 6.0, 92.0, 76.0, 17.0, 58.0, ...]
    }]
}

Realice una limpieza

Para evitar incurrir en más cargos de Vertex AI y Artifact Registry, borra los recursos de Google Cloud que creaste durante este instructivo:

  1. Para anular la implementación del modelo en el extremo y borrarlo, ejecuta el siguiente comando en tu shell:

    ENDPOINT_ID=$(gcloud ai endpoints list \
   --region=LOCATION \
   --filter=display_name=ENDPOINT_NAME \
   --format="value(name)")

DEPLOYED_MODEL_ID=$(gcloud ai endpoints describe $ENDPOINT_ID \
   --region=LOCATION \
   --format="value(deployedModels.id)")

gcloud ai endpoints undeploy-model $ENDPOINT_ID \
  --region=LOCATION \
  --deployed-model-id=$DEPLOYED_MODEL_ID

gcloud ai endpoints delete $ENDPOINT_ID \
   --region=LOCATION \
   --quiet

    Reemplaza LOCATION por la región en la que creaste tu modelo en una sección anterior.

  2. Para borrar tu modelo, ejecuta el siguiente comando en tu shell:

    MODEL_ID=$(gcloud ai models list \
   --region=LOCATION \
   --filter=display_name=DEPLOYED_MODEL_NAME \
   --format="value(name)")

gcloud ai models delete $MODEL_ID \
   --region=LOCATION \
   --quiet

    Reemplaza LOCATION por la región en la que creaste tu modelo en una sección anterior.

  3. Para borrar tu repositorio de Artifact Registry y la imagen del contenedor que contiene, ejecuta el siguiente comando en tu shell:

    gcloud artifacts repositories delete getting-started-nvidia-triton \
  --location=LOCATION \
  --quiet

    Reemplaza LOCATION por la región en la que creaste tu repositorio de Artifact Registry en una sección anterior.

Limitaciones

¿Qué sigue?