TFX | TensorFlow

Questa pagina è stata tradotta dall'API Cloud Translation.

Sviluppare con Docker

Estrazione di un'immagine di sviluppo

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

docker pull tensorflow/serving:latest-devel

Per un ambiente di sviluppo in cui puoi creare TensorFlow Serving con supporto GPU, utilizza:

docker pull tensorflow/serving:latest-devel-gpu

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

Esempio di sviluppo

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

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

Testare l'ambiente di sviluppo

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

# 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

Dockerfile

Attualmente manteniamo i seguenti Dockerfile:

Dockerfile , che è una VM minima con TensorFlow Serving installato.
Dockerfile.gpu , che è una VM minima con TensorFlow Serving con supporto GPU da utilizzare con nvidia-docker .
Dockerfile.devel , che è una VM minima con tutte le dipendenze necessarie per creare TensorFlow Serving.
Dockerfile.devel-gpu , che è una VM minima con tutte le dipendenze necessarie per creare TensorFlow Serving con supporto GPU.

Costruire un contenitore da un Dockerfile

Se desideri creare la tua immagine Docker da un Dockerfile, 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 tentare di creare un'immagine, controlla il repository tensorflow/serving di Docker Hub per assicurarti che non esista già un'immagine che soddisfi le tue esigenze.

La compilazione dai sorgenti 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 la documentazione di Bazel per ulteriori informazioni. Puoi utilizzare questo stesso meccanismo per modificare le ottimizzazioni con cui stai creando TensorFlow Serving. 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 tu abbia 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 stai eseguendo un'immagine GPU, assicurati di eseguirla utilizzando il runtime NVIDIA --runtime=nvidia .

Da qui è possibile seguire le istruzioni per testare un ambiente di sviluppo .

Creazione di un binario di servizio ottimizzato

Quando esegui ModelServer di TensorFlow Serving, potresti 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 ModelServer non è completamente ottimizzato per la CPU su cui è in esecuzione. A seconda del modello che stai servendo, potrebbero non essere necessarie ulteriori ottimizzazioni. Tuttavia, costruire un file binario ottimizzato è semplice.

Quando si crea 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 file binario ModelServer con tutte le ottimizzazioni della CPU supportate dall'host su cui stai creando l'immagine Docker.

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

Clona il progetto TensorFlow Serving

git clone https://github.com/tensorflow/serving
cd serving

Costruisci un'immagine con un ModelServer ottimizzato

Per CPU:

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

Per la GPU: `

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

Crea 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 .
```
  La tua nuova immagine Docker ottimizzata è ora $USER/tensorflow-serving , che puoi utilizzare proprio come faresti con l'immagine tensorflow/serving:latest standard.
- Per 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 .
```
  La tua nuova immagine Docker ottimizzata è ora $USER/tensorflow-serving-gpu , che puoi utilizzare proprio come faresti con l'immagine tensorflow/serving:latest-gpu standard.