Tutorial sui container Edge

Dopo aver creato un modello AutoML Vision Edge e averlo esportato in un bucket Google Cloud Storage, puoi utilizzare i servizi RESTful con i tuoi modelli AutoML Vision Edge e TF Serving Image Docker.

Cosa creerai

I container Docker possono aiutarti a eseguire facilmente il deployment di modelli perimetrali su dispositivi diversi. Puoi eseguire modelli perimetrali chiamando le API REST dai container con il linguaggio che preferisci, con l'ulteriore vantaggio di non dover installare dipendenze o trovare le versioni di TensorFlow appropriate.

In questo tutorial imparerai a conoscere l'esecuzione di modelli perimetrali sui dispositivi utilizzando i container Docker.

Nello specifico, questo tutorial illustra tre passaggi:

  1. Recupero di container predefiniti.
  2. Esecuzione di container con modelli Edge per avviare le API REST.
  3. Fare previsioni.

Molti dispositivi dispongono solo di CPU, mentre alcuni potrebbero avere GPU per ottenere previsioni più rapide. Forniamo tutorial con container predefiniti di CPU e GPU.

Obiettivi

In questa procedura dettagliata introduttiva end-to-end, utilizzerai esempi di codice per:

  1. Ottieni il container Docker.
  2. Avvia le API REST utilizzando container Docker con modelli perimetrali.
  3. Fai previsioni per ottenere risultati analizzati.

Prima di iniziare

Per completare questo tutorial, devi:

  1. Addestra un modello Edge esportabile. Segui la guida rapida ai modelli di dispositivi Edge per addestrare un modello Edge.
  2. Esporta un modello AutoML Vision Edge. Questo modello verrà gestito con container come API REST.
  3. Installa Docker. Questo è il software necessario per eseguire i container Docker.
  4. (Facoltativo) Installa il docker e il driver NVIDIA. Questo passaggio è facoltativo se hai dispositivi con GPU e vuoi ottenere previsioni più rapide.
  5. Prepara le immagini di test. Queste immagini verranno inviate nelle richieste per ottenere i risultati dell'analisi.

I dettagli per l'esportazione dei modelli e l'installazione del software necessario sono disponibili nella sezione seguente.

Esporta modello AutoML Vision Edge

Dopo aver addestrato un modello Edge, puoi esportarlo su dispositivi diversi.

I container supportano i modelli TensorFlow, denominati saved_model.pb al momento dell'esportazione.

Per esportare un modello AutoML Vision Edge per i container, seleziona la scheda Container nell'interfaccia utente, quindi esporta il modello in ${YOUR_MODEL_PATH} in Google Cloud Storage. Questo modello esportato verrà pubblicato con i container come API REST in un secondo momento.

Opzione Esporta nel contenitore

Per scaricare il modello esportato in locale, esegui questo comando.

