Criar um modelo personalizado para seu classificador de imagens

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 centenas de classes de imagem. Ela reconheceu, de forma genérica, a foto de uma flor: pétalas, flores, plantas e céu.

Para atualizar o app a reconhecer flores, margaridas ou rosas específicas, por exemplo, você precisará de um modelo personalizado que seja treinado com muitos exemplos de cada tipo de flor que você quer reconhecer.

Prerequisites

  • Codelab anterior deste programa de aprendizado.

O que você criará e aprenderá

  • Como treinar um modelo personalizado de classificador de imagens usando o Model Lite do TensorFlow Lite.

Pré-requisitos

  • Nenhum hardware específico é necessário. Tudo isso pode ser feito usando o Google Colab no navegador.

2. Começar

Todo o código a ser seguido foi preparado e está disponível para execução usando o 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, será relativamente fácil treinar um modelo com o fabricante de modelos do TensorFlow Lite para reconhecê-los.

A maneira mais fácil de fazer isso é criar um arquivo .zip ou .tgz contendo as imagens, classificadas em diretórios. Por exemplo, se você usar imagens de margaridas, dentes-de-leão, rosas, girassol e tulipas, poderá organizá-las em diretórios como estes:

4ee12554e75b103f.png

Compacte esse código e hospede-o em um servidor para poder treinar modelos com ele. Você usará um que foi preparado para você no restante deste laboratório.

Neste laboratório, você vai usar o Google Colab para treinar o modelo. Você pode encontrar colab em colab.research.google.com. Se você estiver usando outro ambiente, talvez precise instalar muitas dependências, não menos o TensorFlow.

3. Instalar e importar dependências

  1. Instalar o Model Lite do TensorFlow Lite Faça isso com uma instalação do pip. O &> /dev/null no final apenas suprime a saída. O Model Maker produz muitas coisas que não são imediatamente relevantes. Ela foi suprimida para que você possa se concentrar na tarefa em questão.
# Install Model maker
!pip install -q tflite-model-maker &> /dev/null
  1. Em seguida, você precisará importar as bibliotecas necessárias e garantir que 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 suas imagens estiverem organizadas em pastas e elas forem compactadas, se você fizer o download do arquivo ZIP e descompactá-lo, suas imagens serão marcadas automaticamente com base na pasta em que estão. 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. Basta apontar para a pasta e pronto.

Um elemento importante em modelos de treinamento com machine learning é não usar todos os dados para treinamento. Espere um pouco para testar o modelo com dados que ele não viu antes. É fácil fazer isso com o método de divisão do conjunto de dados proveniente de ImageClassifierDataLoader. Ao transmitir 0, 9, você receberá 90% 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, você pode criar um modelo com eles.

5. Criar o modelo de classificador de imagem

O Model Maker abstrai muitas das especificidades de projetar a rede neural para que você não precise lidar com design de rede e itens como convoluções, densidade, relu, nivelamento, funções de perda e otimizadores. Para um modelo padrão, use apenas uma linha de código para criar um modelo treinando uma rede neural com os dados fornecidos:

model = image_classifier.create(train_data)

Ao executar esse código, o resultado terá a seguinte aparência:

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 é mostrar a arquitetura do modelo. O que o Model Maker está fazendo nos bastidores é chamado de Aprendizado por transferência, que usa um modelo pré-treinado como ponto de partida. Ele usa apenas o que esse modelo aprendeu sobre a construção e a aplicação de imagens. para entender essas cinco flores. Veja isso na primeira linha:

hub_keras_layer_v1v2_2 (HubK (None, 1280)              3413024

A chave é a palavra "Hub", que nos informa que esse modelo veio do TensorFlow Hub. Por padrão, o TensorFlow Lite Model Maker usa um modelo chamado "MobileNet", projetado para reconhecer 1.000 tipos de imagens. A lógica aqui é que a metodologia usada, aprendendo por "recursos" para distinguir entre 1.000 classes, pode ser reutilizada. Os mesmos "recursos" podem ser mapeados para as cinco classes de flores para que elas não precisem ser aprendidas do zero.

O modelo passou por cinco períodos, em que um período é um ciclo completo de treinamento em que a rede neural tenta relacionar as imagens aos rótulos. Ao passar por cinco períodos, em cerca de um minuto, a precisão dos dados de treinamento era de 93,85%. Como há cinco classes, um palpite aleatório seria 20% preciso, então já podemos avançar! Ele também informa um número de "perda", mas você pode ignorar essa informação por enquanto.

Anteriormente, você dividia os dados em dados de treinamento e teste para ter acesso a informações sobre o desempenho da rede em dados ainda não vistos antes. Esses indicadores mostram melhor o desempenho do mundo real commodel.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. Ela é de 88,01%. Por isso, o uso do modelo padrão no mundo real é esperado nesse 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ê poderia fazer muitos ajustes para melhorar o modelo. Isso é apenas uma ciência.

6. Exportar o modelo

Agora que o modelo está treinado, a próxima etapa é exportá-lo no formato .tflite que um aplicativo para dispositivos móveis pode usar. O Model Maker oferece um método de exportação fácil que você pode usar. Basta especificar o diretório para o resultado.

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:

cc5b9988775633b4.png

Aqui, você verá uma lista do diretório atual. Use o botão indicado para mover um diretório para cima:

51e6ac47c992142a.png

No código que você especificou para exportar para o diretório mm_flores. Ao fazer isso, você verá um arquivo chamado "model.tflite". Este é o modelo treinado.

57bad87f294fd189.png

Selecione o arquivo. Você verá três pontos à direita. Clique nelas para ver um menu de contexto e fazer o download do modelo.

aee14ad10c4a8a1a.png

Após alguns instantes, o modelo será transferido para a pasta de downloads.

7. Parabéns

Agora está tudo pronto para integrá-lo ao seu app para dispositivos móveis. Você fará isso no próximo laboratório.