Treine novamente modelos de redes neurais otimizados para dispositivos móveis para reconhecer objetos personalizados usando o TensorFlow

INTRODUÇÃO

O aprendizado de máquina em aplicativos se torna cada vez mais popular. Recomendações inteligentes do YouTube ou Netflix, tradução de texto ao vivo pelo Google Translate. Combinar o poder dos dispositivos móveis, da inteligência artificial e do aprendizado de máquina leva a uma ótima experiência do usuário. No entanto, como os modelos de aprendizagem são um processo computacionalmente complexo e os smartphones são dispositivos de baixo consumo de energia, o aprendizado de máquina para dispositivos móveis exigirá inevitavelmente treinamento em um computador ou servidor local.

RECONHECER MODELOS

Modelos modernos e precisos de reconhecimento de objetos podem conter milhões de parâmetros. Por exemplo, o modelo do Google Início-v3 mostrado na (Fig. 1), onde um bloco representa uma camada,

Figura 1: O diagrama Inception-v3 é capaz de distinguir entre uma salamandra manchada e uma salamandra de fogo (Fig. 2).

Figura 2: Fotos de salamandra malhada e de fogo

Infelizmente, o processo de treinamento de modelos tão complexos requer um enorme poder computacional, ou seja, Início-v3 requer duas semanas de aprender com 8NVIDIA Tesla K40 placas gráficas. Para acelerar o processo, o Google lançou uma versão ou modelo inicial pré-treinado que pode ser adaptado a uma nova tarefa. Este processo é chamado de aprendizagem por transferência e facilita significativamente o retreinamento dos pesos existentes das camadas las para reconhecer novos objetos. Não é tão eficaz quanto treinar do zero, mas é surpreendentemente eficaz para muitas aplicações. O melhor é que ele consegue alcançar resultados satisfatórios em aproximadamente 30 minutos em um laptop, sem precisar de GPU.

PROBLEMA DE TAMANHO

Inception-v3 é um ótimo modelo, mas lento e volumoso para dispositivos móveis. Ocupa muito espaço e memória (quase 100 MB). Além disso, o tempo de processamento de entrada para saída leva de 200 a 300 ms para processar uma imagem de entrada 224×224 em um telefone decente (Nexus 5). Felizmente, o Google também lançou modelos otimizados para dispositivos móveis – “MobileNet”.

MobileNets são uma classe de rede neural convolucional criada para ser rápida, eficiente em termos de recursos e razoavelmente precisa. (Mais informações: https://arxiv.org/pdf/1704.04861.pdf)

O Google lançou vários tipos de MobileNet (Fig. 3):

Figura 3: Tipos de modelo MobileNet

Onde:

• MACs (Multiply Accumulates) – proporcional ao poder de computação necessário,
• parâmetros – proporcionais ao uso de memória

Além disso, cada modelo vem com pesos normais e quantizados. Uma versão do modelo quantizado usa 8 bits pesos em vez de 32 bits. Como resultado, o modelo diminuiu seu tamanho até 75% (ao custo de uma precisão um pouco pior) e devido à computação de 8 bits, o tempo de processamento diminuiu.

REÚNE DADOS DE TREINAMENTO

Para começar, precisamos de dados de treinamento de objetos que queremos reconhecer. Precisamos de pelo menos 1000 imagens de cada objeto. Para tornar esse processo mais rápido, podemos fazer um filme e dividi-lo em frames. Para fazer acontecer vou usarFFMpeg.

Se a resolução do filme for alta, devemos reduzi-la primeiro. ComFFMpeg podemos chamar o comando abaixo:

Se passarmos a largura_desejada como500ele reduzirá a largura para 500 px e, devido ao valor do tamanho da altura passado de-1 o script irá ajustá-lo automaticamente para manter a proporção.

Finalmente, podemos dividi-lo com:

Se o filme for gravado em 30 fps e passarmos o valor de fps de:

• 30 – retornará imagens de cada quadro,
• 15 – retornará a cada segundo quadro,
• 1 – retornará um quadro a cada segundo do filme.

Este processo deve ser repetido para cada objeto que queremos reconhecer.

TEMPO DE TREINAMENTO

Presumo que você já tenha instalado o TensorFlow. Caso contrário, siga este guia: https://www.tensorflow.org/install/.

Para iniciar o retreinamento, execute o script retrain.py:

Onde:

• image_dir – um caminho para a pasta com a estrutura como esta:

• learning_rate – controla o tamanho das atualizações na camada final durante o treinamento,
• testing_percentage – qual porcentagem de imagens usar como conjunto de teste,
• validation_percentage – qual porcentagem de imagens usar como conjunto de validação,
• train_batch_size – quantas imagens treinar por vez,
• validation_batch_size – quantas imagens usar em um lote de avaliação. Este conjunto de validação é usado com muito mais frequência do que o conjunto de teste e é um indicador precoce da precisão do modelo durante o treinamento. Um valor de -1 faz com que todo o conjunto de validação seja usado, o que leva a resultados mais estáveis ​​em iterações de treinamento, mas pode ser mais lento em grandes conjuntos de treinamento,
• flip_left_right – se deve virar aleatoriamente metade das imagens de treinamento horizontalmente,
• random_scale – porcentagem que determina quanto aumentar aleatoriamente o tamanho das imagens de treinamento,
• random_brightness – porcentagem que determina quanto multiplicar aleatoriamente os pixels de entrada da imagem de treinamento para cima ou para baixo,
• eval_step_interval – com que frequência avaliar os resultados do treinamento,
• how_many_training_steps – quantas etapas de treinamento executar antes de terminar,
• architecture – nome de uma arquitetura modelo (que será baixada automaticamente).

A princípio recomendo deixar o campo arquitetura em branco. O modelo Inception-v3 será selecionado. Isso verificará se a qualidade dos seus dados de treinamento é suficiente. Se a precisão for satisfatória, você pode tentar selecionar arquiteturas MobileNet menores.

Podemos observar o processo de aprendizagem na janela do console ou graficamente (Fig. 4), na forma de gráficos, chamando:

E abrindo http://localhost:6006/ em nosso navegador.

Figura 4: Interface TensorBoard

Após a conclusão do processo de aprendizagem, o modelo será salvo em/tmp/output_graph.pb e arquivo de rótulos para/tmp/output_labels.txt.

Como você pode ver, treinar novamente um modelo para reconhecer objetos personalizados é muito fácil e leva menos de uma hora, incluindo tempo de aprendizado, em um laptop decente. No próximo artigo mostrarei como utilizar o modelo gerado para visualizar resultados de objetos reconhecidos.