Dove:

  • ${YOUR_MODEL_PATH}: la posizione del modello su Google Cloud Storage (ad esempio, gs://my-bucket-vcm/models/edge/ICN4245971651915048908/2020-01-20_01-27-14-064_tf-saved-model/)
  • ${YOUR_LOCAL_MODEL_PATH} - Il percorso locale da cui vuoi scaricare il modello (ad esempio, /tmp).
gsutil cp ${YOUR_MODEL_PATH} ${YOUR_LOCAL_MODEL_PATH}/saved_model.pb

Installa Docker

Docker è un software utilizzato per il deployment e l'esecuzione di applicazioni all'interno di container.

Installa Docker Community Edition (CE) sul tuo sistema. Lo utilizzerai per servire i modelli Edge come API REST.

Installa il driver NVIDIA e NVIDIA DOCKER (facoltativo - solo per GPU)

Alcuni dispositivi sono dotati di GPU per fornire previsioni più rapide. Il container docker GPU viene fornito con supporto per le GPU NVIDIA.

Per eseguire i container GPU, devi installare il driver NVIDIA e NVIDIA Docker sul tuo sistema.

Esecuzione dell'inferenza del modello mediante CPU

Questa sezione fornisce istruzioni dettagliate per eseguire inferenze dei modelli utilizzando i container della CPU. Utilizzerai il Docker installato per ottenere ed eseguire il container della CPU per gestire i modelli Edge esportati come API REST, quindi inviare le richieste di un'immagine di test alle API REST per ottenere i risultati analizzati.

Esegui il pull dell'immagine Docker

Innanzitutto, utilizzerai Docker per ottenere un container CPU predefinito. Il container CPU predefinito include già l'intero ambiente per la gestione dei modelli Edge esportati, che non contengono ancora modelli Edge.

Il container predefinito della CPU è archiviato in Google Container Registry. Prima di richiedere il container, imposta una variabile di ambiente per la posizione del container in Google Container Registry:

export CPU_DOCKER_GCR_PATH=gcr.io/cloud-devrel-public-resources/gcloud-container-1.14.0:latest

Dopo aver impostato la variabile di ambiente per il percorso di Container Registry, esegui questa riga di comando per ottenere il container della CPU:

sudo docker pull ${CPU_DOCKER_GCR_PATH}

esegui il container Docker

Dopo aver ottenuto il container esistente, eseguirai questo container della CPU per fornire inferenze del modello Edge con le API REST.

Prima di avviare il container della CPU, devi impostare le variabili di sistema:

  • ${CONTAINER_NAME} - Una stringa che indica il nome del container, ad esempio CONTAINER_NAME=automl_high_accuracy_model_cpu, quando viene eseguito.
  • ${PORT} - Un numero che indica la porta nel tuo dispositivo per accettare in seguito chiamate API REST, ad esempio PORT=8501.

Dopo aver impostato le variabili, esegui Docker nella riga di comando per gestire le inferenze del modello Edge con le API REST:

sudo docker run --rm --name ${CONTAINER_NAME} -p ${PORT}:8501 -v ${YOUR_MODEL_PATH}:/tmp/mounted_model/0001 -t ${CPU_DOCKER_GCR_PATH}

Una volta eseguito correttamente il container, le API REST sono pronte per essere pubblicate su http://localhost:${PORT}/v1/models/default:predict. La sezione seguente descrive come inviare richieste di previsione a questa località.

Invia una richiesta di previsione

Ora che il container funziona correttamente, puoi inviare una richiesta di previsione su un'immagine di test alle API REST.

Riga di comando

Il corpo della richiesta della riga di comando contiene image_bytes con codifica Base64 e una stringa key per identificare l'immagine specificata. Consulta l'argomento Codifica Base64 per ulteriori informazioni sulla codifica delle immagini. Il formato del file JSON della richiesta è il seguente:

/tmp/request.json 
{
  "instances":
  [
    {
      "image_bytes":
      {
        "b64": "/9j/7QBEUGhvdG9zaG9...base64-encoded-image-content...fXNWzvDEeYxxxzj/Coa6Bax//Z"
      },
      "key": "your-chosen-image-key"
    }
  ]
}

Dopo aver creato un file di richiesta JSON locale, puoi inviare la tua richiesta di previsione.

Utilizza il seguente comando per inviare la richiesta di previsione:

curl -X POST -d  @/tmp/request.json http://localhost:${PORT}/v1/models/default:predict
Risposta

Dovresti vedere un output simile al seguente:

{
    "predictions": [
        {
            "labels": ["Good", "Bad"],
            "scores": [0.665018, 0.334982]
        }
    ]
}

Python

Per maggiori informazioni, consulta la documentazione di riferimento dell'API AutoML Vision Python.

Per eseguire l'autenticazione in AutoML Vision, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

import base64
import cv2
import io
import json

import requests

def preprocess_image(image_file_path, max_width, max_height):
    """Preprocesses input images for AutoML Vision Edge models.

    Args:
        image_file_path: Path to a local image for the prediction request.
        max_width: The max width for preprocessed images. The max width is 640
            (1024) for AutoML Vision Image Classfication (Object Detection)
            models.
        max_height: The max width for preprocessed images. The max height is
            480 (1024) for AutoML Vision Image Classfication (Object
            Detetion) models.
    Returns:
        The preprocessed encoded image bytes.
    """
    # cv2 is used to read, resize and encode images.
    encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), 85]
    im = cv2.imread(image_file_path)
    [height, width, _] = im.shape
    if height > max_height or width > max_width:
        ratio = max(height / float(max_width), width / float(max_height))
        new_height = int(height / ratio + 0.5)
        new_width = int(width / ratio + 0.5)
        resized_im = cv2.resize(
            im, (new_width, new_height), interpolation=cv2.INTER_AREA
        )
        _, processed_image = cv2.imencode(".jpg", resized_im, encode_param)
    else:
        _, processed_image = cv2.imencode(".jpg", im, encode_param)
    return base64.b64encode(processed_image).decode("utf-8")

