Servindo TensorFlow com Docker

Uma das maneiras mais fáceis de começar a usar o TensorFlow Serving é com o 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 endpoints de serviço adicionais, consulte a API REST do cliente .

Instale o Docker

As instruções gerais de instalação estão no site do Docker , mas damos alguns links rápidos aqui:

• Docker para macOS
• Docker para Windows para Windows 10 Pro ou posterior
• Docker Toolbox para versões muito mais antigas do macOS ou versões do Windows anteriores ao Windows 10 Pro

Servindo com Docker

Extraindo uma imagem de veiculação

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

docker pull tensorflow/serving

Isso extrairá uma imagem mínima do Docker com o TensorFlow Serving instalado.

Consulte o repositório tensorflow/serving do Docker Hub para outras versões de imagens que você pode extrair.

Executando uma imagem de veiculação

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

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

Quando a imagem de serviço executa o ModelServer, ela é executada 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 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ê fará é executar o contêiner Docker , publicar as portas do contêiner nas portas do seu host e montar o caminho do seu host no SavedModel para onde o contêiner 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

Nesse caso, iniciamos um contêiner Docker, publicamos a porta 8501 da API REST na porta 8501 do nosso host e pegamos um modelo que chamamos de my_model e o vinculamos ao caminho base do modelo padrão ( ${MODEL_BASE_PATH}/${MODEL_NAME} = /models/my_model ). Finalmente, preenchemos a variável de ambiente MODEL_NAME com my_model e deixamos MODEL_BASE_PATH com 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 a 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 outra.

Passando argumentos adicionais

tensorflow_model_server oferece suporte a muitos argumentos adicionais que você pode passar para os contêineres docker de serviço. 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 de linha de comando suportados por tensorflow_model_server .

Criando sua própria imagem de veiculação

Se quiser uma imagem de veiculação que tenha seu modelo integrado ao contêiner, você 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>

Por fim, confirme o contêiner que está atendendo ao seu modelo alterando MODEL_NAME para corresponder ao nome do seu modelo ` ':

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

Agora você pode parar serving_base

docker kill serving_base

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

Exemplo de serviço

Vejamos um exemplo completo onde 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.

A seguir, usaremos um modelo de brinquedo chamado Half Plus Two , que gera 0.5 * x + 2 para os valores de x que fornecemos para previsão.

Para obter esse 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 REST API (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 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

Nota: Versões mais antigas do Windows e outros sistemas sem curl podem baixá-lo aqui .

Isso deve retornar um conjunto de valores:

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

Mais informações sobre como usar a API RESTful podem ser encontradas aqui .

Servindo com Docker usando sua GPU

Instale nvidia-docker

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

• Drivers NVIDIA atualizados para o seu sistema
• nvidia-docker : Você pode seguir as instruções de instalação aqui

Executando uma imagem de serviço de GPU

A execução de uma imagem de serviço de GPU é idêntica à execução de uma imagem de CPU. Para obter mais detalhes, consulte executando uma imagem de veiculação .

Exemplo de serviço de GPU

Vejamos 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 obter a imagem mais recente do docker da GPU do TensorFlow Serving executando:

docker pull tensorflow/serving:latest-gpu

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

A seguir, usaremos um modelo de brinquedo chamado Half Plus Two , que gera 0.5 * x + 2 para os valores de x que fornecemos para previsão. Este modelo terá operações vinculadas ao dispositivo GPU e não será executado na CPU.

Para obter esse 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 REST API (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 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

Nota: Versões mais antigas do Windows e outros sistemas sem curl podem baixá-lo aqui .

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 GPU ou sem uma compilaçã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 como usar a API RESTful podem ser encontradas aqui .

Desenvolvendo com Docker

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