Questa pagina è stata tradotta dall'API Cloud Translation.
Switch to English

TensorFlow che serve 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 endpoint di servizio aggiuntivi, vedere l' API REST del client .

Installa Docker

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

Servire con Docker

Tirando un'immagine di servizio

Dopo aver 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.

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

Esecuzione di un'immagine di servizio

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

  • Porta 8500 esposta per gRPC
  • Porta 8501 esposta per l'API REST
  • Variabile di ambiente opzionale MODEL_NAME (il valore predefinito è model )
  • Variabile di 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 SavedModel 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 dove il contenitore si aspetta modelli.

Diamo un'occhiata a 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 container Docker, pubblicato la porta dell'API REST 8501 sulla porta 8501 del nostro host e preso un modello che abbiamo chiamato my_model e lo abbiamo 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, useremmo -p 8500:8500 . Puoi avere entrambe le porte gRPC e REST API aperte contemporaneamente o 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 servizio con il tuo modello integrato nel contenitore, puoi creare la tua immagine.

Prima esegui un'immagine di servizio come daemon:

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, salva il contenitore che serve il tuo modello cambiando 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 l'elaborazione 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 della pubblicazione:

docker pull tensorflow/serving

In questo modo 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, prima clona 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 nostro modello desiderato dal nostro host alla posizione in cui sono previsti modelli nel contenitore. Passiamo anche il nome del modello come variabile di ambiente, che sarà importante quando interroghiamo il modello.

Per eseguire query sul modello utilizzando l'API di previsione, è possibile 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] }

Ulteriori informazioni sull'utilizzo dell'API RESTful sono disponibili qui .

Servire con Docker utilizzando la tua GPU

Installa nvidia-docker

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

Esecuzione di un'immagine di pubblicazione della GPU

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

Esempio di servizio GPU

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

Prima installa nvidia-docker . Successivamente è possibile eseguire il pull dell'ultima immagine docker della GPU TensorFlow Serving eseguendo:

docker pull tensorflow/serving:latest-gpu

Questo tirerà giù un'immagine Docker minima con ModelServer costruito 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 funzionerà sulla CPU.

Per ottenere questo modello, prima clona 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 --runtime=nvidia -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 con il runtime nvidia-docker , avvierà TensorFlow Serving Model Server, collegherà la porta API REST 8501 e mapperà il nostro modello desiderato dal nostro host a dove sono previsti modelli nel contenitore. Passiamo anche il nome del modello come variabile di ambiente, che sarà importante quando interroghiamo il modello.

SUGGERIMENTO: prima di interrogare il 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, è possibile 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 simile a:

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

Ulteriori informazioni sull'utilizzo dell'API RESTful sono disponibili qui .

Sviluppo con Docker

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