def container_predict(image_file_path, image_key, port_number=8501):
    """Sends a prediction request to TFServing docker container REST API.

    Args:
        image_file_path: Path to a local image for the prediction request.
        image_key: Your chosen string key to identify the given image.
        port_number: The port number on your device to accept REST API calls.
    Returns:
        The response of the prediction request.
    """
    # AutoML Vision Edge models will preprocess the input images.
    # The max width and height for AutoML Vision Image Classification and
    # Object Detection models are 640*480 and 1024*1024 separately. The
    # example here is for Image Classification models.
    encoded_image = preprocess_image(
        image_file_path=image_file_path, max_width=640, max_height=480
    )

    # The example here only shows prediction with one image. You can extend it
    # to predict with a batch of images indicated by different keys, which can
    # make sure that the responses corresponding to the given image.
    instances = {
        "instances": [{"image_bytes": {"b64": str(encoded_image)}, "key": image_key}]
    }

    # This example shows sending requests in the same server that you start
    # docker containers. If you would like to send requests to other servers,
    # please change localhost to IP of other servers.
    url = "http://localhost:{}/v1/models/default:predict".format(port_number)

    response = requests.post(url, data=json.dumps(instances))
    print(response.json())

(Facoltativo) Esegui l'inferenza del modello utilizzando i container GPU

Questa sezione mostra come eseguire le inferenze dei modelli utilizzando i container GPU. Questo processo è molto simile all'esecuzione dell'inferenza del modello utilizzando una CPU. Le differenze principali sono il percorso del container GPU e il modo in cui avvii i container GPU.

Esegui il pull dell'immagine Docker

Innanzitutto, utilizzerai Docker per ottenere un container GPU predefinito. Il container GPU predefinito include già l'ambiente per gestire i modelli Edge esportati con GPU, che non contengono ancora modelli Edge o driver.

Il container predefinito della CPU è archiviato in Google Container Registry. Prima di richiedere il container, imposta una variabile di ambiente per la posizione del container in Google Container Registry:

export GPU_DOCKER_GCR_PATH=gcr.io/cloud-devrel-public-resources/gcloud-container-1.14.0-gpu:latest

Esegui la riga di comando seguente per recuperare il container GPU:

sudo docker pull ${GPU_DOCKER_GCR_PATH}

esegui il container Docker

Questo passaggio eseguirà il container GPU per gestire le inferenze dei modelli Edge con le API REST. Devi installare il driver NVIDIA e docker come indicato sopra. Devi inoltre impostare le seguenti variabili di sistema:

  • ${CONTAINER_NAME} - Una stringa che indica il nome del container, ad esempio CONTAINER_NAME=automl_high_accuracy_model_gpu, quando viene eseguito.
  • ${PORT} - Un numero che indica la porta nel tuo dispositivo per accettare in seguito chiamate API REST, ad esempio PORT=8502.

Dopo aver impostato le variabili, esegui Docker nella riga di comando per gestire le inferenze del modello Edge con le API REST:

sudo docker run --runtime=nvidia --rm --name "${CONTAINER_NAME}" -v \
${YOUR_MODEL_PATH}:/tmp/mounted_model/0001 -p \
${PORT}:8501 -t ${GPU_DOCKER_GCR_PATH}

Una volta eseguito correttamente il container, le API REST sono pronte per essere pubblicate in http://localhost:${PORT}/v1/models/default:predict. La sezione seguente descrive come inviare richieste di previsione a questa località.

