Tutorial sui container Edge

Dopo aver creato un modello AutoML Vision Edge e averlo esportato in un modello Bucket Cloud Storage cui puoi utilizzare i servizi RESTful Modelli AutoML Vision Edge e Immagini Docker basate su TF.

Cosa creerai

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

In questo tutorial, troverai una spiegazione passo passo nell'esecuzione di modelli periferici sui dispositivi utilizzando container Docker.

Nello specifico, questo tutorial ti guiderà attraverso tre passaggi:

  1. Creazione di container predefiniti.
  2. Esecuzione di container con modelli Edge per avviare API REST.
  3. per fare previsioni.

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

Obiettivi

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

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

Prima di iniziare

Per completare questo tutorial, devi:

  1. Addestra un modello Edge esportabile. Segui le Guida rapida ai modelli di dispositivi Edge per addestrare un modello Edge un modello di machine learning.
  2. Esporta un modello AutoML Vision Edge. Questo modello con container come API REST.
  3. Installa Docker. Questo è il software richiesto per eseguire e i container Docker.
  4. (Facoltativo) Installa il docker e il driver NVIDIA. Questo passaggio è facoltativo se hanno dispositivi con GPU e vorrebbe ottenere previsioni più rapide.
  5. Prepara le immagini di test. Queste immagini verranno inviate nelle richieste per ottenere i risultati analizzati.

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

Esporta modello AutoML Vision Edge

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

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

Per esportare un modello AutoML Vision Edge per i container, seleziona Container nella UI ed esporta modello per ${YOUR_MODEL_PATH} su Google di archiviazione ideale in Cloud Storage. Questo modello esportato in un secondo momento con i container come API REST.

Opzione Esporta in contenitore

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

Dove:

  • ${YOUR_MODEL_PATH} - La località 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 tuo percorso locale dove vuoi scaricare il modello (ad esempio, /tmp).
gcloud storage cp ${YOUR_MODEL_PATH} ${YOUR_LOCAL_MODEL_PATH}/saved_model.pb

Installa Docker

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

Installa Docker Community Edition (CE) sul tuo sistema. Potrai per gestire i modelli Edge come API REST.

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

Alcuni dispositivi dispongono di GPU per fornire previsioni più rapide. Container Docker GPU supporta le GPU NVIDIA.

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

Esecuzione dell'inferenza del modello utilizzando la CPU

Questa sezione fornisce istruzioni dettagliate per eseguire le inferenze del modello utilizzando i container della CPU. Utilizzerai il Docker installato per recuperare ed eseguire il container della CPU per gestire i modelli Edge esportati come API REST, invia 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 modello predefinito Il container della CPU include già l'intero ambiente per pubblicare i modelli Edge esportati, che non contiene ancora modelli Edge.

Il container con CPU predefinito è archiviato in Google Container Registry. Prima del giorno richiesta del container, imposta una variabile di ambiente per la località 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 la seguente 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 le 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 quando in esecuzione, ad esempio CONTAINER_NAME=automl_high_accuracy_model_cpu.
  • ${PORT}: un numero che indica la portabilità sul dispositivo da accettare Chiamate API REST in un secondo momento, ad esempio PORT=8501.

Dopo aver impostato le variabili, esegui Docker nella riga di comando per gestire il modello Edge le inferenze 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 che il container è in esecuzione, le API REST sono pronte per la pubblicazione alle ore http://localhost:${PORT}/v1/models/default:predict. La nella sezione seguente viene spiegato come inviare richieste di previsione a questa località.

Invia una richiesta di previsione

Ora che il container funziona correttamente, puoi inviare una 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 data. Consulta le Argomento Codifica Base64 per saperne di più 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 previsione richiesta.

Utilizza il comando seguente 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 ulteriori informazioni, consulta API AutoML Vision Python documentazione di riferimento.

Per eseguire l'autenticazione su AutoML Vision, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 container GPU

Questa sezione mostra come eseguire le inferenze del modello utilizzando i container GPU. Questo è molto simile all'esecuzione dell'inferenza del modello utilizzando una CPU. La chiave le differenze sono il percorso del container GPU e il modo in cui vengono avviati i container GPU.

Esegui il pull dell'immagine Docker

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

Il container con CPU predefinito è archiviato in Google Container Registry. Prima del giorno quando richiedi il container, imposta una variabile di ambiente per posizione in Google Container Registry:

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

Esegui questa riga di comando per recuperare il container GPU:

sudo docker pull ${GPU_DOCKER_GCR_PATH}

Esegui il container Docker

In questo passaggio verrà eseguito il container GPU per gestire le inferenze del modello Edge con le API REST. Devi installare il driver e la docker NVIDIA come indicato sopra. Devi inoltre impostare le seguenti variabili di sistema:

  • ${CONTAINER_NAME}: una stringa che indica il nome del container quando in esecuzione, ad esempio CONTAINER_NAME=automl_high_accuracy_model_gpu.
  • ${PORT}: un numero che indica la portabilità sul dispositivo da accettare Chiamate API REST in un secondo momento, ad esempio PORT=8502.

Dopo aver impostato le variabili, esegui Docker nella riga di comando per gestire il modello Edge le inferenze 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 che il container è in esecuzione, le API REST sono pronte per la pubblicazione in http://localhost:${PORT}/v1/models/default:predict. La nella sezione seguente viene spiegato come inviare richieste di previsione a questa località.

Invia una richiesta di previsione

Ora che il container funziona correttamente, puoi inviare una 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 data. Consulta le Argomento Codifica Base64 per saperne di più 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 previsione richiesta.

Utilizza il comando seguente 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 ulteriori informazioni, consulta API AutoML Vision Python documentazione di riferimento.

Per eseguire l'autenticazione su AutoML Vision, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 la CPU o container Docker GPU. Ora puoi eseguire il deployment di questo container su più dispositivi.

Passaggi successivi