TFX | TensorFlow

Esta página foi traduzida pela API Cloud Translation.

Desenvolvendo com Docker

Puxando uma imagem de desenvolvimento

Para um ambiente de desenvolvimento onde você pode construir o TensorFlow Serving, você pode tentar:

docker pull tensorflow/serving:latest-devel

Para um ambiente de desenvolvimento onde você pode construir o TensorFlow Serving com suporte para GPU, use:

docker pull tensorflow/serving:latest-devel-gpu

Veja o Docker Hub tensorflow / servindo repo para outras versões do as imagens que você pode puxar.

Exemplo de desenvolvimento

Depois de extrair uma das imagens do Docker de desenvolvimento, você pode executá-la enquanto abre a porta gRPC (8500):

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

Testando o ambiente de desenvolvimento

Para testar um modelo, de dentro do contêiner, tente:

# 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

Atualmente, mantemos os seguintes Dockerfiles:

Dockerfile , que é um VM mínimo com TensorFlow Servindo instalado.
Dockerfile.gpu , que é um VM mínima com TensorFlow Servindo com suporte GPU para ser usado com nvidia-docker .
Dockerfile.devel , que é um VM mínimo com todas as dependências necessárias para construir TensorFlow Servindo.
Dockerfile.devel-gpu , que é um VM mínimo com todas as dependências necessárias para construir TensorFlow Servindo com suporte GPU.

Construir um contêiner a partir de um Dockerfile

Se quiser construir sua própria imagem do Docker a partir de um Dockerfile, você pode fazer isso executando o comando de compilação do Docker:

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 .

DICA: Antes de tentar construir uma imagem, verifique o Docker Hub tensorflow / servindo repo para certificar-se uma imagem que atenda às suas necessidades ainda não existir.

Construir a partir de fontes consome muita RAM. Se RAM é um problema em seu sistema, você pode limitar o uso de RAM, especificando --local_ram_resources=2048 ao chamar Bazel. Veja os docs Bazel para mais informações. Você pode usar esse mesmo mecanismo para ajustar as otimizações com as quais está construindo o TensorFlow Serving. Por exemplo:

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 .

Executando um contêiner

Isso pressupõe que você tenha construído o Dockerfile.devel recipiente.

Para executar o contêiner abrindo a porta gRPC (8500):

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

DICA: Se você estiver executando uma imagem de GPU, certifique-se de executar usando o NVIDIA runtime --runtime=nvidia .

A partir daqui, você pode seguir as instruções para testar um ambiente de desenvolvimento .

Criação de um binário de veiculação otimizado

Ao executar o ModelServer do TensorFlow Serving, você pode notar uma mensagem de registro semelhante a esta:

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

Isso indica que seu binário ModelServer não está totalmente otimizado para a CPU em que está sendo executado. Dependendo do modelo que você está servindo, otimizações adicionais podem não ser necessárias. No entanto, construir um binário otimizado é simples.

Ao construir uma imagem Docker do fornecido Dockerfile.devel ou Dockerfile.devel-gpu arquivos, o binário ModelServer será construído com a bandeira -march=native . Isso fará com que o Bazel construa um binário ModelServer com todas as otimizações de CPU para as quais o host que você está construindo a imagem Docker suporta.

Para criar uma imagem de veiculação totalmente otimizada para seu host, basta:

Clone o projeto TensorFlow Serving

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

Crie uma imagem com um ModelServer otimizado

Para CPU:

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

Para GPU: `

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

Construir uma imagem de serviço com a imagem de desenvolvimento como base
- Para CPU:
```
docker build -t $USER/tensorflow-serving \
  --build-arg TF_SERVING_BUILD_IMAGE=$USER/tensorflow-serving-devel \
  -f tensorflow_serving/tools/docker/Dockerfile .
```
  Sua imagem Docker otimizado novo é agora $USER/tensorflow-serving , que você pode usar como faria o padrão tensorflow/serving:latest imagem.
- Para 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 .
```
  Sua imagem Docker otimizado novo é agora $USER/tensorflow-serving-gpu , que você pode usar como faria o padrão tensorflow/serving:latest-gpu imagem.