Criar um app iOS para prever valores

Criar um app iOS para prever valores

Sobre este codelab

Último abr. 8, 2022 atualizado

Escrito por Wei Wei

1. Antes de começar

Neste codelab, você aprenderá a executar uma inferência de regressão a partir de um app iOS usando o TensorFlow Serving com REST e gRPC.

Prerequisites

• Conhecimento básico de desenvolvimento para iOS com Swift
• Conhecimento básico de machine learning com o TensorFlow, como treinamento e implantação
• Conhecimento básico do Colaboratory
• Noções básicas de terminais, Python e Docker

O que você aprenderá

• Como treinar um modelo de regressão com o TensorFlow
• Como criar um app iOS simples e fazer previsões com o modelo treinado pelo TensorFlow Serving (REST e gRPC).
• Como exibir o resultado na IU.

Pré-requisitos

• Acesso ao Colab
• A versão mais recente do Xcode
• CocoaPods
• Docker
• Bash
• Compilador de buffer de protocolo (somente necessário se você quiser gerar o stub do gRPC novamente)
• Plug-in gerador de código gRPC-swift (necessário somente se você quiser gerar o stub do gRPC por conta própria)

Observação:desde março de 2022, o suporte ao M1 para o TensorFlow Serving ainda está em desenvolvimento. Por isso, não é possível executá-lo em um Mac M1. No entanto, você ainda poderá executar o app para iOS em um Mac M1.

2. Começar a configuração

Para fazer o download do código para este codelab, faça o seguinte:

1. Navegue até o repositório do GitHub deste codelab.
2. Clique em Code > Download zip para fazer o download de todo o código para este codelab.

3. Descompacte o arquivo ZIP baixado para descompactar uma pasta raiz codelabs com todos os recursos necessários.

Neste codelab, você só precisará dos arquivos no subdiretório TFServing/RegressioniOS do repositório, que contém duas pastas:

• A pasta starter contém o código inicial que você usará como base para este codelab.
• A pasta finished contém o código concluído do app de exemplo finalizado.

3. Fazer o download das dependências do projeto

Faça o download dos pods necessários

• Na pasta starter/iOS, execute:

pod install

O Cocoapods instalará todas as bibliotecas necessárias e gerará um novo arquivo regression.xcworkspace.

4. Executar o app inicial

• Clique duas vezes no arquivo regression.xcworkspace para abrir o Xcode.

Observação:este codelab pressupõe que você usa o Simulator. Se você usa um iPhone físico, mude localhost no código para o endereço IP do seu servidor, que executa o TensorFlow Serving.

Executar e explorar o app

1. Altere a segmentação por dispositivo para qualquer iPhone, como o iPhone 13.

2. Clique em 'Run' e aguarde o Xcode compilar o projeto e iniciar o app inicial no Simulator.

Observação:durante a compilação, o Xcode emite diversos avisos sobre as bibliotecas CNIOBoringSSL e gRPC-Swift. É possível ignorá-las.

A IU é bem direta. Há uma caixa de texto em que você pode digitar um número, que é enviado ao back-end do TensorFlow Serving com REST ou gRPC. O back-end realiza a regressão no valor de entrada e retorna o valor previsto para o app cliente, que exibe o resultado na IU novamente.

Se você inserir um número e clicar em Inferir, nada acontecerá porque o app ainda não poderá se comunicar com o back-end.

5. Treinar um modelo de regressão simples com o TensorFlow

A regressão é uma das tarefas mais comuns. O objetivo é prever uma única quantidade contínua com base na entrada. Por exemplo, com base na previsão do tempo para hoje, faça a previsão da temperatura mais alta amanhã.

Treinar um modelo de regressão

1. Abra este link no navegador.

O Colab carrega o notebook Python.

2. No notebook Python, importe as bibliotecas TensorFlow e NumPy e crie seis pares de dados de treinamento com xs como entrada e ys como rótulos.

Se você plotar esses pontos de dados em um gráfico, eles serão posicionados em uma linha reta porque são gerados pela equação y = 2x -1.

3. Use a API Keras para criar uma rede neural de duas camadas simples e prever o valor de y com base na entrada de x. Depois, compile e ajuste o modelo.

