Esta página foi traduzida pela API Cloud Translation.

Servindo um modelo do TensorFlow

Este tutorial mostra como usar os componentes do TensorFlow Serving para exportar um modelo TensorFlow treinado e usar o tensorflow_model_server padrão para servi-lo. Se você já está familiarizado com TensorFlow Servir, e você quer saber mais sobre como os internos de servidores trabalhar, ver a TensorFlow Servindo tutorial avançado .

Este tutorial usa um modelo simples de Regressão Softmax que classifica dígitos manuscritos. É muito semelhante ao apresentado no tutorial TensorFlow na classificação de imagens usando o conjunto de dados Moda MNIST .

O código para este tutorial consiste em duas partes:

Um arquivo Python, mnist_saved_model.py , que treina e exportações do modelo.
Um ModelServer binário que pode ser instalado quer usando Apt, ou compilada a partir de um arquivo de C ++ ( main.cc ). Os TensorFlow Servindo descobre ModelServer novo modelos exportados e executa um gRPC serviço para servi-los.

Antes de começar, primeiro instalar Docker .

Treinar e exportar o modelo do TensorFlow

Para a fase de formação, o gráfico TensorFlow é lançado em TensorFlow sessão sess , com o tensor de entrada (imagem) como x e tensor de saída (pontuação Softmax) como y .

Então nós usamos de TensorFlow módulo SavedModelBuilder para exportar o modelo. SavedModelBuilder salva um "instantâneo" do modelo treinado para armazenamento confiável para que ele possa ser carregado mais tarde para inferência.

Para mais detalhes sobre o formato SavedModel, consulte a documentação no SavedModel README.md .

De mnist_saved_model.py , o seguinte é um trecho de código curto para ilustrar o processo geral de salvar um modelo para o disco.

export_path_base = sys.argv[-1]
export_path = os.path.join(
    tf.compat.as_bytes(export_path_base),
    tf.compat.as_bytes(str(FLAGS.model_version)))
print('Exporting trained model to', export_path)
builder = tf.saved_model.builder.SavedModelBuilder(export_path)
builder.add_meta_graph_and_variables(
    sess, [tf.compat.v1.saved_model.tag_constants.SERVING],
    signature_def_map={
        'predict_images':
            prediction_signature,
        tf.compat.v1.saved_model.signature_constants
            .DEFAULT_SERVING_SIGNATURE_DEF_KEY:
            classification_signature,
    },
    main_op=tf.compat.v1.tables_initializer(),
    strip_default_attrs=True)
builder.save()

SavedModelBuilder.__init__ leva o seguinte argumento:

export_path é o caminho do diretório de exportação.

SavedModelBuilder irá criar o diretório se ele não existir. No exemplo, nós concatenar o argumento de linha de comando e FLAGS.model_version para obter o diretório de exportação. FLAGS.model_version especifica a versão do modelo. Você deve especificar um valor inteiro maior ao exportar uma versão mais recente do mesmo modelo. Cada versão será exportada para um subdiretório diferente no caminho fornecido.

Você pode adicionar gráfico meta e variáveis para o construtor usando SavedModelBuilder.add_meta_graph_and_variables() com os seguintes argumentos:

sess é a sessão TensorFlow que mantém o modelo treinado você está exportando.
tags é o conjunto de tags com o qual salvar o gráfico meta. Neste caso, uma vez que temos a intenção de usar o gráfico em servir, usamos a serve tag de constantes tag SavedModel predefinidos. Para mais detalhes, consulte tag_constants.py e TensorFlow relacionado documentação da API .
signature_def_map especifica o mapa de de chave fornecida pelo usuário para uma assinatura a uma tensorflow :: SignatureDef para adicionar ao gráfico meta. A assinatura especifica que tipo de modelo está sendo exportado e os tensores de entrada/saída para vincular ao executar a inferência.
Os especiais chave de assinatura serving_default Especifica o padrão que serve de assinatura. A chave def de assinatura de serviço padrão, juntamente com outras constantes relacionadas a assinaturas, são definidas como parte das constantes de assinatura SavedModel. Para mais detalhes, consulte signature_constants.py e TensorFlow relacionado documentação da API .
Além disso, para ajudar a assinatura construção defs facilmente, a API SavedModel fornece utils def assinatura .. Especificamente, no original mnist_saved_model.py arquivo, usamos signature_def_utils.build_signature_def() para construir predict_signature e classification_signature .
Como um exemplo de como predict_signature é definido, o util leva os seguintes argumentos:
- inputs={'images': tensor_info_x} especifica a entrada de informações do tensor.
- outputs={'scores': tensor_info_y} especifica a pontuação tensor info.
- method_name é o método utilizado para a inferência. Para pedidos de previsão, que deve ser definido como tensorflow/serving/predict . Para outros nomes de métodos, ver signature_constants.py e TensorFlow relacionado documentação da API .