Invia una richiesta di previsione

Ora che il container funziona correttamente, puoi inviare una richiesta di previsione su un'immagine di test alle API REST.

Riga di comando

Il corpo della richiesta della riga di comando contiene image_bytes con codifica Base64 e una stringa key per identificare l'immagine specificata. Consulta l'argomento Codifica Base64 per ulteriori informazioni sulla codifica delle immagini. Il formato del file JSON della richiesta è il seguente:

/tmp/request.json 
{
  "instances":
  [
    {
      "image_bytes":
      {
        "b64": "/9j/7QBEUGhvdG9zaG9...base64-encoded-image-content...fXNWzvDEeYxxxzj/Coa6Bax//Z"
      },
      "key": "your-chosen-image-key"
    }
  ]
}

Dopo aver creato un file di richiesta JSON locale, puoi inviare la tua richiesta di previsione.

Utilizza il seguente comando per inviare la richiesta di previsione:

curl -X POST -d  @/tmp/request.json http://localhost:${PORT}/v1/models/default:predict
Risposta

Dovresti vedere un output simile al seguente:

{
    "predictions": [
        {
            "labels": ["Good", "Bad"],
            "scores": [0.665018, 0.334982]
        }
    ]
}

Python

Per maggiori informazioni, consulta la documentazione di riferimento dell'API AutoML Vision Python.

Per eseguire l'autenticazione in AutoML Vision, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

import base64
import cv2
import io
import json

import requests

def preprocess_image(image_file_path, max_width, max_height):
    """Preprocesses input images for AutoML Vision Edge models.

    Args:
        image_file_path: Path to a local image for the prediction request.
        max_width: The max width for preprocessed images. The max width is 640
            (1024) for AutoML Vision Image Classfication (Object Detection)
            models.
        max_height: The max width for preprocessed images. The max height is
            480 (1024) for AutoML Vision Image Classfication (Object
            Detetion) models.
    Returns:
        The preprocessed encoded image bytes.
    """
    # cv2 is used to read, resize and encode images.
    encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), 85]
    im = cv2.imread(image_file_path)
    [height, width, _] = im.shape
    if height > max_height or width > max_width:
        ratio = max(height / float(max_width), width / float(max_height))
        new_height = int(height / ratio + 0.5)
        new_width = int(width / ratio + 0.5)
        resized_im = cv2.resize(
            im, (new_width, new_height), interpolation=cv2.INTER_AREA
        )
        _, processed_image = cv2.imencode(".jpg", resized_im, encode_param)
    else:
        _, processed_image = cv2.imencode(".jpg", im, encode_param)
    return base64.b64encode(processed_image).decode("utf-8")

def container_predict(image_file_path, image_key, port_number=8501):
    """Sends a prediction request to TFServing docker container REST API.

    Args:
        image_file_path: Path to a local image for the prediction request.
        image_key: Your chosen string key to identify the given image.
        port_number: The port number on your device to accept REST API calls.
    Returns:
        The response of the prediction request.
    """
    # AutoML Vision Edge models will preprocess the input images.
    # The max width and height for AutoML Vision Image Classification and
    # Object Detection models are 640*480 and 1024*1024 separately. The
    # example here is for Image Classification models.
    encoded_image = preprocess_image(
        image_file_path=image_file_path, max_width=640, max_height=480
    )

    # The example here only shows prediction with one image. You can extend it
    # to predict with a batch of images indicated by different keys, which can
    # make sure that the responses corresponding to the given image.
    instances = {
        "instances": [{"image_bytes": {"b64": str(encoded_image)}, "key": image_key}]
    }

    # This example shows sending requests in the same server that you start
    # docker containers. If you would like to send requests to other servers,
    # please change localhost to IP of other servers.
    url = "http://localhost:{}/v1/models/default:predict".format(port_number)

    response = requests.post(url, data=json.dumps(instances))
    print(response.json())

Riepilogo

In questo tutorial hai esaminato l'esecuzione di modelli Edge utilizzando i container Docker della CPU o della GPU. Ora puoi eseguire il deployment di questa soluzione basata su container.

Passaggio successivo