xs = np.array([-1.0,  0.0, 1.0, 2.0, 3.0, 4.0], dtype=float)
ys = np.array([-3.0, -1.0, 1.0, 3.0, 5.0, 7.0], dtype=float)

model = tf.keras.Sequential([
   tf.keras.layers.Dense(units=10, input_shape=[1]),
   tf.keras.layers.Dense(units=1),
   ])

model.compile(optimizer='sgd',
             loss='mean_squared_error')

history = model.fit(xs, ys, epochs=500, verbose=0)

print("Finished training the model")

print(model.predict([10.0]))

O treinamento do modelo pode levar alguns segundos, e o valor previsto para a entrada 10 é 18.999996, o que é uma boa previsão, já que a verdade é 2 * 10 -1 = 19.

4. Exporte o modelo:

model_dir = './regression/'
version = 123
export_path = os.path.join(model_dir, str(version))
model.save(export_path, save_format="tf")
print('\nexport_path = {}'.format(export_path))
!ls -l {export_path}

5. Compacte o SavedModel exportado em um único arquivo regression.zip:

!zip -r regression.zip ./regression

6. Clique em Runtime > Run all no menu de navegação para executar o notebook e depois esperar a execução ser concluída.
7. Clique em Arquivos e faça o download do regression.zip.

6. Implantar um modelo de regressão com o TensorFlow Serving

• Para implantar o modelo com o TensorFlow Serving, descompacte o arquivo regression.zip com uma ferramenta de descompactação, como o 7-Zip.

A estrutura de pasta será semelhante a esta imagem:

Você pode se referir à pasta regression como a pasta SavedModel. 123 é um exemplo de número da versão. Se quiser, você pode escolher outro número.

Iniciar o TensorFlow Serving

• No seu terminal, inicie o TensorFlow Serving com o Docker, mas substitua o marcador PATH/TO/SAVEDMODEL pelo caminho absoluto da pasta regression no seu computador.

docker pull tensorflow/serving

docker run -it --rm -p 8500:8500 -p 8501:8501 -v "PATH/TO/SAVEDMODEL:/models/regression" -e MODEL_NAME=regression tensorflow/serving

Primeiro, o Docker faz o download automático da imagem do TensorFlow Serving em um minuto. Depois disso, o TensorFlow Serving será iniciado. O registro será semelhante a este snippet de código:

2022-02-25 06:01:12.513231: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:206] Restoring SavedModel bundle.
2022-02-25 06:01:12.585012: I external/org_tensorflow/tensorflow/core/platform/profile_utils/cpu_utils.cc:114] CPU Frequency: 3000000000 Hz
2022-02-25 06:01:13.395083: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:190] Running initialization op on SavedModel bundle at path: /models/ssd_mobilenet_v2_2/123
2022-02-25 06:01:13.837562: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:277] SavedModel load for tags { serve }; Status: success: OK. Took 1928700 microseconds.
2022-02-25 06:01:13.877848: I tensorflow_serving/servables/tensorflow/saved_model_warmup_util.cc:59] No warmup data file found at /models/ssd_mobilenet_v2_2/123/assets.extra/tf_serving_warmup_requests
2022-02-25 06:01:13.929844: I tensorflow_serving/core/loader_harness.cc:87] Successfully loaded servable version {name: regression version: 123}
2022-02-25 06:01:13.985848: I tensorflow_serving/model_servers/server_core.cc:486] Finished adding/updating models
2022-02-25 06:01:13.985987: I tensorflow_serving/model_servers/server.cc:367] Profiler service is enabled
2022-02-25 06:01:13.988994: I tensorflow_serving/model_servers/server.cc:393] Running gRPC ModelServer at 0.0.0.0:8500 ...
[warn] getaddrinfo: address family for nodename not supported
2022-02-25 06:01:14.033872: I tensorflow_serving/model_servers/server.cc:414] Exporting HTTP/REST API at:localhost:8501 ...
[evhttp_server.cc : 245] NET_LOG: Entering the event loop ...

Observação: depois de iniciar a imagem de docker do TensorFlow Serving, acesse http://localhost:8501/v1/models/<MODEL_NAME>/metadata para inspecionar os detalhes dos tensores de entrada e saída. Neste codelab, substitua <MODEL_NAME> por regression.

7. Conectar o app para iOS ao TensorFlow Serving por meio do REST

