TensorFlow Servire con Docker

Uno dei modi più semplici per iniziare a utilizzare TensorFlow Serving è con Docker .

# Download the TensorFlow Serving Docker image and repo
docker pull tensorflow/serving

git clone https://github.com/tensorflow/serving
# Location of demo models
TESTDATA="$(pwd)/serving/tensorflow_serving/servables/tensorflow/testdata"

# Start TensorFlow Serving container and open the REST API port
docker run -t --rm -p 8501:8501 \
    -v "$TESTDATA/saved_model_half_plus_two_cpu:/models/half_plus_two" \
    -e MODEL_NAME=half_plus_two \
    tensorflow/serving &

# Query the model using the predict API
curl -d '{"instances": [1.0, 2.0, 5.0]}' \
    -X POST http://localhost:8501/v1/models/half_plus_two:predict

# Returns => { "predictions": [2.5, 3.0, 4.5] }

Per ulteriori endpoint di servizio, consulta l' API REST del client .

Installa Docker

Le istruzioni generali di installazione si trovano sul sito Docker , ma forniamo alcuni collegamenti rapidi qui:

Servire con Docker

Estrazione di un'immagine di servizio

Una volta installato Docker, puoi estrarre l'ultima immagine docker di TensorFlow Serving eseguendo:

docker pull tensorflow/serving

Verrà visualizzata un'immagine Docker minima con TensorFlow Serving installato.

Consulta il repository tensorflow/serving di Docker Hub per altre versioni di immagini che puoi estrarre.

Esecuzione di un'immagine di servizio

Le immagini di servizio (sia CPU che GPU) hanno le seguenti proprietà:

  • Porta 8500 esposta per gRPC
  • Porta 8501 esposta per l'API REST
  • Variabile d'ambiente facoltativa MODEL_NAME (il valore predefinito è model )
  • Variabile d'ambiente opzionale MODEL_BASE_PATH (il valore predefinito è /models )

Quando l'immagine di servizio esegue ModelServer, lo esegue come segue:

tensorflow_model_server --port=8500 --rest_api_port=8501 \
  --model_name=${MODEL_NAME} --model_base_path=${MODEL_BASE_PATH}/${MODEL_NAME}

Per servire con Docker, avrai bisogno di:

  • Una porta aperta sul tuo host su cui servire
  • Un modello salvato da servire
  • Un nome per il tuo modello a cui farà riferimento il tuo cliente

Quello che farai è eseguire il contenitore Docker , pubblicare le porte del contenitore sulle porte del tuo host e montare il percorso del tuo host su SavedModel nel punto in cui il contenitore prevede i modelli.

Diamo un'occhiata ad un esempio:

docker run -p 8501:8501 \
  --mount type=bind,source=/path/to/my_model/,target=/models/my_model \
  -e MODEL_NAME=my_model -t tensorflow/serving

In questo caso, abbiamo avviato un contenitore Docker, pubblicato la porta 8501 dell'API REST sulla porta 8501 del nostro host e preso un modello denominato my_model e associato al percorso di base del modello predefinito ( ${MODEL_BASE_PATH}/${MODEL_NAME} = /models/my_model ). Infine, abbiamo riempito la variabile d'ambiente MODEL_NAME con my_model e lasciato MODEL_BASE_PATH al suo valore predefinito.

Questo verrà eseguito nel contenitore:

tensorflow_model_server --port=8500 --rest_api_port=8501 \
  --model_name=my_model --model_base_path=/models/my_model

Se volessimo pubblicare la porta gRPC, utilizzeremmo -p 8500:8500 . Puoi avere entrambe le porte gRPC e API REST aperte contemporaneamente oppure scegliere di aprire solo l'una o l'altra.

Passaggio di argomenti aggiuntivi

tensorflow_model_server supporta molti argomenti aggiuntivi che potresti passare ai contenitori docker di servizio. Ad esempio, se volessimo passare un file di configurazione del modello invece di specificare il nome del modello, potremmo fare quanto segue:

docker run -p 8500:8500 -p 8501:8501 \
  --mount type=bind,source=/path/to/my_model/,target=/models/my_model \
  --mount type=bind,source=/path/to/my/models.config,target=/models/models.config \
  -t tensorflow/serving --model_config_file=/models/models.config

Questo approccio funziona per qualsiasi altro argomento della riga di comando supportato da tensorflow_model_server .

Creare la tua immagine di servizio

Se desideri un'immagine di pubblicazione con il tuo modello integrato nel contenitore, puoi creare la tua immagine.

Per prima cosa esegui un'immagine di servizio come demone:

docker run -d --name serving_base tensorflow/serving

Successivamente, copia il tuo SavedModel nella cartella del modello del contenitore:

docker cp models/<my model> serving_base:/models/<my model>

