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

Sviluppando con Docker

Tirare un'immagine di sviluppo

Per un ambiente di sviluppo in cui è possibile creare TensorFlow Serving, è possibile provare:

 docker pull tensorflow/serving:latest-devel
 

Per un ambiente di sviluppo in cui è possibile creare TensorFlow con supporto GPU, utilizzare:

 docker pull tensorflow/serving:latest-devel-gpu
 

Vedi il Docking Hub tensorflow / repo di servizio per altre versioni di immagini che puoi estrarre.

Esempio di sviluppo

Dopo aver estratto una delle immagini Docker di sviluppo, è possibile eseguirla aprendo la porta gRPC (8500):

 docker run -it -p 8500:8500 tensorflow/serving:latest-devel
 

Test dell'ambiente di sviluppo

Per testare un modello, dall'interno del contenitore provare:

 # train the mnist model
python tensorflow_serving/example/mnist_saved_model.py /tmp/mnist_model
# serve the model
tensorflow_model_server --port=8500 --model_name=mnist --model_base_path=/tmp/mnist_model/ &
# test the client
python tensorflow_serving/example/mnist_client.py --num_tests=1000 --server=localhost:8500
 

Dockerfiles

Al momento manteniamo i seguenti Dockerfile:

  • Dockerfile , che è una macchina virtuale minimale con TensorFlow Serving installato.

  • Dockerfile.gpu , che è una VM minimale con TensorFlow con supporto GPU da utilizzare con nvidia-docker .

  • Dockerfile.devel , che è una macchina virtuale minima con tutte le dipendenze necessarie per creare il servizio TensorFlow.

  • Dockerfile.devel-gpu , che è una VM minima con tutte le dipendenze necessarie per creare TensorFlow con supporto GPU.

Creazione di un contenitore da un file Docker

Se desideri creare la tua immagine Docker da un file Docker, puoi farlo eseguendo il comando Docker build:

Dockerfile :

 docker build --pull -t $USER/tensorflow-serving .
 

Dockerfile.gpu :

 docker build --pull -t $USER/tensorflow-serving-gpu -f Dockerfile.gpu .
 

Dockerfile.devel :

 docker build --pull -t $USER/tensorflow-serving-devel -f Dockerfile.devel .
 

Dockerfile.devel-gpu :

 docker build --pull -t $USER/tensorflow-serving-devel-gpu -f Dockerfile.devel-gpu .
 

SUGGERIMENTO: prima di provare a creare un'immagine, controllare Dockens Hub tensorflow / repo di servizio per assicurarsi che un'immagine che soddisfi le proprie esigenze non sia già esistente.

Costruire da fonti consuma molta RAM. Se la RAM è un problema sul tuo sistema, puoi limitare l'utilizzo della RAM specificando --local_ram_resources=2048 mentre invochi Bazel. Consulta i documenti Bazel per ulteriori informazioni. Puoi usare questo stesso meccanismo per modificare le ottimizzazioni con cui stai realizzando TensorFlow. Per esempio:

 docker build --pull --build-arg TF_SERVING_BUILD_OPTIONS="--copt=-mavx \
  --cxxopt=-D_GLIBCXX_USE_CXX11_ABI=0 --local_ram_resources=2048" -t \
  $USER/tensorflow-serving-devel -f Dockerfile.devel .
 

Esecuzione di un contenitore

Ciò presuppone che sia stato creato il contenitore Dockerfile.devel .

Per eseguire il contenitore aprendo la porta gRPC (8500):

 docker run -it -p 8500:8500 $USER/tensorflow-serving-devel
 

SUGGERIMENTO: se si esegue un'immagine GPU, assicurarsi di eseguire utilizzando il runtime NVIDIA --runtime=nvidia .

Da qui, puoi seguire le istruzioni per testare un ambiente di sviluppo .

Costruire un servizio binario ottimizzato

Quando si esegue ModelServer di TensorFlow Serving, è possibile notare un messaggio di registro simile al seguente:

 I external/org_tensorflow/tensorflow/core/platform/cpu_feature_guard.cc:141]
Your CPU supports instructions that this TensorFlow binary was not compiled to
use: AVX2 FMA
 

Ciò indica che il file binario di ModelServer non è completamente ottimizzato per la CPU su cui è in esecuzione. A seconda del modello in uso, potrebbero non essere necessarie ulteriori ottimizzazioni. Tuttavia, la costruzione di un binario ottimizzato è semplice.

Quando si Dockerfile.devel un'immagine Docker dai file Dockerfile.devel o Dockerfile.devel-gpu forniti, il file binario ModelServer verrà creato con il flag -march=native . Ciò farà sì che Bazel crei un binario ModelServer con tutte le ottimizzazioni della CPU sull'host su cui stai costruendo l'immagine Docker su supporti.

Per creare un'immagine di pubblicazione completamente ottimizzata per il tuo host, semplicemente:

  1. Clonare il progetto TensorFlow Serving
 git clone https://github.com/tensorflow/serving
cd serving
 
  1. Costruisci un'immagine con un ModelServer ottimizzato

    • Per CPU:
 docker build --pull -t $USER/tensorflow-serving-devel \
  -f tensorflow_serving/tools/docker/Dockerfile.devel .
 
 *   For GPU: `
 
 docker build --pull -t $USER/tensorflow-serving-devel-gpu \
  -f tensorflow_serving/tools/docker/Dockerfile.devel-gpu .
 
  1. Costruisci un'immagine di servizio con l'immagine di sviluppo come base

    • Per CPU:
 docker build -t $USER/tensorflow-serving \
  --build-arg TF_SERVING_BUILD_IMAGE=$USER/tensorflow-serving-devel \
  -f tensorflow_serving/tools/docker/Dockerfile .
 
     Your new optimized Docker image is now `$USER/tensorflow-serving`, which
    you can [use](#running_a_serving_image) just as you would the standard
    `tensorflow/serving:latest` image.

*   For GPU:
 
 docker build -t $USER/tensorflow-serving-gpu \
  --build-arg TF_SERVING_BUILD_IMAGE=$USER/tensorflow-serving-devel-gpu \
  -f tensorflow_serving/tools/docker/Dockerfile.gpu .
 
     Your new optimized Docker image is now `$USER/tensorflow-serving-gpu`,
    which you can [use](#running_a_gpu_serving_image) just as you would the
    standard `tensorflow/serving:latest-gpu` image.