O back-end está pronto. Assim, você pode enviar solicitações de cliente ao TensorFlow Serving para fazer previsões. Há duas maneiras de enviar solicitações ao TensorFlow Serving:

• REST
• gRPC

Enviar solicitações e receber respostas com REST

Há três etapas simples:

1. Crie a solicitação REST.
2. Envie a solicitação REST para o TensorFlow Serving.
3. Extraia o resultado previsto da resposta REST e renderize a IU.

Você realiza essas etapas no arquivo iOS/regression/ViewController.swift.

Criar a solicitação REST

1. No momento, a função doInference() não envia a solicitação REST para o TensorFlow Serving. Você precisa implementar essa ramificação de REST para criar uma solicitação REST:

if (connectionMode[picker.selectedRow(inComponent: 0)] == "REST") {
    print("Using REST")
    // TODO: Add code to send a REST request to TensorFlow Serving.

}

O TensorFlow Serving espera uma solicitação POST que contenha um valor único. Portanto, você precisa incorporar o valor de entrada em um JSON, que é o payload da solicitação.

2. Adicione este código à ramificação REST:

//Create the REST request.
let json: [String: Any] = ["signature_name" : "serving_default", "instances" : [[value]]]

let jsonData = try? JSONSerialization.data(withJSONObject: json)

let url = URL(string: "http://localhost:8501/v1/models/regression:predict")!
var request = URLRequest(url: url)
request.httpMethod = "POST"

// Insert JSON data into the request.
request.httpBody = jsonData

Enviar a solicitação REST para o TensorFlow Serving

• Adicione este código imediatamente após o código na ramificação REST:

// Send the REST request.
let task = URLSession.shared.dataTask(with: request) { data, response, error in
    guard let data = data, error == nil else {
        print(error?.localizedDescription ?? "No data")
        return
    }

    // TODO: Add code to process the response.
}

task.resume()

Processar a resposta REST do TensorFlow Serving

• Adicione este código ao snippet de código anterior imediatamente após o comentário TODO: Add code to process the response.:

// Process the REST response.
let results: RESTResults = try! JSONDecoder().decode(RESTResults.self, from: data)
DispatchQueue.main.async{
    self.txtOutput.text = String(results.predictions[0][0])
}

Agora, a função de pós-processamento extrai os valores previstos da resposta e exibe o resultado na IU.

Executar

1. Clique em Run e aguarde o Xcode iniciar o app no Simulator.
2. Insira um número na caixa de texto e clique em Inferir.

Agora você verá um valor previsto na IU.

8. Conectar o app para iOS ao TensorFlow Serving por meio do gRPC

Além do REST, o TensorFlow Serving também é compatível com o gRPC.

O gRPC é um framework de chamada de procedimento remoto (RPC) moderno, de código aberto e de alta performance que pode ser executado em qualquer ambiente. Ele pode conectar serviços de forma eficiente em data centers e com compatibilidade conectável para balanceamento de carga, rastreamento, verificação de integridade e autenticação. Observamos que o gRPC tem uma performance melhor do que o REST na prática.

Enviar solicitações e receber respostas com o gRPC

Há quatro etapas simples:

1. Opcional: gerar o código stub do cliente gRPC
2. Criar a solicitação gRPC
3. Enviar a solicitação gRPC para o TensorFlow Serving
4. Extrair o resultado previsto da resposta gRPC e renderizar a IU

Você realiza essas etapas no arquivo iOS/regression/ViewController.swift.

Opcional: gerar o código stub do cliente gRPC

Observação: esta etapa é opcional porque o código inicial já inclui o código stub do cliente gRPC. No entanto, se você quiser gerar o stub do cliente por conta própria, leia esta etapa para entender o processo. Verifique se você configurou corretamente o compilador de buffer de protocolo e o plug-in do gerador de código Swift do gRPC, caso faça um teste.

Para usar o gRPC com o TensorFlow Serving, é necessário seguir o fluxo de trabalho do gRPC. Caso queira saber mais, consulte a documentação do gRPC.

O TensorFlow Serving e o TensorFlow definem os arquivos .proto automaticamente. No TensorFlow e no TensorFlow Serving 2.8, os seguintes arquivos .proto são necessários:

tensorflow/core/example/example.proto
tensorflow/core/example/feature.proto
tensorflow/core/protobuf/struct.proto
tensorflow/core/protobuf/saved_object_graph.proto
tensorflow/core/protobuf/saver.proto
tensorflow/core/protobuf/trackable_object_graph.proto
tensorflow/core/protobuf/meta_graph.proto
tensorflow/core/framework/node_def.proto
tensorflow/core/framework/attr_value.proto
tensorflow/core/framework/function.proto
tensorflow/core/framework/types.proto
tensorflow/core/framework/tensor_shape.proto
tensorflow/core/framework/full_type.proto
tensorflow/core/framework/versions.proto
tensorflow/core/framework/op_def.proto
tensorflow/core/framework/graph.proto
tensorflow/core/framework/tensor.proto
tensorflow/core/framework/resource_handle.proto
tensorflow/core/framework/variable.proto

tensorflow_serving/apis/inference.proto
tensorflow_serving/apis/classification.proto
tensorflow_serving/apis/predict.proto
tensorflow_serving/apis/regression.proto
tensorflow_serving/apis/get_model_metadata.proto
tensorflow_serving/apis/input.proto
tensorflow_serving/apis/prediction_service.proto
tensorflow_serving/apis/model.proto

Para gerar o código de stub do cliente gRPC:

1. No terminal, navegue até a pasta starter/src/proto/ e gere o stub:

bash generate_grpc_stub_swift.sh

Vários arquivos .swift são gerados na pasta starter/src/proto/generated/import.

2. Se eles ainda não foram copiados para o projeto, arraste todos os arquivos .swift gerados para o projeto no Xcode.

Criar a solicitação gRPC

Semelhante à solicitação REST, você cria a solicitação gRPC na ramificação gRPC.

if (connectionMode[picker.selectedRow(inComponent: 0)] == "REST") {

}
else {
    print("Using gRPC")
    // TODO: add code to send a gRPC request to TF Serving

}

• Para criar a solicitação gRPC, adicione este código à ramificação gRPC:

//Create the gRPC request.
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
let channel = ClientConnection.insecure(group: group).connect(host: "localhost", port: 8500)
let stub = Tensorflow_Serving_PredictionServiceClient(channel: channel)

var modelSpec = Tensorflow_Serving_ModelSpec()
modelSpec.name = "regression"
modelSpec.signatureName = "serving_default"

// Prepare the input tensor.
var batchDim = Tensorflow_TensorShapeProto.Dim()
batchDim.size = 1
var inputDim = Tensorflow_TensorShapeProto.Dim()
inputDim.size = 1
var inputTensorShape = Tensorflow_TensorShapeProto()
inputTensorShape.dim = [batchDim, inputDim]
var inputTensor = Tensorflow_TensorProto()
inputTensor.dtype = Tensorflow_DataType.dtFloat
inputTensor.tensorShape = inputTensorShape
inputTensor.floatVal = [Float(value)]

var request = Tensorflow_Serving_PredictRequest()
request.modelSpec = modelSpec
request.inputs = ["dense_input" : inputTensor]

let callOptions = CallOptions(timeLimit: .timeout(.seconds(15)))

Enviar a solicitação gRPC para o TensorFlow Serving

• Adicione este código à ramificação do gRPC imediatamente após o código no snippet de código anterior:

// Send the gRPC request.
let call = stub.predict(request, callOptions: callOptions)

Processar a resposta gRPC do TensorFlow Serving

• Adicione este código imediatamente após o no snippet de código anterior:

// Process the response.
call.response.whenSuccess { response in
    let result = response.outputs["dense_1"]?.floatVal[0]
    DispatchQueue.main.async{
        self.txtOutput.text = String(describing: result!)
    }
}
call.response.whenFailure { error in
    print("Call failed with error\n\(error)")
}

Agora, a função de pós-processamento extrai os valores previstos da resposta e exibe o resultado na IU.

Executar

1. Clique em Run no menu de navegação e aguarde o Xcode iniciar o app no Simulator.
2. Insira um número na caixa de texto e clique em Inferir.

Agora você verá um valor previsto na IU.

9. Parabéns

Você usou o TensorFlow Serving para adicionar recursos de regressão ao seu app.

Saiba mais

• Página inicial do TensorFlow Serving
• Página inicial do gRPC
• Regressão básica: previsão de eficiência de combustível