1. Antes de começar
No codelab anterior, você criou um app para Android e iOS que usou um modelo básico de rotulagem de imagens que reconhece várias centenas de classes de imagem. Ele reconheceu a imagem de uma flor de forma bastante genérica: vendo pétalas, flor, planta e céu.
Para atualizar o app e reconhecer flores, margaridas ou rosas específicas, por exemplo, você vai precisar de um modelo personalizado treinado com vários exemplos de cada tipo de flor que quer reconhecer.
Pré-requisitos
- O codelab anterior deste programa de aprendizado.
O que você vai criar e aprender
- Como treinar um modelo personalizado do classificador de imagens usando o TensorFlow Lite Model Maker.
O que é necessário
- Não é necessário nenhum hardware específico. Tudo pode ser concluído usando o Google Colab no navegador.
2. Começar
Todo o código a ser acompanhado foi preparado e está disponível para execução no Google Colab aqui. Se você não tiver acesso ao Google Colab, clone o repositório e use o notebook chamado CustomImageClassifierModel.ipynb, que pode ser encontrado no diretório ImageClassificationMobile->colab.
Se você tiver muitos exemplos de flores específicas, é relativamente fácil treinar um modelo com o TensorFlow Lite Model maker para reconhecê-las.
A maneira mais fácil de fazer isso é criando um arquivo .zip ou .tgz com as imagens, classificadas em diretórios. Por exemplo, se você usar imagens de margaridas, dentes-de-leão, rosas, girassóis e tulipas, poderá organizá-las em diretórios como estes:
Compacte-o e hospede-o em um servidor para treinar modelos com ele. Você vai usar uma que já foi preparada para você no restante deste laboratório.
Neste laboratório, presumimos que você esteja usando o Google Colab para treinar o modelo. Acesse o Colab em colab.research.google.com. Se estiver usando outro ambiente, talvez você tenha que instalar muitas dependências, não apenas o TensorFlow.
3. Instalar e importar dependências
- Instalar o TensorFlow Lite Model Maker. Para isso, use um pip install. O &> /dev/null at the end just suppresses the output. O Model Maker gera muitas coisas que não são imediatamente relevantes. Ele foi suprimido para que você possa se concentrar na tarefa em mãos.
# Install Model maker
!pip install -q tflite-model-maker &> /dev/null
- Depois, importe as bibliotecas necessárias e verifique se está usando o TensorFlow 2.x:
# Imports and check that we are using TF2.x
import numpy as np
import os
from tflite_model_maker import configs
from tflite_model_maker import ExportFormat
from tflite_model_maker import model_spec
from tflite_model_maker import image_classifier
from tflite_model_maker.image_classifier import DataLoader
import tensorflow as tf
assert tf.__version__.startswith('2')
tf.get_logger().setLevel('ERROR')
Agora que o ambiente está pronto, é hora de começar a criar o modelo.
4. Fazer o download e preparar seus dados
Se as imagens estiverem organizadas em pastas e essas pastas estiverem compactadas, se você fizer o download e descompactar o arquivo, suas imagens serão rotuladas automaticamente com base na pasta em que se encontram. Esse diretório será referenciado como data_path.
data_path = tf.keras.utils.get_file(
'flower_photos',
'https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz',
untar=True)
Esse caminho de dados pode ser carregado em um modelo de rede neural para treinamento com a classe ImageClassifierDataLoader do TensorFlow Lite Model Maker. Aponte-o para a pasta e pronto.
Um elemento importante no treinamento de modelos com machine learning é não usar todos os dados para treinamento. Espere um pouco para testar o modelo com dados que ele ainda não viu. Isso é fácil de fazer com o método de divisão do conjunto de dados que vem de ImageClassifierDataLoader. Ao passar um 0, 9 para ele, você receberá 90% dele como dados de treinamento e 10% como dados de teste:
data = DataLoader.from_folder(data_path)
train_data, test_data = data.split(0.9)
Agora que os dados estão preparados, é possível criar um modelo com eles.
5. Criar o modelo de classificador de imagem
O Model Maker abstrai muitos detalhes do design da rede neural para que você não precise lidar com o design da rede e coisas como convoluções, densas, relu, niveladas, funções de perda e otimizadores. Para um modelo padrão, você pode simplesmente usar uma única linha de código para criar um modelo treinando uma rede neural com os dados fornecidos:
model = image_classifier.create(train_data)
Ao executá-lo, você verá uma saída semelhante a esta:
Model: "sequential_2"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
hub_keras_layer_v1v2_2 (HubK (None, 1280) 3413024
_________________________________________________________________
dropout_2 (Dropout) (None, 1280) 0
_________________________________________________________________
dense_2 (Dense) (None, 5) 6405
=================================================================
Total params: 3,419,429
Trainable params: 6,405
Non-trainable params: 3,413,024
_________________________________________________________________
None
Epoch 1/5
103/103 [===] - 15s 129ms/step - loss: 1.1169 - accuracy: 0.6181
Epoch 2/5
103/103 [===] - 13s 126ms/step - loss: 0.6595 - accuracy: 0.8911
Epoch 3/5
103/103 [===] - 13s 127ms/step - loss: 0.6239 - accuracy: 0.9133
Epoch 4/5
103/103 [===] - 13s 128ms/step - loss: 0.5994 - accuracy: 0.9287
Epoch 5/5
103/103 [===] - 13s 126ms/step - loss: 0.5836 - accuracy: 0.9385
A primeira parte mostra a arquitetura do seu modelo. O Model Maker está fazendo em segundo plano o que chamamos de aprendizado por transferência, que usa um modelo pré-treinado existente como ponto de partida e aplica o que o modelo aprendeu sobre como as imagens são construídas para entender essas cinco flores. A primeira linha é a seguinte:
hub_keras_layer_v1v2_2 (HubK (None, 1280) 3413024
A chave é a palavra "Hub", nos informando que este modelo veio do TensorFlow Hub. Por padrão, o TensorFlow Lite Model Maker usa um modelo chamado "MobileNet" que foi projetado para reconhecer 1.000 tipos de imagem. A lógica é que a metodologia usada, aprendendo "atributos" para distinguir entre mil classes, podem ser reutilizadas. Os mesmos "recursos" podem ser mapeadas para nossas cinco classes de flores, para que não precisem ser aprendidas do zero.
O modelo passou por 5 períodos, em que um período é um ciclo completo de treinamento em que a rede neural tenta corresponder as imagens aos rótulos. Ao passar por 5 períodos, em cerca de 1 minuto, tinha 93,85% de precisão nos dados de treinamento. Considerando que há 5 classes, um palpite aleatório seria 20% preciso, então isso é progresso! Ele também informa um número de "perda", mas é seguro ignorar isso por enquanto.
Anteriormente, você dividiu os dados em dados de treinamento e teste para ter um medidor do desempenho da rede em dados que ela ainda não viu. Esse é um melhor indicador de como ela pode funcionar no mundo real usando model.evaluate nos dados de teste:
loss, accuracy = model.evaluate(test_data)
A saída será semelhante a esta:
12/12 [===] - 5s 115ms/step - loss: 0.6622 - accuracy: 0.8801
Observe a precisão aqui. É 88,01%, então usar o modelo padrão no mundo real deve esperar esse nível de precisão. Isso não é ruim para o modelo padrão que você treinou em cerca de um minuto. É claro que você provavelmente poderia fazer muitos ajustes para melhorar o modelo, e isso é uma ciência por si só!
6. Exportar o modelo
Agora que o modelo está treinado, a próxima etapa é exportá-lo para o formato .tflite, que pode ser usado por um aplicativo para dispositivos móveis. O Model Maker oferece um método de exportação fácil que pode ser usado. Basta especificar o diretório de saída.
O código fica assim:
model.export(export_dir='/mm_flowers')
Se você estiver executando isso no Google Colab, poderá ver o modelo clicando no ícone de pasta à esquerda da tela:
Depois disso, você terá uma lista do diretório atual. Use o botão indicado para mover "para cima" em um diretório:
No código, você especificou como exportar para o diretório mm_flowers. Abra esse arquivo para ver um arquivo chamado "model.tflite". Este é seu modelo treinado.
Selecione o arquivo e três pontos vão aparecer à direita. Clique para abrir um menu de contexto e fazer o download do modelo.
Depois de alguns instantes, o download do modelo será feito na pasta de downloads.
7. Parabéns
Agora está tudo pronto para ser integrado ao seu app para dispositivos móveis. Você vai fazer isso no próximo laboratório.