Questa pagina è stata tradotta dall'API Cloud Translation.

TensorFlow al servizio con Docker

Uno dei modi più semplici per iniziare a utilizzare tensorflow porzione è con finestra mobile .

# 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 punti finali che servono, vedere il Client API REST .

Installa Docker

Istruzioni per l'installazione generale sono sul sito Docker , ma diamo alcuni collegamenti rapidi qui:

Docker per macOS
Docker per Windows per Windows 10 Pro o successivo
Docker Toolbox per le versioni più vecchie di MacOS, o le versioni di Windows prima di Windows 10 Pro

Servire con Docker

Tirare un'immagine di servizio

Dopo aver installato Docker, puoi estrarre l'ultima immagine docker TensorFlow Serving eseguendo:

docker pull tensorflow/serving

Questo ridurrà un'immagine Docker minima con TensorFlow Serving installato.

Vedere la Docker Hub tensorflow / repo servire per altre versioni di immagini si può tirare.

Esecuzione di un'immagine di servizio

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

Porta 8500 esposta per gRPC
Porta 8501 esposta per l'API REST
Opzionale variabile d'ambiente MODEL_NAME (il default è model )
Ambiente opzionale variabile MODEL_BASE_PATH (default /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 faremo è eseguire il Docker contenitore, pubblicare le porte del container alle porte del proprio host, e il montaggio il percorso del vostro ospite al SavedModel al punto in cui il contenitore si aspetta modelli.

Vediamo 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 iniziato un contenitore Docker, pubblicato il porto API REST 8501 alla porta del nostro ospite 8501, e portati un modello che abbiamo chiamato my_model e legati al percorso di base del modello di default ( ${MODEL_BASE_PATH}/${MODEL_NAME} = /models/my_model ). Infine, abbiamo riempito nella variabile d'ambiente MODEL_NAME con my_model , e lasciato MODEL_BASE_PATH al suo valore di default.

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 il porto gRPC, useremmo -p 8500:8500 . Puoi avere entrambe le porte gRPC e API REST aperte contemporaneamente o scegliere di aprire solo l'una o l'altra.

Passando argomenti aggiuntivi

tensorflow_model_server supporta molti argomenti aggiuntivi che si potrebbe passare ai contenitori docker servono. 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 uno qualsiasi degli altri argomenti della riga di comando che tensorflow_model_server supporti.

Creare la tua immagine di servizio

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

Prima esegui un'immagine di servizio come demone:

docker run -d --name serving_base tensorflow/serving

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

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

Infine, impegnare il contenitore che sta servendo il vostro modello cambiando MODEL_NAME per abbinare il nome del modello ` ':

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

Ora è possibile smettere di serving_base

docker kill serving_base

Questo vi lascerà un'immagine Docker chiamato con il <my container> che è possibile distribuire e caricherà il vostro modello per il servizio all'avvio.

Esempio di servizio

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

Questo estrarrà l'ultima immagine di TensorFlow Serving con ModelServer installato.

Avanti, useremo un modello giocattolo chiamato Half Plus Two , che genera 0.5 * x + 2 per i valori di x che forniamo 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

Quindi, 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 nostro modello desiderato dal nostro host a dove sono previsti i modelli nel contenitore. Passiamo anche il nome del modello come variabile d'ambiente, che sarà importante quando interrogheremo il modello.

Per interrogare il 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] }

Maggiori informazioni su come utilizzare l'API RESTful può essere trovato qui .

Servire con Docker usando la tua GPU

Installa nvidia-docker

Prima di servire con una GPU, oltre a installazione di Docker , avrete bisogno di:

Up-to-date driver NVIDIA per il sistema
nvidia-docker : è possibile seguire le istruzioni per l'installazione qui

Esecuzione di un'immagine che serve GPU

L'esecuzione di un'immagine di servizio GPU è identica all'esecuzione di un'immagine CPU. Per maggiori dettagli, vedere esecuzione di un'immagine che serve .

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 installare nvidia-docker . Successivamente puoi estrarre l'ultima immagine docker GPU TensorFlow Serving eseguendo:

docker pull tensorflow/serving:latest-gpu

Ciò ridurrà un'immagine Docker minima con ModelServer creato per l'esecuzione su GPU installate.

Avanti, useremo un modello giocattolo chiamato Half Plus Two , che genera 0.5 * x + 2 per i valori di x che forniamo per la previsione. Questo modello avrà operazioni legate al dispositivo GPU e non funzionerà 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

Quindi, 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, legherà la porta API REST 8501 e mapperà il nostro modello desiderato dal nostro host a dove 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 interrogare il modello, assicurarsi di attendere fino a quando 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 interrogare il 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 genererà un errore del tipo:

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

Maggiori informazioni su come utilizzare l'API RESTful può essere trovato qui .

Sviluppare con Docker

Per le istruzioni su come costruire e sviluppare tensorflow Servire, si prega di fare riferimento alla Sviluppare con guida Docker .