Infine, conferma il contenitore che serve il tuo modello modificando MODEL_NAME in modo che corrisponda al nome del tuo modello ` ':

docker commit --change "ENV MODEL_NAME <my model>" serving_base <my container>

Ora puoi interrompere serving_base

docker kill serving_base

Questo ti lascerà con un'immagine Docker chiamata <my container> che puoi distribuire e caricherà il tuo modello per essere servito all'avvio.

Esempio utile

Esaminiamo un esempio completo in cui carichiamo un SavedModel e lo chiamiamo utilizzando l'API REST. Per prima cosa estrai l'immagine di servizio:

docker pull tensorflow/serving

Verrà estratta l'ultima immagine di TensorFlow Serving con ModelServer installato.

Successivamente utilizzeremo un modello giocattolo chiamato Half Plus Two , che genera 0.5 * x + 2 per i valori di x forniti per la previsione.

Per ottenere questo modello, clonare prima il repository TensorFlow Serving.

mkdir -p /tmp/tfserving
cd /tmp/tfserving
git clone https://github.com/tensorflow/serving

Successivamente, esegui il contenitore TensorFlow Serving puntandolo a questo modello e aprendo la porta API REST (8501):

docker run -p 8501:8501 \
  --mount type=bind,\
source=/tmp/tfserving/serving/tensorflow_serving/servables/tensorflow/testdata/saved_model_half_plus_two_cpu,\
target=/models/half_plus_two \
  -e MODEL_NAME=half_plus_two -t tensorflow/serving &

Questo eseguirà il contenitore docker e avvierà TensorFlow Serving Model Server, collegherà la porta API REST 8501 e mapperà il modello desiderato dal nostro host al punto in cui sono previsti i modelli nel contenitore. Passiamo anche il nome del modello come variabile d'ambiente, che sarà importante quando interrogheremo il modello.

Per eseguire query sul modello utilizzando l'API di previsione, puoi eseguire

curl -d '{"instances": [1.0, 2.0, 5.0]}' \
  -X POST http://localhost:8501/v1/models/half_plus_two:predict

Questo dovrebbe restituire una serie di valori:

{ "predictions": [2.5, 3.0, 4.5] }

Ulteriori informazioni sull'utilizzo dell'API RESTful possono essere trovate qui .

Servire con Docker utilizzando la tua GPU

Installa nvidia-docker

Prima di utilizzare una GPU, oltre a installare Docker , avrai bisogno di:

Esecuzione di un'immagine di servizio GPU

L'esecuzione di un'immagine di servizio GPU è identica all'esecuzione di un'immagine della CPU. Per ulteriori dettagli, vedi esecuzione di un'immagine di pubblicazione .

Esempio di servizio GPU

Esaminiamo un esempio completo in cui carichiamo un modello con operazioni legate alla GPU e lo chiamiamo utilizzando l'API REST.

Per prima cosa installa nvidia-docker . Successivamente puoi estrarre l'ultima immagine docker TensorFlow Serving GPU eseguendo:

docker pull tensorflow/serving:latest-gpu

Verrà scaricata un'immagine Docker minima con ModelServer creato per l'esecuzione su GPU installate.

Successivamente utilizzeremo un modello giocattolo chiamato Half Plus Two , che genera 0.5 * x + 2 per i valori di x forniti per la previsione. Questo modello avrà operazioni legate al dispositivo GPU e non verrà eseguito sulla CPU.

Per ottenere questo modello, clonare prima il repository TensorFlow Serving.

mkdir -p /tmp/tfserving
cd /tmp/tfserving
git clone https://github.com/tensorflow/serving

Successivamente, esegui il contenitore TensorFlow Serving puntandolo a questo modello e aprendo la porta API REST (8501):

docker run --gpus all -p 8501:8501 \
--mount type=bind,\
source=/tmp/tfserving/serving/tensorflow_serving/servables/tensorflow/testdata/saved_model_half_plus_two_gpu,\
target=/models/half_plus_two \
  -e MODEL_NAME=half_plus_two -t tensorflow/serving:latest-gpu &

Questo eseguirà il contenitore docker, avvierà TensorFlow Serving Model Server, collegherà la porta API REST 8501 e mapperà il modello desiderato dal nostro host al punto in cui sono previsti i modelli nel contenitore. Passiamo anche il nome del modello come variabile d'ambiente, che sarà importante quando interrogheremo il modello.

SUGGERIMENTO: prima di eseguire una query sul modello, assicurati di attendere finché non viene visualizzato un messaggio come il seguente, che indica che il server è pronto a ricevere richieste:

2018-07-27 00:07:20.773693: I tensorflow_serving/model_servers/main.cc:333]
Exporting HTTP/REST API at:localhost:8501 ...

Per eseguire query sul modello utilizzando l'API di previsione, puoi eseguire

curl -d '{"instances": [1.0, 2.0, 5.0]}' \
  -X POST http://localhost:8501/v1/models/half_plus_two:predict

Questo dovrebbe restituire un insieme di valori:

{ "predictions": [2.5, 3.0, 4.5] }

SUGGERIMENTO: Il tentativo di eseguire il modello GPU su una macchina senza GPU o senza una build GPU funzionante di TensorFlow Model Server comporterà un errore simile a:

Cannot assign a device for operation 'a': Operation was explicitly assigned to /device:GPU:0

Ulteriori informazioni sull'utilizzo dell'API RESTful possono essere trovate qui .

Sviluppare con Docker

Per istruzioni su come creare e sviluppare Tensorflow Serving, fare riferimento alla guida Sviluppo con Docker .