Esta página foi traduzida pela API Cloud Translation.

TensorFlow Serving com Docker

Uma das maneiras mais fáceis de começar a usar TensorFlow porção é com 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] }

Para terminais que servem adicionais, consulte a API cliente REST .

Instale o Docker

Instruções de instalação geral são no site da Docker , mas nós damos alguns links rápidos aqui:

Docker para macOS
Docker para Windows para o Windows 10 Pro ou mais tarde
Docker Toolbox para versões mais antigas do MacOS, ou versões do Windows antes do Windows 10 Pro

Servindo com Docker

Puxando uma imagem de serviço

Depois de instalar o Docker, você pode extrair a imagem mais recente do Docker do TensorFlow Serving executando:

docker pull tensorflow/serving

Isso puxará para baixo uma imagem mínima do Docker com o TensorFlow Serving instalado.

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

Executando uma imagem de serviço

As imagens de veiculação (CPU e GPU) têm as seguintes propriedades:

Porta 8500 exposta para gRPC
Porta 8501 exposta para a API REST
Opcional variável de ambiente MODEL_NAME (padrão para model )
Variável de ambiente opcional MODEL_BASE_PATH (o padrão é /models )

Quando a imagem veiculada executa o ModelServer, ela o executa da seguinte maneira:

tensorflow_model_server --port=8500 --rest_api_port=8501 \
  --model_name=${MODEL_NAME} --model_base_path=${MODEL_BASE_PATH}/${MODEL_NAME}

Para servir com o Docker, você precisará de:

Uma porta aberta em seu host para servir
Um SavedModel para servir
Um nome para o seu modelo ao qual seu cliente se referirá

O que você vai fazer é executar o Docker recipiente, publicar portas do contêiner às portas do seu anfitrião, e de montagem caminho do seu anfitrião à SavedModel para onde o recipiente espera modelos.

Vejamos um exemplo:

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

Neste caso, nós começamos um recipiente Docker, publicado a porta API REST 8501 à porta do nosso anfitrião 8501, e levado um modelo chamamos my_model e amarrou-o para o caminho de base do modelo padrão ( ${MODEL_BASE_PATH}/${MODEL_NAME} = /models/my_model ). Finalmente, temos preenchido na variável de ambiente MODEL_NAME com my_model , e deixou MODEL_BASE_PATH para seu valor padrão.

Isso será executado no contêiner:

tensorflow_model_server --port=8500 --rest_api_port=8501 \
  --model_name=my_model --model_base_path=/models/my_model

Se quiséssemos publicar o porta gRPC, usaríamos -p 8500:8500 . Você pode ter as portas gRPC e REST API abertas ao mesmo tempo ou optar por abrir apenas uma ou a outra.

Passando argumentos adicionais

tensorflow_model_server suporta muitos argumentos adicionais que você poderia passar para os contentores Docker servir. Por exemplo, se quiséssemos passar um arquivo de configuração do modelo em vez de especificar o nome do modelo, poderíamos fazer o seguinte:

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

Essa abordagem funciona para qualquer um dos outros argumentos linha de comando que tensorflow_model_server suportes.

Criar sua própria imagem de serviço

Se você quiser uma imagem de veiculação que tenha seu modelo integrado ao contêiner, poderá criar sua própria imagem.

Primeiro execute uma imagem de serviço como um daemon:

docker run -d --name serving_base tensorflow/serving

Em seguida, copie seu SavedModel para a pasta de modelo do contêiner:

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

