notebooks/official/prediction/get_started_with_nvidia_triton_serving.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "18ebbd838e32"
      },
      "outputs": [],
      "source": [
        "# Copyright 2022 Google LLC\n",
        "#\n",
        "# Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "# you may not use this file except in compliance with the License.\n",
        "# You may obtain a copy of the License at\n",
        "#\n",
        "#     https://www.apache.org/licenses/LICENSE-2.0\n",
        "#\n",
        "# Unless required by applicable law or agreed to in writing, software\n",
        "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "# See the License for the specific language governing permissions and\n",
        "# limitations under the License."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "06cb539bac9c"
      },
      "source": [
        "# Get started with NVIDIA Triton server\n",
        "\n",
        "<table align=\"left\">\n",
        "\n",
        "  <td style=\"text-align: center\">\n",
        "    <a href=\"https://colab.research.google.com/github/GoogleCloudPlatform/vertex-ai-samples/blob/main/notebooks/official/prediction/get_started_with_nvidia_triton_serving.ipynb\">\n",
        "      <img src=\"https://cloud.google.com/ml-engine/images/colab-logo-32px.png\" alt=\"Google Colaboratory logo\"><br> Open in Colab\n",
        "    </a>\n",
        "  </td>\n",
        "  <td style=\"text-align: center\">\n",
        "    <a href=\"https://console.cloud.google.com/vertex-ai/colab/import/https:%2F%2Fraw.githubusercontent.com%2FGoogleCloudPlatform%2Fvertex-ai-samples%2F%2Fmain%2Fnotebooks%2Fofficial%2Fprediction%2Fget_started_with_nvidia_triton_serving.ipynb\">\n",
        "      <img width=\"32px\" src=\"https://cloud.google.com/ml-engine/images/colab-enterprise-logo-32px.png\" alt=\"Google Cloud Colab Enterprise logo\"><br> Open in Colab Enterprise\n",
        "    </a>\n",
        "  </td> \n",
        "  <td style=\"text-align: center\">\n",
        "    <a href=\"https://console.cloud.google.com/vertex-ai/workbench/deploy-notebook?download_url=https://raw.githubusercontent.com/GoogleCloudPlatform/vertex-ai-samples/main/notebooks/official/prediction/get_started_with_nvidia_triton_serving.ipynb\">\n",
        "      <img src=\"https://lh3.googleusercontent.com/UiNooY4LUgW_oTvpsNhPpQzsstV5W8F7rYgxgGBD85cWJoLmrOzhVs_ksK_vgx40SHs7jCqkTkCk=e14-rj-sc0xffffff-h130-w32\" alt=\"Vertex AI logo\"><br> Open in Workbench\n",
        "    </a>\n",
        "  </td> \n",
        "  <td style=\"text-align: center\">\n",
        "    <a href=\"https://github.com/GoogleCloudPlatform/vertex-ai-samples/blob/main/notebooks/official/prediction/get_started_with_nvidia_triton_serving.ipynb\">\n",
        "      <img src=\"https://cloud.google.com/ml-engine/images/github-logo-32px.png\" alt=\"GitHub logo\"><br> View on GitHub\n",
        "    </a>\n",
        "  </td>                                                                                              \n",
        "</table>\n",
        "<br/><br/><br/><br/>\n",
        "\n",
        "This notebook is a revised version of notebook from [Rajesh Thallam](https://github.com/GoogleCloudPlatform/vertex-ai-samples/blob/main/notebooks/community/vertex_endpoints/nvidia-triton/nvidia-triton-custom-container-prediction.ipynb)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ffbf1d56b5a6"
      },
      "source": [
        "## Overview\n",
        "\n",
        "This tutorial demonstrates how to deploy a Vertex AI model resource to a [NVIDIA Triton Inference Server (Triton)](https://developer.nvidia.com/nvidia-triton-inference-server), and make online predictions using Vertex AI Prediction.\n",
        "\n",
        "\n",
        "Learn more about [Vertex AI Prediction](https://cloud.google.com/vertex-ai/docs/predictions/getting-predictions)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8b10d2fb975d"
      },
      "source": [
        "### Objective\n",
        "\n",
        "In this tutorial, you learn how to deploy a container running Nvidia Triton Server with a Vertex AI model resource to a Vertex AI endpoint for making online predictions.\n",
        "\n",
        "This tutorial uses the following Google Cloud ML services:\n",
        "\n",
        "- Vertex AI model\n",
        "- Vertex AI endpoint\n",
        "- Vertex AI Prediction\n",
        "- Artifact Registry\n",
        "\n",
        "The steps performed in this tutorial include:\n",
        "\n",
        "- Download the model artifacts from TensorFlow Hub.\n",
        "- Create Triton serving configuration file for the model.\n",
        "- Construct a custom container, with Triton serving image, for model deployment.\n",
        "- Upload the model as a Vertex AI model resource.\n",
        "- Deploy the Vertex AI model resource to a Vertex AI endpoint resource.\n",
        "- Make a prediction request.\n",
        "- Undeploy the model resource and delete the endpoint."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "32ed93a8f8c4"
      },
      "source": [
        "### Dataset\n",
        "\n",
        "The tutorial uses Faster R-CNN with ResNet-101 v1 object detection model provided on [TensorFlow Hub](https://tfhub.dev/tensorflow/faster_rcnn/resnet101_v1_640x640/1) that has been trained on the [COCO 2017 dataset](https://cocodataset.org/#download) with training images scaled to 640x640."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "35bee437737d"
      },
      "source": [
        "### Costs\n",
        "\n",
        "This tutorial uses billable components of Google Cloud:\n",
        "\n",
        "* Vertex AI\n",
        "* Cloud Storage\n",
        "\n",
        "Learn about [Vertex AI pricing](https://cloud.google.com/vertex-ai/pricing) and [Cloud Storage pricing](https://cloud.google.com/storage/pricing), and use the [Pricing Calculator](https://cloud.google.com/products/calculator/) to generate a cost estimate based on your projected usage."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f0316df526f8"
      },
      "source": [
        "## Get started"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a2c2cb2109a0"
      },
      "source": [
        "### Install Vertex AI SDK for Python and other required packages\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "install_mlops"
      },
      "outputs": [],
      "source": [
        "! pip3 install --upgrade --quiet google-cloud-aiplatform \\\n",
        "                                 tensorflow \\\n",
        "                                 tensorflow-hub \\\n",
        "                                 numpy \\\n",
        "                                 google-api-python-client"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ff555b32bab8"
      },
      "source": [
        "### Restart runtime (Colab only)\n",
        "\n",
        "To use the newly installed packages, you must restart the runtime on Google Colab."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "f09b4dff629a"
      },
      "outputs": [],
      "source": [
        "import sys\n",
        "\n",
        "if \"google.colab\" in sys.modules:\n",
        "\n",
        "    import IPython\n",
        "\n",
        "    app = IPython.Application.instance()\n",
        "    app.kernel.do_shutdown(True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ee775571c2b5"
      },
      "source": [
        "<div class=\"alert alert-block alert-warning\">\n",
        "<b>⚠️ The kernel is going to restart. Wait until it's finished before continuing to the next step. ⚠️</b>\n",
        "</div>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "92e68cfc3a90"
      },
      "source": [
        "### Authenticate your notebook environment (Colab only)\n",
        "\n",
        "Authenticate your environment on Google Colab.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "46604f70e831"
      },
      "outputs": [],
      "source": [
        "import sys\n",
        "\n",
        "if \"google.colab\" in sys.modules:\n",
        "\n",
        "    from google.colab import auth\n",
        "\n",
        "    auth.authenticate_user()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4f872cd812d0"
      },
      "source": [
        "### Set Google Cloud project information and initialize Vertex AI SDK for Python\n",
        "\n",
        "To get started using Vertex AI, you must have an existing Google Cloud project and [enable the Vertex AI API](https://console.cloud.google.com/flows/enableapi?apiid=aiplatform.googleapis.com). Learn more about [setting up a project and a development environment](https://cloud.google.com/vertex-ai/docs/start/cloud-environment)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oM1iC_MfAts1"
      },
      "outputs": [],
      "source": [
        "PROJECT_ID = \"[your-project-id]\"  # @param {type:\"string\"}\n",
        "\n",
        "# Set the project id\n",
        "! gcloud config set project {PROJECT_ID}\n",
        "\n",
        "LOCATION = \"us-central1\"  # @param {type: \"string\"}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zgPO1eR3CYjk"
      },
      "source": [
        "### Create a Cloud Storage bucket\n",
        "\n",
        "Create a storage bucket to store intermediate artifacts such as datasets.\n",
        "\n",
        "- *{Note to notebook author: For any user-provided strings that need to be unique (like bucket names or model ID's), append \"-unique\" to the end so proper testing can occur}*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MzGDU7TWdts_"
      },
      "outputs": [],
      "source": [
        "BUCKET_URI = f\"gs://your-bucket-name-{PROJECT_ID}-unique\"  # @param {type:\"string\"}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-EcIXiGsCePi"
      },
      "source": [
        "**Only if your bucket doesn't already exist**: Run the following cell to create your Cloud Storage bucket."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NIq7R4HZCfIc"
      },
      "outputs": [],
      "source": [
        "! gsutil mb -l {LOCATION} -p {PROJECT_ID} {BUCKET_URI}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "setup_vars"
      },
      "source": [
        "### Set up variables\n",
        "\n",
        "Next, set up some variables used throughout the tutorial.\n",
        "\n",
        "### Import libraries"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5c51d0f060ba"
      },
      "outputs": [],
      "source": [
        "import json\n",
        "import os\n",
        "from pathlib import Path\n",
        "\n",
        "import numpy as np\n",
        "import requests\n",
        "import tensorflow as tf\n",
        "import tensorflow_hub as hub\n",
        "from google.api import httpbody_pb2\n",
        "from google.cloud import aiplatform as aiplatform\n",
        "from google.cloud import aiplatform_v1 as gapic\n",
        "from PIL import Image"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9e609999d2cd"
      },
      "source": [
        "### Define constants\n",
        "\n",
        "`MODEL_ARTIFACTS_REPOSITORY` is a root Cloud Storage location where the Triton model artifacts are stored."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "771aa5548060"
      },
      "outputs": [],
      "source": [
        "MODEL_ARTIFACTS_REPOSITORY = f\"{BUCKET_URI}/triton-on-vertex/models\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "299e6463253d"
      },
      "source": [
        "The following set of constants are used to create names and display names of Vertex AI Prediction resources like models, endpoints, and model deployments."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "d572aed16497"
      },
      "outputs": [],
      "source": [
        "# set model names and version\n",
        "MODEL_NAME = \"faster-rcnn\"\n",
        "MODEL_VERSION = \"v01\"\n",
        "MODEL_DISPLAY_NAME = f\"triton-{MODEL_NAME}-{MODEL_VERSION}\"\n",
        "ENDPOINT_DISPLAY_NAME = f\"endpoint-{MODEL_NAME}-{MODEL_VERSION}\"\n",
        "\n",
        "# You can get the latest Triton image uri from\n",
        "# https://catalog.ngc.nvidia.com/orgs/nvidia/containers/tritonserver\n",
        "NGC_TRITON_IMAGE_URI = \"nvcr.io/nvidia/tritonserver:22.01-py3\"\n",
        "\n",
        "# prediction container image name\n",
        "IMAGE_NAME = \"vertex-triton-inference:22.01\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6183d4018b5b"
      },
      "source": [
        "### Initialize Vertex AI SDK for Python\n",
        "\n",
        "Initialize the Vertex AI SDK for Python for your project and corresponding bucket."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dcf75deec9a4"
      },
      "outputs": [],
      "source": [
        "aiplatform.init(project=PROJECT_ID, staging_bucket=BUCKET_URI)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "accelerators:training,cpu,prediction,cpu,mbsdk"
      },
      "source": [
        "#### Set hardware accelerators\n",
        "\n",
        "You can set hardware accelerators for training and prediction.\n",
        "\n",
        "Set the variables `TRAIN_GPU/TRAIN_NGPU` to use a container image supporting a GPU and the number of GPUs allocated to the virtual machine (VM) instance. For example, to use a GPU container image with 4 Nvidia Telsa T4 GPUs allocated to each VM, you would specify:\n",
        "\n",
        "    (aip.gapic.AcceleratorType.NVIDIA_TESLA_T4, 4)\n",
        "\n",
        "Otherwise specify `(None, None)` to use a container image to run on a CPU.\n",
        "\n",
        "Learn more about [hardware accelerator support for your location](https://cloud.google.com/vertex-ai/docs/general/locations#accelerators)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "accelerators:training,cpu,prediction,cpu,mbsdk"
      },
      "outputs": [],
      "source": [
        "TRAIN_GPU, TRAIN_NGPU = (gapic.AcceleratorType.NVIDIA_TESLA_T4, 1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "machine:training"
      },
      "source": [
        "#### Set machine type\n",
        "\n",
        "Next, set the machine type to use for training.\n",
        "\n",
        "- Set the variable `TRAIN_COMPUTE` to configure  the compute resources for the VMs you use for for training.\n",
        " - `machine type`\n",
        "     - `n1-standard`: 3.75GB of memory per vCPU.\n",
        "     - `n1-highmem`: 6.5GB of memory per vCPU\n",
        "     - `n1-highcpu`: 0.9 GB of memory per vCPU\n",
        " - `vCPUs`: number of \\[2, 4, 8, 16, 32, 64, 96 \\]\n",
        "\n",
        "*Note: The following isn't supported for training:*\n",
        "\n",
        " - `standard`: 2 vCPUs\n",
        " - `highcpu`: 2, 4 and 8 vCPUs\n",
        "\n",
        "*Note: You may also use n2 and e2 machine types for training and deployment, but they do not support GPUs*."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "machine:training"
      },
      "outputs": [],
      "source": [
        "MACHINE_TYPE = \"n1-standard\"\n",
        "\n",
        "VCPU = \"4\"\n",
        "TRAIN_COMPUTE = MACHINE_TYPE + \"-\" + VCPU\n",
        "print(\"Train machine type\", TRAIN_COMPUTE)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5468fdaf15ba"
      },
      "source": [
        "## NVIDIA Triton Inference Server (Triton) Overview\n",
        "\n",
        "[NVIDIA Triton Inference Server (Triton)](https://github.com/triton-inference-server/server) provides an inference solution optimized for both CPUs and GPUs. Triton can run multiple models from the same or different frameworks concurrently on a single GPU or CPU. In a multi-GPU server, it automatically creates an instance of each model on each GPU to increase utilization without extra coding. It supports real-time inferencing, batch inferencing to maximize GPU/CPU utilization, and streaming inference with built-in support for audio streaming input. It also supports model ensembles for use cases that require multiple models to perform end-to-end inference.\n",
        "\n",
        "The following figure shows the Triton's high-level architecture.\n",
        "\n",
        "![Triton high level architecture](https://github.com/triton-inference-server/server/raw/190a59184ea82a18b6c790bfacc8933fe04f01fa/docs/user_guide/images/arch.jpg)\n",
        "\n",
        "- The model repository is a file-system based repository of the models that Triton makes available for inference.\n",
        "- Inference requests arrive at the server via either HTTP/REST or gRPC and are then routed to the appropriate per-model scheduler.\n",
        "- Triton implements multiple scheduling and batching algorithms that can be configured on a model-by-model basis.\n",
        "- The backend performs inference using the inputs provided in the batched requests to produce the requested outputs.\n",
        "\n",
        "Triton provides readiness and liveness health endpoints, as well as utilization, throughput, and latency metrics, which enable the integration of Triton into deployment environments, such as Vertex AI Prediction.\n",
        "\n",
        "Refer to [Triton architecture](https://github.com/triton-inference-server/server/blob/190a59184ea82a18b6c790bfacc8933fe04f01fa/docs/user_guide/architecture.md#L4) for more detailed information.\n",
        "\n",
        "## Triton on Vertex AI Prediction\n",
        "\n",
        "Triton inference server runs inside a container published by NVIDIA GPU Cloud (NGC) - [NVIDIA Triton Inference Server Image](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/tritonserver). NVIDIA and GCP Vertex AI team collaborated and added packages and configurations to align Triton with Vertex AI [requirements for custom serving container images](https://cloud.google.com/vertex-ai/docs/predictions/custom-container-requirements).\n",
        "\n",
        "The model to be served by Triton should be registered with Vertex AI as a model resource. The model's metadata refer to a location of the ensemble artifacts in Google Cloud Storage (GCS) and the custom serving container including configuration.\n",
        "\n",
        "Triton loads the models and exposes inference, health, and model management REST endpoints using [standard inference protocols](https://github.com/kserve/kserve/tree/master/docs/predict-api/v2). While deploying to Vertex AI, Triton recognizes Vertex AI environment and adopts Vertex AI Prediction protocol for [health checks](https://cloud.google.com/vertex-ai/docs/predictions/custom-container-requirements#health) and predictions.\n",
        "\n",
        "To invoke the model through the Vertex AI Prediction endpoint, format prediction request using a [standard Inference Request JSON Object](https://github.com/kserve/kserve/blob/master/docs/predict-api/v2/required_api.md#inference) or a [Inference Request JSON Object with a binary extension](https://github.com/triton-inference-server/server/blob/main/docs/protocol/extension_binary_data.md) and submit a request to Vertex AI Prediction [REST rawPredict endpoint](https://cloud.google.com/vertex-ai/docs/reference/rest/v1beta1/projects.locations.endpoints/rawPredict). You need to use the `rawPredict` rather than `predict` endpoint because inference request formats used by Triton are not compatible with the Vertex AI Prediction [standard input format](https://cloud.google.com/vertex-ai/docs/predictions/online-predictions-custom-models#formatting-prediction-input).\n",
        "\n",
        "![triton-on-vertex-ai-predictions](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0192665cc7af"
      },
      "source": [
        "## Download model artifacts\n",
        "\n",
        "For this tutorial, download the object detection model provided on [TensorFlow Hub](https://tfhub.dev/tensorflow/faster_rcnn/resnet101_v1_640x640/1) that has been trained on the [COCO 2017 dataset](https://cocodataset.org/#download). Triton expects [model repository]() to be organized in the following structure for serving [TensorFlow `SavedModel`](https://www.tensorflow.org/guide/saved_model) formats:\n",
        "\n",
        "> ```\n",
        "> └── model-repository-path\n",
        ">        └── model_name\n",
        ">               ├── config.pbtxt\n",
        ">               └── 1\n",
        ">                   └── model.savedmodel\n",
        ">                         └── <saved-model-files>\n",
        "> ```\n",
        "\n",
        "\n",
        "The `config.pbtxt` file describes the [model configuration](https://github.com/triton-inference-server/server/blob/main/docs/model_configuration.md) for the model."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "39c4ae2da5ec"
      },
      "outputs": [],
      "source": [
        "# download and organize model artifacts as per Triton model repository spec\n",
        "! mkdir -p models/object_detector/1/model.savedmodel/\n",
        "! curl -L \"https://tfhub.dev/tensorflow/faster_rcnn/resnet101_v1_640x640/1?tf-hub-format=compressed\" | \\\n",
        "    tar -zxvC ./models/object_detector/1/model.savedmodel/\n",
        "! ls -ltr ./models/object_detector/1/model.savedmodel/"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "68b5d96bd29b"
      },
      "source": [
        "After downloading the model locally, the model repository is organized as follows:\n",
        "\n",
        "> ```\n",
        "> ./models\n",
        "> └── object_detector\n",
        ">     └── 1\n",
        ">         └── model.savedmodel\n",
        ">             ├── saved_model.pb\n",
        ">             └── variables\n",
        ">                 ├── variables.data-00000-of-00001\n",
        ">                 └── variables.index\n",
        "> ```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "d966364e6d59"
      },
      "outputs": [],
      "source": [
        "!tree ./models"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "da18b2ab4350"
      },
      "source": [
        "### Create model configuration file\n",
        "\n",
        "The [model configuration](https://github.com/triton-inference-server/server/blob/190a59184ea82a18b6c790bfacc8933fe04f01fa/docs/user_guide/model_configuration.md#L4) file `config.pbtxt` provides information about the model such as inputs and outputs. Refer to the [Triton docs](https://github.com/triton-inference-server/common/blob/main/protobuf/model_config.proto) for the configuration format. For TensorFlow models, you can use the [`saved_model_cli` command](https://www.tensorflow.org/guide/saved_model#details_of_the_savedmodel_command_line_interface) and map to the Triton's configuration format. \n",
        "\n",
        "*Note:* Triton datatypes are different from the frameworks and should be mapped accordingly based on this [data table](https://github.com/triton-inference-server/server/blob/190a59184ea82a18b6c790bfacc8933fe04f01fa/docs/user_guide/model_configuration.md#datatypes).\n",
        "\n",
        "For example: DT_UINT8 -> TYPE_UINT8"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6803867b6382"
      },
      "outputs": [],
      "source": [
        "!saved_model_cli show --dir ./models/object_detector/1/model.savedmodel/ --all"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "af290dc29cc9"
      },
      "outputs": [],
      "source": [
        "%%writefile ./models/object_detector/config.pbtxt\n",
        "\n",
        "name: \"object_detector\"\n",
        "platform: \"tensorflow_savedmodel\"\n",
        "backend: \"tensorflow\"\n",
        "max_batch_size: 0\n",
        "input [\n",
        "  {\n",
        "    name: \"input_tensor\"\n",
        "    data_type: TYPE_UINT8\n",
        "    dims: [ 1, -1, -1, 3 ]\n",
        "  }\n",
        "]\n",
        "output [\n",
        "  {\n",
        "    name: \"detection_anchor_indices\"\n",
        "    data_type: TYPE_FP32\n",
        "    dims: [ 1, 300 ]\n",
        "  },\n",
        "  {\n",
        "    name: \"detection_boxes\"\n",
        "    data_type: TYPE_FP32\n",
        "    dims: [ 1, 300, 4 ]\n",
        "  },\n",
        "  {\n",
        "    name: \"detection_classes\"\n",
        "    data_type: TYPE_FP32\n",
        "    dims: [ 1, 300 ]\n",
        "  },\n",
        "  {\n",
        "    name: \"detection_multiclass_scores\"\n",
        "    data_type: TYPE_FP32,\n",
        "    dims: [ 1, 300, 91]\n",
        "  },\n",
        "  {\n",
        "    name: \"detection_scores\"\n",
        "    data_type: TYPE_FP32\n",
        "    dims: [ 1, 300 ]\n",
        "  },\n",
        "  {\n",
        "    name: \"num_detections\"\n",
        "    data_type: TYPE_FP32\n",
        "    dims: [ 1 ]\n",
        "  },\n",
        "  {\n",
        "    name: \"raw_detection_boxes\"\n",
        "    data_type: TYPE_FP32\n",
        "    dims: [ 1, 300, 4 ]\n",
        "  },\n",
        "  {\n",
        "    name: \"raw_detection_scores\"\n",
        "    data_type: TYPE_FP32\n",
        "    dims: [ 1, 300, 91 ]\n",
        "  }\n",
        "]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1368d9e763e2"
      },
      "source": [
        "### Push model artifacts to a Cloud Storage bucket\n",
        "\n",
        "The downloaded model artifacts, including the model configuration file, are pushed to a Cloud Storage bucket defined by `MODEL_ARTIFACTS_REPOSITORY`. This bucket is then used for uploading the model artifacts to a Vertex AI model resource."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8a95a31d2732"
      },
      "outputs": [],
      "source": [
        "! gsutil cp -r ./models/object_detector $MODEL_ARTIFACTS_REPOSITORY/\n",
        "\n",
        "! gsutil ls -r $MODEL_ARTIFACTS_REPOSITORY/object_detector/"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ad1f9883b7b9"
      },
      "source": [
        "### Download test image file and generate payload to make prediction requests\n",
        "\n",
        "The following function downloads a test image file and formats the request payload as a JSON file to be passed to prediction requests."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "51972519f03a"
      },
      "outputs": [],
      "source": [
        "def generate_payload(image_url):\n",
        "    # download image to memory and resize\n",
        "    image_inputs = Image.open(requests.get(image_url, stream=True).raw).resize(\n",
        "        (200, 200)\n",
        "    )\n",
        "    # convert image to numpy array\n",
        "    image_tensor = np.asarray(image_inputs)\n",
        "    # derive image shape\n",
        "    image_shape = [1] + list(image_tensor.shape)\n",
        "\n",
        "    # create/set directory to save payload\n",
        "    base = Path(\"./test\")\n",
        "    base.mkdir(exist_ok=True)\n",
        "\n",
        "    # create payload request for Nvidia Triton server\n",
        "    payload = {\n",
        "        \"id\": \"0\",\n",
        "        \"inputs\": [\n",
        "            {\n",
        "                \"name\": \"input_tensor\",\n",
        "                \"shape\": image_shape,\n",
        "                \"datatype\": \"UINT8\",\n",
        "                \"parameters\": {},\n",
        "                \"data\": image_tensor.tolist(),\n",
        "            }\n",
        "        ],\n",
        "    }\n",
        "\n",
        "    # save payload as json file\n",
        "    payload_file = os.path.join(base, \"payload.json\")\n",
        "    with open(payload_file, \"w\") as f:\n",
        "        json.dump(payload, f)\n",
        "    print(f\"Payload generated at {payload_file}\")\n",
        "\n",
        "    return payload_file"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "80755f77145a"
      },
      "source": [
        "### Download and view the sample image"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3d6e3e9a45a7"
      },
      "outputs": [],
      "source": [
        "# set image url\n",
        "image_url = \"https://github.com/tensorflow/models/raw/master/research/object_detection/test_images/image2.jpg\"\n",
        "\n",
        "# show image\n",
        "image = Image.open(requests.get(image_url, stream=True).raw).resize((200, 200))\n",
        "image"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5a3692e6482d"
      },
      "source": [
        "### Format the request payload as JSON"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "95a0dbcb902b"
      },
      "outputs": [],
      "source": [
        "# format payload as JSON\n",
        "payload_file = generate_payload(image_url)\n",
        "\n",
        "print(payload_file)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ef3cd48e5ed9"
      },
      "source": [
        "### Make a prediction locally\n",
        "\n",
        "Next, make a prediction with a local instance of the object detection model downloaded from TensorFlow Hub on the test image"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7326e903d212"
      },
      "outputs": [],
      "source": [
        "# download the model\n",
        "detector = hub.load(\"https://tfhub.dev/tensorflow/faster_rcnn/resnet101_v1_640x640/1\")\n",
        "\n",
        "# download the image\n",
        "image = Image.open(requests.get(image_url, stream=True).raw).resize((200, 200))\n",
        "\n",
        "# convert image to a tensor using `tf.convert_to_tensor`\n",
        "image_tensor = tf.convert_to_tensor(np.asarray(image))\n",
        "\n",
        "# model expects an image batch, for single image add an axis with `tf.newaxis`\n",
        "image_tensor = image_tensor[tf.newaxis, ...]\n",
        "\n",
        "# run inference\n",
        "detector_output = detector(image_tensor)\n",
        "\n",
        "# return class_ids\n",
        "class_ids = detector_output[\"detection_classes\"]\n",
        "print(class_ids)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4088a566fbcb"
      },
      "source": [
        "## Building and pushing the container image\n",
        "\n",
        "To use a custom container for serving predictions, you must specify a Docker container image that meets the [custom container requirements](https://cloud.google.com/vertex-ai/docs/predictions/custom-container-requirements). This section describes how to create the container image running Nvidia Triton Server and push it to Artifact Registry. \n",
        "\n",
        "The Artifact Registry is a service for storing and managing artifacts in private repositories, including container images, Helm charts, and language packages. It's the recommended container image registry for Google Cloud.\n",
        "\n",
        "Learn more about [Quick start for Docker](https://cloud.google.com/artifact-registry/docs/docker/quickstart)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gar_enable_api"
      },
      "source": [
        "### Enable Artifact Registry API\n",
        "\n",
        "First, you must enable the Artifact Registry API service for your project.\n",
        "\n",
        "Learn more about [Enabling service](https://cloud.google.com/artifact-registry/docs/enable-service)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "df3616824fb0"
      },
      "outputs": [],
      "source": [
        "! gcloud services enable artifactregistry.googleapis.com"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f7e0403eef20"
      },
      "source": [
        "### Create a private Docker repository to push the container images\n",
        "\n",
        "Next, create your own private repository in Artifact Registry for your container image."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4643ca50f603"
      },
      "outputs": [],
      "source": [
        "DOCKER_ARTIFACT_REPO = \"triton-prediction-container\"\n",
        "\n",
        "# create a new Docker repository with your location with the description\n",
        "! gcloud artifacts repositories create {DOCKER_ARTIFACT_REPO} \\\n",
        "    --repository-format=docker \\\n",
        "    --location={LOCATION} \\\n",
        "    --description=\"Triton Docker repository\"\n",
        "\n",
        "# verify that your repository was created.\n",
        "! gcloud artifacts repositories list \\\n",
        "    --location={LOCATION} \\\n",
        "    --filter=\"name~\"{DOCKER_ARTIFACT_REPO}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gar_auth"
      },
      "source": [
        "### Configure authentication to your private repo\n",
        "\n",
        "Before you push or pull container images, configure Docker to use the `gcloud` command-line tool to authenticate requests to Artifact Registry for your location."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ef441e0d3f2a"
      },
      "outputs": [],
      "source": [
        "! gcloud auth configure-docker {LOCATION}-docker.pkg.dev --quiet"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "name_container:training"
      },
      "source": [
        "### Registering the Nvidia Triton Server container\n",
        "\n",
        "#### Name the container to register\n",
        "\n",
        "Next, you provide a name for your custom container to use when submitting it to the Artifact Registry."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4a7cf7c1789d"
      },
      "outputs": [],
      "source": [
        "DEPLOY_IMAGE = (\n",
        "    f\"{LOCATION}-docker.pkg.dev/{PROJECT_ID}/{DOCKER_ARTIFACT_REPO}/{IMAGE_NAME}\"\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b0302d85b20d"
      },
      "source": [
        "#### Fetch and tag the Nvidia Triton Server container\n",
        "\n",
        "Next, fetch (pull) a copy of the Nvidia Triton Server container and tag the copy for registering in Artifact Registry."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cd99f7d6b799"
      },
      "outputs": [],
      "source": [
        "import sys\n",
        "\n",
        "IS_COLAB = \"google.colab\" in sys.modules\n",
        "\n",
        "if not IS_COLAB:\n",
        "    ! docker pull $NGC_TRITON_IMAGE_URI\n",
        "    ! docker tag $NGC_TRITON_IMAGE_URI $DEPLOY_IMAGE\n",
        "else:\n",
        "    # install docker daemon\n",
        "    ! apt-get -qq install docker.io"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2d3029333e92"
      },
      "source": [
        "### Run the container locally *[optional]*\n",
        "\n",
        "Before pushing the custom container image to Artifact Registry to use it with Vertex AI Predictions, run the container in local environment to verify that the server responds to prediction instances."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "002ca85547fe"
      },
      "source": [
        "1. To run the container image as a container locally, run the following command:\n",
        "\n",
        "**NOTE:** You can ignore error `No such container` which is thrown when the container isn't running."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "c4438609304a"
      },
      "outputs": [],
      "source": [
        "if not IS_COLAB:\n",
        "    ! docker stop local_object_detector\n",
        "    ! docker run -t -d -p 8000:8000 --rm \\\n",
        "        --name=local_object_detector \\\n",
        "        -e AIP_MODE=True \\\n",
        "        $DEPLOY_IMAGE \\\n",
        "        --model-repository $MODEL_ARTIFACTS_REPOSITORY\n",
        "    ! sleep 20"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "b4f323bfacf1"
      },
      "outputs": [],
      "source": [
        "if not IS_COLAB:\n",
        "    # check if the triton container is running locally\n",
        "    ! docker container ls -f\"name=local_object_detector\" --no-trunc"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6e13b94db665"
      },
      "source": [
        "2. To send the container's server a health check, run the following command. It should return the status code as `200`.\n",
        "\n",
        "*Note:* You're using the v2 API for Nvidia Triton Server -- which is the latest version."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "75ded496a095"
      },
      "outputs": [],
      "source": [
        "if not IS_COLAB:\n",
        "    ! curl -s -o /dev/null -w \"%{http_code}\" http://localhost:8000/v2/health/ready"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4f325a2b6a2f"
      },
      "source": [
        "3. To send the container's server a prediction request, run the following command with sample image file as the payload and get prediction responses"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "d9568eb6304e"
      },
      "outputs": [],
      "source": [
        "if not IS_COLAB:\n",
        "    # request prediction response\n",
        "    ! curl -X POST -H \"Content-Type: application/octet-stream\" \\\n",
        "        -H \"Accept: */*\" \\\n",
        "        --data-binary @$payload_file \\\n",
        "        localhost:8000/v2/models/object_detector/infer | \\\n",
        "      jq -c '.outputs[] | select(.name == \"detection_classes\")'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a7d76c05d109"
      },
      "source": [
        "4. To stop the container, run the following command:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1ee8310e38dc"
      },
      "outputs": [],
      "source": [
        "if not IS_COLAB:\n",
        "    ! docker stop local_object_detector"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6e51ebd6dcaa"
      },
      "source": [
        "### Push the container image to Artifact Registry\n",
        "\n",
        "After testing the container image locally, push the image to Artifact Registry. The Artifact Registry image URI is then used when creating the Vertex AI model resource."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "58f094be7ec1"
      },
      "outputs": [],
      "source": [
        "if not IS_COLAB:\n",
        "    ! docker push $DEPLOY_IMAGE"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f50e9c553fb7"
      },
      "source": [
        "*Executes in Colab*\n",
        "\n",
        "**Note**: This cell may exceed the space limitations of the Google Colab free tier. To ensure successful execution, please consider using a Google Colab Pro or Pro+ account."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "a7e8c98f1e56"
      },
      "outputs": [],
      "source": [
        "%%bash -s $IS_COLAB $DEPLOY_IMAGE $NGC_TRITON_IMAGE_URI\n",
        "if [ $1 == \"False\" ]; then\n",
        "  exit 0\n",
        "fi\n",
        "set -x\n",
        "dockerd -b none --iptables=0 -l warn &\n",
        "for i in $(seq 5); do [ ! -S \"/var/run/docker.sock\" ] && sleep 2 || break; done\n",
        "docker pull $3\n",
        "docker tag $3 $2\n",
        "docker push $2\n",
        "kill $(jobs -p)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4d2bb68b8f9b"
      },
      "source": [
        "## Create Vertex AI model resource\n",
        "\n",
        "A Vertex AI model resource must be created to deploy the model to a Vertex AI endpoint. Create a Vertex AI model resource with the deployment image pointing to the model artifacts. Refer to [Vertex AI Prediction guide](https://cloud.google.com/vertex-ai/docs/predictions/use-custom-container) for creating Vertex AI model resource with custom container."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8d86c4d8f0c7"
      },
      "outputs": [],
      "source": [
        "model = aiplatform.Model.upload(\n",
        "    display_name=MODEL_DISPLAY_NAME,\n",
        "    serving_container_image_uri=DEPLOY_IMAGE,\n",
        "    artifact_uri=MODEL_ARTIFACTS_REPOSITORY,\n",
        "    sync=True,\n",
        ")\n",
        "\n",
        "model.resource_name"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f3c8c48ee2fb"
      },
      "source": [
        "### Deploy the model to Vertex AI endpoint\n",
        "\n",
        "Deploying the Vertex AI model resoure to a Vertex AI endpoint for online predictions:\n",
        "\n",
        "1. Create an endpoint resource exposing an external interface to users consuming the model. \n",
        "2. After the endpoint is ready, deploy one or more instances of a model to the endpoint. The deployed model runs the custom container image running Nvidia Triton Server to serve predictions.\n",
        "\n",
        "Refer to Vertex AI Predictions guide to [Deploy a model using the Vertex AI API](https://cloud.google.com/vertex-ai/docs/predictions/deploy-model-api) for more information about the APIs used in the following cells."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b1488b536cf8"
      },
      "source": [
        "### Create a Vertex AI endpoint\n",
        "\n",
        "Next, you create the Vertex AI endpoint, from which you subsequently deploy your Vertex AI model resource to."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "38fbd01376fa"
      },
      "outputs": [],
      "source": [
        "endpoint = aiplatform.Endpoint.create(display_name=ENDPOINT_DISPLAY_NAME)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d04a1e77ebda"
      },
      "source": [
        "### Deploy Vertex AI model resource to the endpoint resource\n",
        "\n",
        "After the endpoint is ready, deploy the model resource to the endpoint resource. The deployed model runs theNvidia Triton Server on a GPU node equipped with the NVIDIA Tesla T4 GPUs. Refer to [Deploy a model using the Vertex AI API](https://cloud.google.com/vertex-ai/docs/predictions/deploy-model-api) guide for more information.\n",
        "\n",
        "**NOTE:** This step can take up to 20 min."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "567c1f644e3f"
      },
      "outputs": [],
      "source": [
        "MIN_NODES = 1\n",
        "MAX_NODES = 2\n",
        "\n",
        "traffic_percentage = 100\n",
        "machine_type = TRAIN_COMPUTE\n",
        "accelerator_type = TRAIN_GPU.name\n",
        "accelerator_count = TRAIN_NGPU\n",
        "min_replica_count = MIN_NODES\n",
        "max_replica_count = MAX_NODES\n",
        "\n",
        "model.deploy(\n",
        "    endpoint=endpoint,\n",
        "    deployed_model_display_name=MODEL_DISPLAY_NAME,\n",
        "    machine_type=machine_type,\n",
        "    min_replica_count=min_replica_count,\n",
        "    max_replica_count=max_replica_count,\n",
        "    traffic_percentage=traffic_percentage,\n",
        "    accelerator_type=accelerator_type,\n",
        "    accelerator_count=accelerator_count,\n",
        "    sync=True,\n",
        ")\n",
        "\n",
        "print(endpoint.gca_resource)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "be665a6d09db"
      },
      "source": [
        "## Making predictions\n",
        "\n",
        "To make prediction requests to the Vertex AI endpoint, you format the prediction request using a [standard Inference Request JSON Object](https://github.com/kserve/kserve/blob/master/docs/predict-api/v2/required_api.md#inference) or a [Inference Request JSON Object with a binary extension](https://github.com/triton-inference-server/server/blob/main/docs/protocol/extension_binary_data.md) and submit the request to Vertex AI Prediction [REST rawPredict endpoint](https://cloud.google.com/vertex-ai/docs/reference/rest/v1beta1/projects.locations.endpoints/rawPredict). \n",
        "\n",
        "---\n",
        "\n",
        "Instead of `predict` API, you must use the `rawPredict` API  because prediction request formats used by Triton are not compatible with the Vertex AI Prediction [standard input format](https://cloud.google.com/vertex-ai/docs/predictions/online-predictions-custom-models#formatting-prediction-input).\n",
        "\n",
        "---\n",
        "\n",
        "In the [previous section](#Download-test-image-file-and-generate-payload-to-make-prediction-requests) the request body was formatted as a [standard Inference Request JSON Object](https://github.com/kserve/kserve/blob/master/docs/predict-api/v2/required_api.md#inference)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "539bd89689e0"
      },
      "source": [
        "**You can invoke the Vertex AI Prediction `rawPredict` endpoint using [Vertex AI SDK for Python](https://googleapis.dev/python/aiplatform/latest/aiplatform_v1/prediction_service.html#:~:text=async-,raw_predict,-(request%3A%20Optional%5BUnion), any HTTP tool or library, including `curl`.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8715490de7ba"
      },
      "outputs": [],
      "source": [
        "endpoint_name = endpoint.resource_name\n",
        "print(endpoint_name)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ef14f78a6e8f"
      },
      "source": [
        "### Make a prediction request using `rawPredict`\n",
        "\n",
        "The method `rawPredict()` is currently only available at the GAPIC API or REST interface. In this tutorial, you use the GAPIC interface.\n",
        "\n",
        "#### Create the client API interface\n",
        "\n",
        "Next, you create the client interface to the Vertex AI Prediction service."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0fc2e930ecdb"
      },
      "outputs": [],
      "source": [
        "API_ENDPOINT = \"{}-aiplatform.googleapis.com\".format(LOCATION)\n",
        "client_options = {\"api_endpoint\": API_ENDPOINT}\n",
        "\n",
        "pred_client = gapic.PredictionServiceClient(client_options=client_options)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "77966cc1685f"
      },
      "source": [
        "#### Format the HTTP request\n",
        "\n",
        "Next, you prepare a prediction request. In this example, the model format is for the Nvidia Triton Server. This model format takes a request signature not supported by the HTTP server in the Vertex AI prebuilt TensorFlow serving containers.\n",
        "\n",
        "For this model format, you use the `raw_predict()` to pass as-is a request that matches directly the serving interfac of the model, with the following request format:\n",
        "\n",
        "    http_body -> {\n",
        "        'id': an identifier for the request\n",
        "       'inputs': [ instance_1, instance_2, ... instance_n\n",
        "       ]\n",
        "    }\n",
        "    \n",
        "where:\n",
        "\n",
        "    instance -> { 'name': the name of the input tensor\n",
        "                  'shape': the input shape of the example\n",
        "                  'datatype': the data type of the input\n",
        "                  'parameters': server specific parameters\n",
        "                  'data': the input data\n",
        "                }"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "c97b1200e22f"
      },
      "outputs": [],
      "source": [
        "# format payload\n",
        "http_body = httpbody_pb2.HttpBody(\n",
        "    data=open(payload_file).read().encode(\"utf-8\"),\n",
        "    content_type=\"application/json\",\n",
        ")\n",
        "\n",
        "# Initialize request argument(s)\n",
        "request = gapic.RawPredictRequest(endpoint=endpoint_name, http_body=http_body)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "395a2836a569"
      },
      "source": [
        "### Make the prediction request\n",
        "\n",
        "Next, make the prediction request using the `raw_predict()` method."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7fc337a9f7be"
      },
      "outputs": [],
      "source": [
        "# Make initial warmup request\n",
        "try:\n",
        "    response = pred_client.raw_predict(request=request)\n",
        "except Exception as e:\n",
        "    print(e)\n",
        "\n",
        "# Make the prediction request\n",
        "response = pred_client.raw_predict(request=request)\n",
        "result = json.loads(response.data)\n",
        "print(result)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c978717949bd"
      },
      "source": [
        "#### Get detection classes from the output"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "94f601d640dc"
      },
      "outputs": [],
      "source": [
        "detection_classes = [\n",
        "    item for item in result[\"outputs\"] if item[\"name\"] == \"detection_classes\"\n",
        "][0]\n",
        "json.dumps(detection_classes)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6cf44dd9e744"
      },
      "source": [
        "### Making `curl` request to get prediction response\n",
        "\n",
        "Alternatively, you can make prediction requests using the REST interface.\n",
        "\n",
        "*Note:* Notice the use of `rawPredict` API endpoint in the URI below."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "31f15c9b6fe5"
      },
      "outputs": [],
      "source": [
        "endpoint_uri = (\n",
        "    f\"https://{LOCATION}-aiplatform.googleapis.com/v1/{endpoint_name}:rawPredict\"\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dbfbee893d35"
      },
      "outputs": [],
      "source": [
        "! curl -X POST \\\n",
        "   -H \"Authorization: Bearer $(gcloud auth print-access-token)\" \\\n",
        "   -H \"Content-Type: application/json\"  \\\n",
        "   -H \"Accept: */*\" \\\n",
        "   $endpoint_uri \\\n",
        "   -d @$payload_file | \\\n",
        "  jq -c '.outputs[] | select(.name == \"detection_classes\")'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f898a2c7a826"
      },
      "source": [
        "## Cleaning up \n",
        "\n",
        "### Cleaning up training and deployment resources\n",
        "\n",
        "To clean up all Google Cloud resources used in this notebook, you can [delete the Google Cloud project](https://cloud.google.com/resource-manager/docs/creating-managing-projects#shutting_down_projects) you used for the tutorial.\n",
        "\n",
        "Otherwise, you can delete the individual resources you created in this tutorial:\n",
        "\n",
        "- model\n",
        "- endpoint\n",
        "- Cloud Storage Bucket\n",
        "- Container Images"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "e8783cb39cd5"
      },
      "outputs": [],
      "source": [
        "delete_endpoint = True\n",
        "delete_model = True\n",
        "delete_image = True\n",
        "delete_bucket = False\n",
        "\n",
        "# Delete the endpoint using the Vertex AI fully qualified identifier for the endpoint\n",
        "try:\n",
        "    if delete_endpoint:\n",
        "        endpoint.undeploy_all(sync=True)\n",
        "        endpoint.delete()\n",
        "        print(f\"Deleted endpoint {endpoint.display_name}\")\n",
        "except Exception as e:\n",
        "    print(e)\n",
        "\n",
        "# Delete the model using the Vertex AI fully qualified identifier for the model\n",
        "try:\n",
        "    if delete_model:\n",
        "        model.delete()\n",
        "        print(f\"Deleted model {model.display_name}\")\n",
        "except Exception as e:\n",
        "    print(e)\n",
        "\n",
        "if delete_bucket:\n",
        "    ! gsutil rm -rf $BUCKET_URI"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c1685fb4374b"
      },
      "source": [
        "#### **Delete images from Artifact Registry**\n",
        "\n",
        "Deletes all the container images created in this tutorial with name defined by variable `IMAGE_NAME` from the registry. All associated tags are also deleted."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "17eea976bc97"
      },
      "outputs": [],
      "source": [
        "gar_images = ! gcloud artifacts docker images list $LOCATION-docker.pkg.dev/$PROJECT_ID/$DOCKER_ARTIFACT_REPO \\\n",
        "      --filter=\"package~\"$(echo $IMAGE_NAME | sed 's/:.*//') \\\n",
        "      --format=\"get(package)\"\n",
        "\n",
        "try:\n",
        "    if delete_image:\n",
        "        for image in gar_images:\n",
        "            # delete only if image name starts with valid location\n",
        "            if image.startswith(f'{LOCATION}-docker.pkg.dev'):\n",
        "                print(f\"Deleting image {image} including all tags\")\n",
        "                ! gcloud artifacts docker images delete $image --delete-tags --quiet\n",
        "except Exception as e:\n",
        "    print(e)"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "name": "get_started_with_nvidia_triton_serving.ipynb",
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}