Introdução
Este projeto foi concebido para guiá-lo através do processo de criação de um modelo TensorFlow simples, exportá-lo e, em seguida, servi-lo usando Docker e TensorFlow Serving. TensorFlow é um framework de machine learning de código aberto, e TensorFlow Serving é um sistema de serviço flexível e de alto desempenho para modelos de machine learning. Contêineres Docker facilitam o empacotamento e a implantação consistente desses modelos. Ao final deste projeto, você entenderá como configurar um modelo básico de machine learning em TensorFlow, exportá-lo para serviço e implantá-lo usando TensorFlow Serving dentro de um contêiner Docker.
👀 Pré-visualização
## Enviar uma solicitação de predição para o contêiner TensorFlow Serving
curl -X POST \
http://localhost:9501/v1/models/half_plus_two:predict \
-d '{"signature_name":"serving_default","instances":[[1.0], [2.0], [5.0]]}'
Saída:
{
"predictions": [[2.5], [3.0], [4.5]
]
}
🎯 Tarefas
Neste projeto, você aprenderá:
- Como instalar as dependências do TensorFlow e TensorFlow Serving
- Como criar um modelo TensorFlow simples para operações aritméticas básicas
- Como exportar o modelo em um formato adequado para servir com TensorFlow Serving
- Como servir o modelo usando Docker e TensorFlow Serving
- Como enviar solicitações de predição para o modelo implantado e receber predições
🏆 Conquistas
Após concluir este projeto, você será capaz de:
- Configurar um modelo básico de machine learning em TensorFlow
- Exportar um modelo TensorFlow para serviço
- Implantar um modelo TensorFlow usando Docker e TensorFlow Serving
- Enviar solicitações de predição para o modelo implantado e observar os resultados
Instalar Dependências
Antes de começar, você precisa instalar o TensorFlow no seu ambiente. Além disso, você puxará a imagem do TensorFlow Serving do Docker Hub para se preparar para servir seu modelo em um ambiente em contêiner. Execute os seguintes comandos no seu terminal.
Instalar TensorFlow:
## Install TensorFlow
pip install tensorflow==2.14.0
## Downgrade numpy to 1.26.4 to avoid compatibility issues with TensorFlow
pip install numpy==1.26.4
Puxar a imagem Docker do TensorFlow Serving:
## Pull TensorFlow Serving image from Docker Hub
docker pull tensorflow/serving
Nesta etapa, você instalou o TensorFlow, uma biblioteca poderosa para computação numérica e machine learning, e então puxou a imagem Docker do TensorFlow Serving.
TensorFlow Serving é projetado especificamente para servir modelos de machine learning em ambientes de produção. Usar o Docker garante que o TensorFlow Serving seja executado em um ambiente isolado com todas as suas dependências atendidas, evitando assim conflitos com outros softwares em sua máquina.
Criar e Exportar Seu Modelo
Nesta etapa, você definirá um modelo TensorFlow simples que realiza uma operação aritmética básica: multiplicar sua entrada por 0,5 e, em seguida, adicionar 2. Após definir o modelo, você o exportará para um formato que o TensorFlow Serving possa usar.
Crie e exporte o modelo em ~/project/half_plus_two.py:
## Import TensorFlow
import tensorflow as tf
## Define a simple Sequential model
model = tf.keras.Sequential([
tf.keras.layers.Dense(units=1, input_shape=[1], use_bias=True)
])
## Set the weights to achieve the "multiply by 0.5 and add 2" functionality
weights = [tf.constant([[0.5]]), tf.constant([2.0])]
model.set_weights(weights)
## Compile the model (required even if not training)
model.compile(optimizer='sgd', loss='mean_squared_error')
## Export the model to a SavedModel
export_path = './saved_model_half_plus_two/1'
tf.saved_model.save(model, export_path)
Esta etapa envolve a definição de um modelo TensorFlow que realiza uma operação simples em sua entrada: multiplicar por 0,5 e adicionar 2. O modelo é então exportado para um formato adequado para servir.
- O modelo é definido usando a API Keras do TensorFlow, que é uma API de alto nível para construir e treinar modelos de deep learning. O modelo consiste em uma única camada densa, que é uma camada de rede neural totalmente conectada.
- Os pesos do modelo são definidos manualmente para alcançar a operação desejada (multiplicar por 0,5 e adicionar 2).
- Mesmo que este modelo não seja treinado posteriormente, ele é compilado para finalizar sua estrutura, que é uma etapa necessária no TensorFlow.
- Finalmente, o modelo é salvo no formato TensorFlow SavedModel, que é um diretório contendo um arquivo protobuf e um checkpoint TensorFlow contendo os pesos do modelo. Este formato é exigido pelo TensorFlow Serving para a implantação do modelo.
Para exportar o modelo, execute o script no terminal:
python half_plus_two.py
O modelo é salvo em ~/project/saved_model_half_plus_two, e a estrutura do arquivo é a seguinte:
.
└── saved_model_half_plus_two
└── 1
├── assets
├── fingerprint.pb
├── saved_model.pb
└── variables
├── variables.data-00000-of-00001
└── variables.index
Servir o Modelo Usando Docker e TensorFlow Serving
Após exportar o modelo, a próxima etapa é servi-lo usando o TensorFlow Serving dentro de um contêiner Docker. Isso permite que seu modelo seja acessível através de uma rede e possa responder a solicitações de predição.
Sirva o modelo com Docker no terminal:
## Serve the model using TensorFlow Serving in a Docker container
docker run -t --rm -p 9500:8500 -p 9501:8501 \
-v "/home/labex/project/saved_model_half_plus_two:/models/half_plus_two" \
-e MODEL_NAME=half_plus_two \
tensorflow/serving
Nesta etapa, o modelo exportado é servido usando o TensorFlow Serving dentro de um contêiner Docker. O comando docker run inicia uma instância do TensorFlow Serving e disponibiliza o modelo para solicitações de inferência.
- As flags
-pmapeiam as portas do contêiner Docker para sua máquina host, permitindo que você envie solicitações para o servidor de modelos TensorFlow Serving de sua máquina local. - A flag
-vmonta um volume de sua máquina host para o contêiner Docker, tornando o modelo exportado disponível para o TensorFlow Serving. - A variável de ambiente
-e MODEL_NAMEinforma ao TensorFlow Serving o nome do modelo a ser servido.
Esta configuração encapsula o ambiente de serviço do modelo, garantindo que ele seja executado de forma consistente, independentemente de onde for implantado.
Enviar uma Solicitação de Previsão ao Seu Modelo
Finalmente, você testará o modelo implantado enviando uma solicitação de predição. Esta solicitação pedirá ao modelo que aplique sua lógica (multiplicar por 0,5 e adicionar 2) a um conjunto de valores de entrada.
Envie uma solicitação de predição em outro terminal novo:
## Send a prediction request to the TensorFlow Serving container
curl -X POST \
http://localhost:9501/v1/models/half_plus_two:predict \
-d '{"signature_name":"serving_default","instances":[[1.0], [2.0], [5.0]]}'
Output:
{
"predictions": [[2.5], [3.0], [4.5]
]
}
Esta etapa final envolve testar o modelo implantado enviando uma solicitação HTTP POST. Esta solicitação inclui uma carga útil JSON com instâncias para as quais as predições são necessárias.
- O comando
curlé usado para enviar uma solicitação POST para o servidor TensorFlow Serving. A URL especifica o modelo e o endpoint da API de predição. - A flag
-dfornece os dados para a solicitação de predição em formato JSON. A chavesignature_nameespecifica a assinatura de serviço a ser usada, que é uma maneira de informar ao TensorFlow Serving qual grafo computacional executar. A chaveinstancescontém os dados de entrada para a predição.
A resposta do servidor inclui as predições feitas pelo modelo nas instâncias de entrada fornecidas, demonstrando que o modelo foi implantado com sucesso e está servindo predições.
Resumo
Neste projeto, você aprendeu como criar um modelo TensorFlow simples, exportá-lo para servir e implantá-lo usando TensorFlow Serving e Docker. Você começou instalando as dependências necessárias, depois definiu e exportou um modelo básico. Em seguida, você serviu o modelo usando TensorFlow Serving dentro de um contêiner Docker e o testou enviando uma solicitação de predição. Este fluxo de trabalho é uma habilidade fundamental para implantar modelos de aprendizado de máquina de forma escalável e reproduzível.