Finalmente, cometer o recipiente que está servindo o seu modelo, alterando MODEL_NAME para coincidir com o nome do seu modelo de ` ':

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

Agora você pode parar serving_base

docker kill serving_base

Isso vai deixar você com uma imagem Docker chamado <my container> que você pode implementar e irá carregar o seu modelo para servir na inicialização.

Servindo exemplo

Vamos percorrer um exemplo completo em que carregamos um SavedModel e o chamamos usando a API REST. Primeiro extraia a imagem de veiculação:

docker pull tensorflow/serving

Isso extrairá a imagem mais recente do TensorFlow Serving com o ModelServer instalado.

Em seguida, vamos usar um modelo de brinquedo chamado Half Plus Two , que gera 0.5 * x + 2 para os valores de x que prestamos para a predição.

Para obter este modelo, primeiro clone o repositório TensorFlow Serving.

mkdir -p /tmp/tfserving
cd /tmp/tfserving
git clone https://github.com/tensorflow/serving

Em seguida, execute o contêiner TensorFlow Serving apontando-o para este modelo e abrindo a porta da 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 &

Isso executará o contêiner do docker e iniciará o TensorFlow Serving Model Server, vinculará a porta 8501 da API REST e mapeará nosso modelo desejado de nosso host para onde os modelos são esperados no contêiner. Também passamos o nome do modelo como uma variável de ambiente, o que será importante quando consultarmos o modelo.

Para consultar o modelo usando a API de previsão, você pode executar

curl -d '{"instances": [1.0, 2.0, 5.0]}' \
  -X POST http://localhost:8501/v1/models/half_plus_two:predict

Isso deve retornar um conjunto de valores:

{ "predictions": [2.5, 3.0, 4.5] }

Mais informações sobre o uso da API RESTful pode ser encontrada aqui .

Servindo com Docker usando sua GPU

Instale nvidia-docker

Antes de servir com uma GPU, além de instalar Docker , você vai precisar de:

Up-to-date drivers NVIDIA para o seu sistema
nvidia-docker : Você pode seguir as instruções de instalação aqui

Executando uma imagem de veiculação de GPU

A execução de uma imagem de veiculação da GPU é idêntica à execução de uma imagem da CPU. Para mais detalhes, consulte Execução de uma imagem servindo .

Exemplo de exibição de GPU

Vamos percorrer um exemplo completo em que carregamos um modelo com operações vinculadas à GPU e o chamamos usando a API REST.

Primeiro instale nvidia-docker . Em seguida, você pode extrair a imagem mais recente do TensorFlow Serving GPU docker executando:

docker pull tensorflow/serving:latest-gpu

Isso puxará para baixo uma imagem Docker mínima com ModelServer construído para execução em GPUs instaladas.

Em seguida, vamos usar um modelo de brinquedo chamado Half Plus Two , que gera 0.5 * x + 2 para os valores de x que prestamos para a predição. Este modelo terá ops vinculados ao dispositivo GPU e não funcionará na CPU.

Para obter este modelo, primeiro clone o repositório TensorFlow Serving.

mkdir -p /tmp/tfserving
cd /tmp/tfserving
git clone https://github.com/tensorflow/serving

Em seguida, execute o contêiner TensorFlow Serving apontando-o para este modelo e abrindo a porta da 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 &

Isso executará o contêiner do docker, iniciará o TensorFlow Serving Model Server, vinculará a porta 8501 da API REST e mapeará nosso modelo desejado de nosso host para onde os modelos são esperados no contêiner. Também passamos o nome do modelo como uma variável de ambiente, o que será importante quando consultarmos o modelo.

DICA: antes de consultar o modelo, espere até ver uma mensagem como a seguinte, indicando que o servidor está pronto para receber solicitações:

2018-07-27 00:07:20.773693: I tensorflow_serving/model_servers/main.cc:333]
Exporting HTTP/REST API at:localhost:8501 ...

Para consultar o modelo usando a API de previsão, você pode executar

curl -d '{"instances": [1.0, 2.0, 5.0]}' \
  -X POST http://localhost:8501/v1/models/half_plus_two:predict

Isso deve retornar um conjunto de valores:

{ "predictions": [2.5, 3.0, 4.5] }

DICA: Tentar executar o modelo de GPU em uma máquina sem uma GPU ou sem uma versão de GPU funcional do TensorFlow Model Server resultará em um erro semelhante a:

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

Mais informações sobre o uso da API RESTful pode ser encontrada aqui .

Desenvolvendo com Docker

Para obter instruções sobre como construir e desenvolver Tensorflow Servir, consulte Desenvolvendo com guia Docker .