Esta página foi traduzida pela API Cloud Translation.
Switch to English

TensorFlow Serving 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 pontos de extremidade de serviço adicionais, consulte Client REST API .

Instale o Docker

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

Servindo com Docker

Puxando uma imagem de serviço

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

docker pull tensorflow/serving

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

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

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
  • 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 veiculada executa 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 Docker, você precisará:

  • 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 para o SavedModel onde o contêiner espera os 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, iniciamos um contêiner Docker, publicamos a porta REST API 8501 na porta 8501 do nosso host e pegamos um modelo que chamamos de my_model e o my_model 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 abrir as portas gRPC e REST API ao mesmo tempo ou optar por abrir apenas uma ou a outra.

Passando argumentos adicionais

tensorflow_model_server suporta muitos argumentos adicionais que você pode passar para os contêineres docker de serviço. Por exemplo, se quisermos 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 que tensorflow_model_server suporta.

Criar sua própria imagem de serviço

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

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 puxará a imagem do TensorFlow Serving mais recente 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 a previsã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 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á:

Executar 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 a execução de uma imagem de veiculação .

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 o nvidia-docker . Em seguida, você pode extrair a imagem mais recente do docker de GPU do TensorFlow Serving 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.

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 a previsã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 --runtime=nvidia -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 com o tempo de execução nvidia-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 como usar a API RESTful podem ser encontradas aqui .

Desenvolvendo com Docker

Para obter instruções sobre como criar e desenvolver o Tensorflow Serving, consulte o guia Developing with Docker .