Note-se que tensor_info_x e tensor_info_y têm a estrutura de tensorflow::TensorInfo protocolo de tampão definido aqui . Para construir facilmente tensor informações sobre a API TensorFlow SavedModel também fornece utils.py , com documentação TensorFlow API relacionado .

Além disso, nota que images e scores são nomes de alias tensor. Eles podem ser o que cordas única que você quer, e eles vão se tornar os nomes lógicos de tensor x e y que você consulte para a ligação ao enviar solicitações de previsão mais tarde tensor.

Por exemplo, se x refere-se ao tensor com o nome 'long_tensor_name_foo' e y refere-se ao tensor com o nome 'generated_tensor_name_bar', builder irá armazenar tensor nome lógico para o nome real de mapeamento ( 'imagens' -> 'long_tensor_name_foo') e ( 'pontuação ' -> 'generated_tensor_name_bar'). Isso permite que o usuário se refira a esses tensores com seus nomes lógicos ao executar a inferência.

Vamos executá-lo!

Primeiro, se você ainda não fez isso, clone este repositório para sua máquina local:

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

Limpe o diretório de exportação se ele já existir:

rm -rf /tmp/mnist

Agora vamos treinar o modelo:

tools/run_in_docker.sh python tensorflow_serving/example/mnist_saved_model.py \
  /tmp/mnist

Isso deve resultar em uma saída parecida com:

Training model...

...

Done training!
Exporting trained model to models/mnist
Done exporting!

Agora vamos dar uma olhada no diretório de exportação.

$ ls /tmp/mnist
1

Conforme mencionado acima, será criado um subdiretório para exportar cada versão do modelo. FLAGS.model_version tem o valor padrão de 1, portanto, o sub-diretório correspondente 1 é criado.

$ ls /tmp/mnist/1
saved_model.pb variables

Cada subdiretório de versão contém os seguintes arquivos:

saved_model.pb é o tensorflow serializado :: SavedModel. Inclui uma ou mais definições de gráfico do modelo, bem como metadados do modelo, como assinaturas.
variables são arquivos que armazenam as variáveis serializados dos gráficos.

Com isso, seu modelo do TensorFlow é exportado e pronto para ser carregado!

Carregar modelo exportado com TensorFlow ModelServer padrão

Use uma imagem de veiculação do Docker para carregar facilmente o modelo para veiculação:

docker run -p 8500:8500 \
--mount type=bind,source=/tmp/mnist,target=/models/mnist \
-e MODEL_NAME=mnist -t tensorflow/serving &

Teste o servidor

Podemos usar o fornecido mnist_client utilitário para testar o servidor. O cliente baixa os dados de teste MNIST, os envia como solicitações ao servidor e calcula a taxa de erro de inferência.

tools/run_in_docker.sh python tensorflow_serving/example/mnist_client.py \
  --num_tests=1000 --server=127.0.0.1:8500

Isso deve gerar algo como

    ...
    Inference error rate: 11.13%

Esperamos cerca de 90% de precisão para o modelo Softmax treinado e obtemos uma taxa de erro de inferência de 11% para as primeiras 1.000 imagens de teste. Isso confirma que o servidor carrega e executa o modelo treinado com sucesso!