Embed Size (px)
Citation preview
PONTIFÍCIA UNIVERSIDADE CATÓLICA DO PARANÁ ESCOLA POLITÉCNICA
CURSO DE ENGENHARIA DE COMPUTAÇÃO
DANIEL TAKECHI MINO OKADA JOÃO FILIPE CAVICHIOLO STORRER
VINICIOS DE MORAIS
RELATÓRIO TÉCNICO FINAL
ECOSSISTEMA DE IDENTIFICAÇÃO E LOCALIZAÇÃO DE ANIMAIS DOMÉSTICOS UTILIZANDO APRENDIZADO DE MÁQUINA EM DISPOSITIVOS MÓVEIS
Orientador: Prof. Dr Mark Eirik Scortegagna Joselli __________________________________
Mark Eirik Scortegagna Joselli
CURITIBA 2018
RESUMO
Animais de estimação, como cachorros, são comumente perdidos e
dificilmente retornam aos seus lares. Para mitigar isso, o método de identificação
animal atual, baseado em microchips implantados, necessita de leitores caros e
difíceis de encontrar, pois são inviáveis economicamente. Para contornar a
necessidade de um microchip implantado e seus respectivos dispositivos de leitura,
este projeto propõe um sistema que identifica animais através de aprendizado de
máquina em dispositivos móveis. Dessa forma, os únicos equipamentos necessários
são dispositivos móveis equipados com câmera, que, atualmente, são parte do
cotidiano de grande parte da população mundial.
O desenvolvimento do projeto conta com ferramentas para tratar grandes
quantidades de arquivos, visto que para o processo de treinamento do classificador,
é desejável um grande volume de dados para aumentar a acurácia. Também foram
utilizadas bibliotecas para as linguagens Swift para o aplicativo e treinamento, e
Python também para treinamentos com diferentes algoritmos de aprendizado de
máquina.
Como resultado desse trabalho, obtemos uma plataforma que pode ser
facilmente difundida e auxilia na identificação e recuperação de animais perdidos
através do reconhecimento de raças e geolocalização.
LISTA DE ILUSTRAÇÕES
Figura 1: Diagrama de blocos do projeto .................................................................. 11
Figura 2: Diagrama Entidade Relacionamento do banco de dados .......................... 12
Figura 3: Arquitetura MVVM ...................................................................................... 13
Figura 4: Diagrama de classe ................................................................................... 14
Figura 5: Diagrama de caso de uso do aplicativo ..................................................... 15
Figura 6: Diagrama de Atividades - Relatar cão perdido .......................................... 15
Figura 7: Função para redimensionar imagens ......................................................... 16
Figura 8: Função para tranformar imagens em buffer de pixels ............................... 17
Figura 9: Função para recortar imagens ................................................................... 17
Figura 10: Função para recortar um cão na imagem ................................................ 18
Figura 11: Função para obter as raças de um cachorro na imagem ........................ 18
Figura 12: Função para aplicar os modelos em uma imagem .................................. 19
Figura 13: Modelo Perceptron – Fonte: Rojas, R. [14] .............................................. 20
Figura 14: Cálculo do output em um Perceptron ....................................................... 20
Figura 15: Resultado de um filtro de detecção de bordas com convolução – Fonte:
Chaudhuri, S. [15] ..................................................................................................... 21
Figura 16: Processo de pooling – Fonte: Stanford CS [16] ....................................... 22
Figura 17: Exemplo básico de CNN – Fonte: Stanford CS [16] ................................ 22
Figura 18: Imagem com dois cães e suas respectivas caixas delimitadoras ............ 24
Figura 19: Resultado do treinamento de um modelo utilizando CreateML ............... 27
Figura 20: Função para extrair a classe .................................................................... 29
Figura 21: Função para criar o arquivo contendo os dados das imagens usadas no
treinamento ............................................................................................................... 30
Figura 22: Funções de convolução e pooling ............................................................ 30
Figura 23: Função para encontrar o custo, a acurácia e pegar o próximo batch ...... 31
Figura 24: Função para gerar CNN ........................................................................... 32
Figura 25: Função para treinar o modelo .................................................................. 33
Figura 26: CNN utilizando TFLearn ........................................................................... 34
Figura 27: Resultado do treinamento com TensorFlow e InceptionV3 ..................... 35
Figura 28: Loss para o modelo treinado .................................................................... 35
Figura 29: Accuracy para o modelo treinado ............................................................ 36
Figura 30: Exemplos de Índice de Jaccard – Fonte: TuriCreate [19] ........................ 44
SUMÁRIO
1 INTRODUÇÃO ....................................................................................... 52 PROJETOS SEMELHANTES ............................................................... 82.1 MICROCHIPS IMPLANTADOS ...................................................................... 8
2.1.1 AnimallTAG ................................................................................................... 82.1.2 Vibrac BackHome ......................................................................................... 92.1.3 Abrachip ........................................................................................................ 92.2 SOLUÇÕES COM GPS .................................................................................. 9
2.2.1 MePerdi .......................................................................................................... 92.3 MEDALHAS DE COLEIRA ........................................................................... 10
2.3.1 DogTap ........................................................................................................ 102.3.2 QR Bicho ..................................................................................................... 103 DETALHAMENTO DO PROJETO ...................................................... 113.1 API RESTFUL ............................................................................................... 12
3.2 APLICATIVO MÓVEL ................................................................................... 13
3.2.1 Aprendizado de máquina ........................................................................... 193.2.1.1 Redes Neurais .............................................................................................. 19
3.2.1.1.1 Perceptron ........................................................................................... 19
3.2.1.1.2 Convolutional Neural Network ............................................................. 20
3.2.1.2 Treinamento de modelos .............................................................................. 23
3.2.1.2.1 Detecção de objetos ............................................................................ 24
3.2.1.2.2 Classificação de imagens .................................................................... 25
4 TESTES E RESULTADOS .................................................................. 374.1 TESTES CAIXA PRETA ............................................................................... 37
4.2 TESTES CAIXA BRANCA ............................................................................ 39
4.3 TESTES DE APRENDIZADO DE MÁQUINA ............................................... 44
4.3.1 Detecção de objetos ................................................................................... 444.3.2 Classificação de imagens .......................................................................... 455 CONCLUSÃO ...................................................................................... 46REFERÊNCIAS ......................................................................................................... 47
5
1 INTRODUÇÃO De acordo com a Petfinder [1], uma empresa que dirige abrigos de animais
espalhados pelos Estados Unidos, México e Canadá, existem vários motivos para
utilizar um microchip de identificação em animais de estimação. Dentre eles,
algumas estatísticas:
• 10 milhões de cães e gatos são perdidos ou roubados todos os anos;
• Apenas 22% dos cães que dão entrada nos abrigos retornam para suas
famílias, e quando se trata de gatos essa taxa cai para 2%;
• Apenas 58% animais que possuem o implante subcutâneo possuem o
registro de suas informações nas bases de dados;
• Segundo a própria Petfinder: “uma proteção High-tech pode prevenir um
coração partido”.
Esses dados encorajam a criação de projetos que visam reconhecer animais
e aumentar as chances de um animal perdido retornar à sua casa.
A solução atual para a identificação animal baseadas em implantes de
microchips de rádio frequência ao redor do globo é padronizada pela ISO 11784 ou
a ISO 11785 desde 2002 na Europa [2]. Existem vários projetos no Brasil para
normalizar a identificação animal no sentido legislativo, porém a situação é bastante
descentralizada. Cada estado ou município trabalha de maneira individual,
atrasando a implementação nacional de maneira abrangente.
A microchipagem para a identificação de animais domésticos tem crescido em
uso e importância nos últimos anos. Já é obrigatório implanta-lo em cães e gatos se
o animal for acompanhar seu dono em alguma viagem para qualquer país da europa
ou para o Japão. Criadores também utilizam o microchip por exigência de algumas
associações, para assegurar a origem da raça e impedir falsificações de pedigree.
O intuito da aplicação do microchip é identifica-lo perante a um cadastro em
uma plataforma digital contendo informações que relacionam o código do implante
do animal com as informações do seu dono. Porém não existe nenhuma plataforma
oficial para gerenciar os cadastros. Existem várias plataformas digitais diferentes, e
nenhuma base de dados centralizada. Geralmente o dono é instruído a cadastrar
suas informações no site da fabricante do implante.
O procedimento a ser seguido ao identificar um animal perdido é o seguinte: o
animal deverá ser deslocado até abrigos, clínicas veterinárias, pet-shops, etc, até
6
encontrar um estabelecimento que possua um leitor compatível com esses
microchips (poucos estabelecimentos possuem o equipamento pois eles são muito
caros e não tem nenhuma função que gere lucro). Assim que a leitura for efetuada,
um código é fornecido e ele deverá ser consultado em um computador,
pesquisando-o nas diversas páginas de registro existentes. Encontrando o cadastro,
e, caso as informações estejam atualizadas, o dono do animal poderá ser contatado
e o animal poderá retornar à sua casa.
Esse processo é considerado ineficiente por conta da quantidade de leitores
disponíveis, a descentralização das plataformas de registro, que dificulta a
localização do cadastro, e o próprio cadastro que muitas vezes se encontra
desatualizado. Esses são problemas que permeam o mundo todo, já que o processo
é igual em qualquer lugar, e mesmo que existam exigências do microchip para
viagens, os documentos requerem apenas o código do microchip, e não há
nenhuma métrica de rastreabilidade do animal para situações emergenciais.
As justificativas para a realização do implante em massa são: identificação,
responsabilidade e rastreabilidade, ou seja, aumentar o numero de cães perdidos
recuperados, impedir que cães sejam abandonados e identificar a origem de cada
animal.
Num cenário local, a Prefeitura de Curitiba é bastante ativa na área,
promovendo feiras de adoção e programas de microchipagem de animais de rua.
Em 2016 as pesquisas mostraram que haviam mais de 50 mil animais vivendo nas
ruas da cidade [3]. Para controlar essa situação, a prefeitura em conjundo com a
Universidade Federal do Paraná lançou um projeto chamado Cão comunitário. Que
orientava instituições de grande circulação de pessoas como academias ou escolas
a mobilizar uma consciência em grupo para cuidar das necessidades relacionadas a
alimentação, banho e saúde dos animais de rua das redondezas.
Contudo, isso está longe de ser a solução definitiva. Este projeto propõe um
sistema para dispositivos móveis como prova de conceito para validar a tecnologia
de identificação de cães a partir de características físicas semelhantes, e agrupá-los
por proximidade. A ideia, é que todos que possuam um cão criem um perfil no
aplicativo com as suas informações, juntamente com uma foto de seu cachorro.
Essa foto será classificada pelo modelo de identificação de raças e será criado um
perfil. Se esse cão se perder e alguém o encontrar, basta utilizar o aplicativo na
7
função de identificação e tirar uma foto do cão encontrado. O sistema mostrará uma
pequena lista de cães cadastrados que se parecem com o encontrado e que se
perderam naquela localidade.
As situações que demandam a utilização da plataforma proposta por esse
projeto, exigem que o funcionamento ocorra em locais urbanos, ou seja, nem
sempre existe uma conexão de alta velocidade disponível para uma troca excessiva
de dados. Redes móveis oferecem capacidade suficiente para a troca dos dados
necessários para o funcionamento, que basicamente são compostos de uma
imagem e algumas cadeias de caracteres.
Devido à natureza do projeto, é necessário que ele possa ser utilizado por
uma grande quantidade de pessoas e que essas pessoas consigam opera-lo quando
e onde for necessário. Um aplicativo para smartphones satisfaz esses requisitos,
visto que smartphones se tornaram uma parte essencial da vida de pessoas na
sociedade contemporânea.
Este documento descreve uma plataforma que relaciona informações de
animais encontrados por usuários da plataforma com animais cadastrados que
estejam marcados como perdidos. A plataforma consiste de uma aplicação móvel
para iOS e um banco de dados em nuvem. O desenvolvimento utiliza diferentes
abordagens de aprendizado de maquina para fazer o reconhecimento destes
animais.
Na seção 2, são apresentados projetos comerciais que visam atingir o mesmo
objetivo deste projeto, a localização de cachorros perdidos; na seção 3, será
discorrido sobre detalhes dos módulos do projeto, descrevendo as arquiteturas
utilizadas e os motivos das decisões tomadas; na seção 4, os procedimentos de
teste para validar o funcionamento dos módulos e os resultados obtidos; e,
finalmente, na seção 5, uma breve conclusão sobre o projeto.
8
2 PROJETOS SEMELHANTES O mercado se manifesta de diferentes maneiras quando se trata de produtos
de identificação ou rastreamento animal. Existem algumas empresas que trabalham
com o microchip tradicional, outras com medalhas de coleira com diferentes
tecnologias embarcadas e por fim as soluções com GPS integrado, que carrega uma
bateria. Ao observar os produtos disponíveis, encontramos em alguns, problemas.
Em outros, encontramos um complemento para a solução apresentada neste
documento.
2.1 MICROCHIPS IMPLANTADOS
As soluções com microchips subcutâneos são bastante interessantes, porém,
a principal função dos implantes é a identificação. Esses chips portam um número
único para cada animal, metaforicamente um Registro Geral (RG) que portamos
como cidadãos. É possível encontrar o dono a partir desse recurso, porém o
processo é muito complicado. Primeiramente, a leitura do código do microchip
depende de leitores muito caros. Em seguida deve-se encontrar o cadastro do
número coletado, realizando uma busca em diversas bases de dados existentes,
visto que não existe uma centralização definitiva para essa solução. Por fim, todo o
processo depende do estado dos dados cadastrais, que devem estar atualizados. E
esse é o maior dos problemas dessa solução por conta da expectativa de vida dos
animais. Os cães por exemplo, passam dos 10 anos de idade com facilidade, e as
chances do dono de um cachorro mudar de endereço ou telefone nesse intervalo de
tempo é muito grande. As subseções a seguir, mostram alguns produtos utilizando a
tecnologia dos microchips para a identificação e localização animal.
2.1.1 AnimallTAG
A AnimallTAG [4] é uma empresa que trabalha com identificação animal
focada ao agronegócio. Os principais produtos são brincos de identificação para
rebanhos, mas a instituição é um dos principais fornecedores de microchips
implantados para animais de estimação no Brasil. Além do implante, eles oferecem o
leitor de microchips e brincos e também um portal para o cadastro que relaciona as
informações do dono com as informações do animal.
9
2.1.2 Vibrac BackHome
A Vibrac é uma empresa líder mundial quando se trata de produtos para
animais. Ela comercializa o produto BackHome [5], que são microchips para animais
de estimação, e eles são vendidos comunicando-se diretamente com o dono,
frisando as qualidades exclusivas do microchip da marca. Essa empresa também
vende o seu leitor que é compatível com as outras marcas que seguem o padrão
internacional ISO 11784.
2.1.3 Abrachip
O Abrachip [6] é um bando de dados que pretende centralizar os cadastros de
microchips, contendo informações a respeito da situação clínica do animal
relacionadas no registro. Porém, por mais que a solução tenha o intuito de identificar
animais de maneira global, o portal Abrachip está disponivel somente em português,
o que dificulta a identificação no caso de deslocamentos internacionais.
2.2 SOLUÇÕES COM GPS
A principio, a tecnologia parece interessante e muito eficiente. Ela de fato
funciona e pode ser aplicada por seguradoras em veículos, ou em malas de viagem.
Contudo, a aplicação para o rastreamento animal não é 100% segura, visto que
esses dispositivos podem causar um desconforto dependendo do porte do animal. E
até mesmo podem ser nocivos no caso de um eventual mastigamento do produto e
consequentemente da bateria embutida.
2.2.1 MePerdi
A MePerdi [7] é uma empresa que oferece a tecnologia de rastreamento para
diversas aplicações, entre elas, crianças, idosos, veículos, bolsas e animais. A
empresa oferece um aplicativo para smartphones personalizado para cada
aplicação, que recebe as informações do “Appego GPS”, que é o nome do produto
vendido para realizar o rastreamento. Eles também oferecem suporte ao cadastro do
código de microchips e de medalhas de coleira. Basta inserir o código de
10
identificação presente em um deles e o aplicativo fornece dados sobre o animal e
seu dono.
2.3 MEDALHAS DE COLEIRA
As medalhas de coleira oferecem uma alternativa para encontar o dono de um
animal perdido. As informações podem estar escritas fisicamente nas medalhas, ou
a medalha pode ser um artifício para fornecer o acesso a mais informações. Um
ponto fraco desse sistema é o fato de que alguns animais não fazem o uso de
coleiras, característica comum entre gatos. Outro possível problema é que essas
medalhas podem se perder, soltando-se das coleiras ou juntamente a elas.
2.3.1 DogTap
A DogTap [8] é uma empresa da Alemanha que vende diferentes tipos de
medalhas para coleira. A solução consiste em uma mistura de tecnologias. O NFC e
o QRCode. Assim, basta um celular para realizar a leitura com qualquer uma das
tecnologias e ter o acesso imediato aos dados do animal.
2.3.2 QR Bicho
A QR Bicho [9] é uma iniciativa Brasileira. A empresa vende medalhas com
QRCodes que quando lidos com a câmera de um smartphone, fornecem todos os
dados necessários para a identificação do animal. O funcionamento é similar ao da
DogTap, com excessão da tecnologia NFC, que neste caso não está presente.
11
3 DETALHAMENTO DO PROJETO A proposta deste projeto é construir um aplicativo para smartphones que seja
capaz de reconhecer um cão a partir de uma imagem e geolocalização. Os animais
devem ser previamentes cadastrados na plataforma por seus donos e associados à
uma fotografia. Se eventualmente um cachorro for perdido, e reconhecido pela
plataforma posteriormente, o dono é notificado pelo aplicativo, e recebe a
localização em que o cão parecido com o dele foi visto e a foto tirada pela pessoa
que o encontrou.
A figura 1 mostra o diagrama de blocos do sistema desenvolvido neste
projeto.
Figura 1: Diagrama de blocos do projeto
O projeto é dividido em duas partes principais: uma API RESTful e aplicações
móveis com modelos de aprendizado de máquina para reconhecimento de raças de
cachorros. A utilização de aprendizado de máquina dentro dos aplicativos para
smartphones é um conceito bastante recente. Os novos smartphones estão sendo
construídos com recursos específicos para essa aplicação, como pode ser
observado no A12 Bionic [10], do iPhone Xs, que possui componentes dedicados a
processar tarefas de aprendizado de máquina. É interessante que um processo
dissociado reduz o esforço de processamento do servidor, e o processamento
realizado no dispositivo móvel não gera impacto ao usuário. Também há a vantagem
de realizar o envio de apenas uma imagem, pois toda a validação é feita antes do
12
envio, eliminando casos onde a banda é utilizada para o envio de uma imagem
inadequada.
3.1 API RESTFUL
Para a persistência das informações, um banco de dados foi criado utilizando
MySQL, e, para fazer a conexão entre aplicativo móvel e banco de dados, será
utilizada uma API RESTful desenvolvida em PHP utilizando o framework Laravel
[11]. Este framework foi escolhido devido à simplicidade de criação de uma página
web, no caso dos autores decidirem expandir a plataforma no futuro.
O padrão REST define que as informações são transmitidas em formato
JSON através de requisições HTTP com os métodos GET, POST, DELETE, dentre
outros.
A figura 2, a seguir, mostra o diagrama entidade relacionamento do sistema.
Figura 2: Diagrama Entidade Relacionamento do banco de dados
Além de fazer a conexão entre o aplicativo móvel e o banco de dados, a API
será responsável por relacionar cachorros encontrados com cachorros cadastrados
no banco de dados e notificar os donos de tais cachorros. Serão selecionados os
cachorros perdidos que possuem pelo menos uma das raças retornadas pelo
13
classificador. No caso de nenhum cachorro perdido se encaixar nos critérios de raça,
nenhum dono será notificado e serão retornados todos os cachorros perdidos dentro
de um raio de 5 km, pois o classificador pode ter se equivocado quanto às raças,
então, o usuário que encontrou o cachorro pode fazer uma verificação manual
dentre todos os cachorros.
Para reduzir o consumo de banda e garantir uma performance estável, a API
retornará todas as requisições com paginação, enviando apenas 10 resultados por
página.
3.2 APLICATIVO MÓVEL
Quando se trata de aplicativos para smartphones, são desenvolvidos
principalmente versões para os sistemas operacionais Android e iOS. Ao invés de
desenvolver um aplicativo multiplataforma que funcionaria para ambos sistemas
operacionais, decidiu-se desenvolver um aplicativo nativo para iOS.
O aplicativo para iOS foi desenvolvido no ambiente Xcode [12] utilizando a
linguagem Swift [13] e a arquitetura Model View ViewModel (MVVM).
Na arquitetura MVVM, os modelos são atualizados pelas view models e ficam
encarregados de notifica-las caso algum atributo sofra alteração. Já as view models
realizam o trabalho de formatar as informações contidas no modelo e validar
alterações antes de transferí-las para o modelo. As views apenas mostram a
informação tratada e, caso necessário, realizam alterações na view model. A lógica
principal do aplicativo se localiza nas view models, facilitando a criação de testes
unitários pois, além de facilitar a injeção de dependências, remove a necessidade de
se lidar com views. Para testar o funcionamento das views, podem ser feitos testes
de interface separadamente. A figura 3, a seguir, mostra a relação existente na
arquitetura MVVM.
Figura 3: Arquitetura MVVM
14
O diagrama de classes para o aplicativo está representado na figura 4,
abaixo.
Figura 4: Diagrama de classe
O diagrama de caso de uso que representa o aplicativo está apresentado na
figura 5, abaixo.
15
Figura 5: Diagrama de caso de uso do aplicativo
O aplicativo serve como interface entre usuário e plataforma e possui duas
funcionalidades: gerenciar informações de seus cachorros; e informar a localização
de um cão perdido.
A primeira engloba um CRUD (Create, Read, Update, Delete) para que um
usuário consiga manter as informações de seus cães atualizadas.
A outra é a funcionalidade principal do aplicativo: informar a localização de um
cão perdido e notificar os possíveis donos deste cão. A figura 6 apresenta o
diagrama de atividades para esse caso de uso.
Figura 6: Diagrama de Atividades - Relatar cão perdido
16
Deste diagrama, são atividades do aplicativo apenas o enviar de informações
para a API e mostrar as informações dos donos compatíveis. A API será
responsável por procurar e retornar cães compatíveis, além de notificar os
respectivos donos.
Para proporcionar uma melhor experiência para o usuário, será implementado
infinite scrolling, que lidará automaticamente com a paginação da API, enviando a
requisição para carregar a próxima página assim que o usuário estiver próximo do
final da página.
O aplicativo também é responsável por processar imagens e aplicar o modelo
de aprendizado de máquina. As figuras 7, 8 e 9, a seguir, contém trechos de código
das funções auxiliares que preparam as imagens para o formato de entrada do
modelo, que é um buffer de pixels com tamanho de 416x416 no caso da detecção
de objetos e 299x299 no caso da classificação de imagens.
Figura 7: Função para redimensionar imagens
Para a função de redimensionar imagens, é necessário que a entrada seja
uma imagem com proporções iguais à desejada na saída (1:1), para que não haja
distorções. Como não existe um método nativo para redimensionamento de
imagens, o redimensionamento é feito criando um contexto de renderização de
bitmaps com o tamanho desejado, renderizando a imagem neste contexto, para
conseguir exportá-la redimensionada.
17
Figura 8: Função para tranformar imagens em buffer de pixels
Para transformar a imagem em um buffer de pixels, é alocado um novo
contexto de renderização de imagens com espaço de cores RGB, dimensões iguais
à da imagem, compatibilidade para o formato bitmap e CGImage (formato de
imagem da biblioteca CoreImage), a imagem é renderizada e é retornado um
ponteiro para a posição de memória do contexto de renderização.
Figura 9: Função para recortar imagens
O método para recorte de imagens é mais simples, pois só é necessário fazer
a conversão para o formato de imagens do CoreGraphics (biblioteca de
renderização de imagens para macOS e iOS), que possui um método para recortar
imagens, e converter a imagem recortada para o formato do UIKit (biblioteca de
elementos de interface gráfica do iOS).
As figuras 10 e 11, abaixo, mostram as funções que utilizam as funções
auxiliares mostradas anteriormente para aplicar os modelos de aprendizado de
máquina.
18
Figura 10: Função para recortar um cão na imagem
Figura 11: Função para obter as raças de um cachorro na imagem
Para aplicar o aprendizado de máquina nas imagens, estas são
redimensionadas para o tamanho necessário e convertidas para um buffer de pixels.
O resultado é processado conforme o modelo.
Para a detecção de cachorros, o resultado é um array de posições relativas,
são lançados erros caso o array esteja vazio ou contenha mais de um elemento. A
posição relativa é transformada em posição absoluta para que seja possível recortar
a imagem.
Para a classificação de raças, obtém-se um dicionário, que é ordenado por
grau de confiança da classificação. É então criado um array contendo a raça com
maior probabilidade e também a raça com a segunda maior probabilidade, caso esta
seja maior do que 10%.
19
A figura 12, abaixo, mostra a função utilizada para integrar os dois modelos.
Figura 12: Função para aplicar os modelos em uma imagem
3.2.1 Aprendizado de máquina
Aprendizado de máquina é uma área muito explorada na computação. Com
aprendizado de máquina, o computador utiliza dados que viu anteriormente para
realizar tarefas e tomar decisões sem a intervenção humana. Pode ser utilizado para
diversas tarefas como, por exemplo, encontrar um cachorro em uma imagem, como
será utilizada neste projeto, ou até mesmo recomendações personalizadas, como
presente em serviços como Netflix e Spotify.
3.2.1.1 Redes Neurais
Dentro do campo de aprendizado de máquina, redes neurais se destacam
para a aplicação aqui desejada, pois são capazes de aprender a reconhecer
padrões. Foram consideradas duas abordagens de redes neurais neste projeto:
Perceptron e Convolutional Neural Network (CNN).
3.2.1.1.1 Perceptron
Consiste no primeiro modelo de redes neurais. Esse modelo busca simular
uma rede de neurônios, como a existente em seres humanos, de tal forma que seja
possível “ensinar” um computador da mesma forma com que seres humanos
aprendem.
O perceptron é um modelo matemático, que consiste de uma camada de
entrada, pesos, um somador, uma função de ativação e uma camada de saída. A
figura 13 mostra o modelo de um Perceptron de uma camada.
20
Figura 13: Modelo Perceptron – Fonte: Rojas, R. [14]
A camada de saída é resultado da soma da camada de entrada, multiplicada
com seus devidos pesos e aplicada à uma função de ativação. Os pesos, portanto,
buscam dar mais ou menos importância de cada entrada para o resultado final. No
caso do perceptron, a saída é binária, podendo ser expressa da seguinte forma:
Figura 14: Cálculo do output em um Perceptron
Onde o threshold é definido de acordo com a aplicação.
3.2.1.1.2 Convolutional Neural Network
É um tipo de rede neural quem vem sendo amplamente aplicada em soluções
de classificação de imagens, e é uma evolução do Perceptron.
Este modelo apresenta os conceitos de convolução e pooling. Normalmente,
uma imagem seria percorrida pixel a pixel por um modelo em machine learning, no
entanto isso não seria muito eficaz para a extração de características, pois
21
geralmente características estão presentes em um conjunto de pixels ao invés de
apenas um pixel. Por exemplo, deseja-se extrair características de cachorros.
Pensando rapidamente, algumas características dos cachorros são orelhas, focinho
e pêlos. Para obter as características de uma imagem, esta é dividida em frames. A
convolução é aplicada nos frames da imagem para obter as características principais
de cada frame.
Figura 15: Resultado de um filtro de detecção de bordas com convolução – Fonte: Chaudhuri, S. [15]
Além disso, cada pixel em uma imagem pode ser representado por um
número entre 0 e 255, em uma escala cinza de imagem, representando a
quantidade de brilho naquele pixel. Uma vez que a imagem é percorrida por janelas
de pixel, cada janela deverá ter um número correspondente aos números presentes
em cada pixel da mesma, este procedimento é chamado de pooling e pode ser visto
na figura 16.
22
Figura 16: Processo de pooling – Fonte: Stanford CS [16]
Cada operação de convolução e pooling em uma CNN é considerada uma
“camada” da rede. A Convolutional Neural Network é composta de uma camada de
entrada, 1 ou mais camadas intermediárias, também conhecidas como Hidden
Layers (camadas ocultas), geralmente uma camada fully-connected (totalmente
conectada), ou seja, em que todas as camadas antes dela enviam informações a
todos os neurônios desta, e a camada de saída. A figura 17 mostra de forma
simplificada uma Convolutional Neural Network com 4 camadas ocultas.
Figura 17: Exemplo básico de CNN – Fonte: Stanford CS [16]
23
3.2.1.2 Treinamento de modelos
Dois tipos de modelos de aprendizado de máquina serão treinados com CNNs
para este projeto. Inicialmente, o projeto contaria com apenas um modelo de
aprendizado de máquina para classificação de raças de cachorros, porém, com a
realização de testes, foram encontrados três casos nos quais o resultado da
classificação não seria adequado. Os três casos ocorrem por conta da forma como
os classificadores de imagem funcionam.
No primeiro caso, o usuário escolhe uma foto sem nenhum cachorro, porém
classificadores de imagem apenas conseguem selecionar uma categoria dentre
aquelas previstas no treinamento, não conseguem classificar a imagem como “não
se parece com nenhuma das categorias que conheço”.
No segundo caso, o usuário seleciona uma foto com mais de um cão, mas
classificadores de imagem apenas retornam a categoria predominante, que pode ser
a raça do cachorro “intruso” na foto. Neste caso, um outro modelo deveria ser
utilizado para determinar a presença de diversos cachorros. Para encontrar objetos
em imagens, são utilizados os modelos de detecção de objetos, que conseguem
detectar diversos objetos diferentes em imagens e fornecem as coordenadas de
uma caixa delimitadora que contém o objeto. No caso de nenhum ou mais de um
cachorro ser detectado, a imagem será recusada. Pode-se perceber que detecção
de objetos pode substituir classificadores de imagem para o primeiro caso.
No terceiro caso, o usuário seleciona uma imagem contendo elementos que
podem confundir o classificador, como, por exemplo, uma foto com um labrador e
uma vaca malhada pode ser classificada como dálmata, pois o classificador vê o
formato de um cachorro que pode ser um dálmata e os padrões presentes em pelo
de dálmatas na mesma imagem. Para eliminar essas interferências, será utilizada a
caixa delimitadora resultante do modelo de detecção de objetos para recortar a foto
antes de ser aplicado o modelo de classificação de raças. Deste modo, o conteúdo
da imagem será apenas um cachorro.
Estes modelos serão independentes, e, ao serem utilizados em conjunto, se
complementarão para produzir resultados mais confiáveis.
24
3.2.1.2.1 Detecção de objetos
Este modelo será utilizado para encontrar cães nas imagens. Como elaborado
anteriormente, o resultado obtido a partir deste modelo servirá para filtrar imagens,
deixando passar apenas aquelas que contém exatamente um cachorro, além de
remover partes da imagem que não nos interessam.
Para o treinamento, serão utilizadas 750 fotos de cachorros aleatoriamente
selecionadas na ImageNet [17]. Antes de iniciar o treinamento, um arquivo de texto
contendo nome da imagem, coordenadas do centro, altura e largura das caixas
delimitadoras devem ser criadas manualmente. Para facilitar esta tarefa, será
utilizado Simple Image Annotator [18], que é uma interface gráfica para criar as
caixas delimitadoras e exportar o resultado em um arquivo csv. A figura 18, a seguir,
mostra as caixas criadas através do Simple Image Annotator.
Figura 18: Imagem com dois cães e suas respectivas caixas delimitadoras
O treinamento será feito utilizando a biblioteca TuriCreate [19], que possibilita
aplicar transferência de aprendizado para melhorar a precisão do modelo treinado. O
modelo treinado será uma rede neural convolucional, que consiste de uma camada
de entrada, múltiplas camadas ocultas e uma camada de saída. Cada camada aplica
uma convolução à sua entrada e repassa o resultado para a próxima camada,
simulando a resposta de neurônios a estímulos visuais. Para obter um melhor
resultado no treinamento de modelos de aprendizado de máquina, é possível aplicar
o método de transferência de aprendizado, no qual um modelo já existente (e mais
25
generalizado) é utilizado como base. O modelo treinado para detectar cachorros em
imagens será muito mais eficiente caso seja utilizada a transferência de aprendizado
com um modelo que consiga detectar animais em imagens, por exemplo. Como
base, TuriCreate utiliza automaticamente o modelo Darknet YOLO [20].
O treinamento com 750 imagens (80% destaas utilizadas para treinamento e
20% para validação) e 3000 iterações levou 138430 segundos (cerca de 38 horas) e
obteve 98.8% de precisão no treinamento e 94.4% de precisão na validação. Os
índices de precisão para treinamento e validação não refletem totalmente o
desempenho real dos modelos de aprendizado de máquina, todos os modelos
treinados neste projeto ainda devem passar por uma avaliação, descrita na seção 4
deste documento.
3.2.1.2.2 Classificação de imagens
Este modelo será utilizado para classificar cachorros em suas respectivas
raças. A imagem resultante do modelo de detecção de objetos será utilizada como
entrada neste modelo.
Para o treinamento, será utilizada a Stanford Dogs Dataset [21], uma
coletânea de fotos de cachorros, divididos em 120 raças, montada a partir de
imagens provenientes da ImageNet. Destas 120 raças, foram selecionadas 20 para
o treinamento, de modo a aumentar a eficiência do classificador. Dentre as 120
raças, há vários casos de raças muito semelhantes (husky siberiano e malamute do
alasca, por exemplo), ou variações de tamanho (poodle toy, poodle miniatura e
poodle médio), esses são detalhes muito sutis, muitas vezes indetectáveis em fotos.
Para que o classificador não fique em dúvida dentre raças semelhantes, foi decidido
juntar essas raças em uma única categoria, por exemplo, tanto malamutes como
huskys foram considerados como husky.
O resultado obtido utilizando o modelo com um classificador é uma lista com
as possíveis raças e o grau de confiança de cada classificação. Para cada cachorro,
serão armazenadas duas possíveis raças e seus graus de confiança, desde que a
segunda possível raça tenha um grau de confiança maior do que 10%. Isso será
feito pois o classificador pode, ao classificar uma foto de um shih-tsu, retornar 50%
de confiança para lhasa e 40% para shih-tsu. Utilizando apenas uma raça, apenas
26
os donos de lhasas perdidos serão informados sobre este shih-tsu perdido.
Utilizando duas raças, os donos de shih-tsus também serão informados. Esse
método também possibilita uma melhor classificação de vira-latas, visto que vira-
latas são cachorros sem raça específica, mas podem ser muito similares a outras
raças.
Assim como na detecção de objetos, será utilizada a transferência de
aprendizado no treinamento dos modelos de classificação de imagem. Serão
treinados dois modelos, um com CreateML [22] e um com TensorFlow [23]. O mais
preciso dentre eles será utilizado no aplicativo.
27
3.2.1.2.2.1 CreateML
CreateML é uma ferramenta criada pela Apple para facilitar a criação de
modelos de aprendizado de máquina para aplicações em dispositivos iOS ou
macOS.
A transferência de aprendizado é aplicada automaticamente, e o modelo
utilizado como base é um modelo presente nos sistemas operacionais da Apple. A
grande vantagem de se utilizar CreateML é decorrente disto, o modelo gerado tem
tamanho extremamente reduzido, pois grande parte já existe no sistema operacional
e não precisa ser duplicada.
No total, 3000 fotos de cachorros foram utilizadas para treinamento e
validação. Destas fotos, 5% são aleatoriamente separadas para realizar a validação.
O modelo gerado ocupa apenas 312 KB.
A figura 19, a seguir, mostra o resultado de 23 iterações de treinamento
utilizando CreateML.
Figura 19: Resultado do treinamento de um modelo utilizando CreateML
28
3.2.1.2.2.2 TensorFlow
O TensorFlow é uma biblioteca de machine learning, código aberto,
desenvolvida pela Google e lançada em 2015. Desde então ganhou notoriedade,
sendo utilizada por empresas como Airbnb, Dropbox, ebay, Intel, Twitter e Uber.
Atualmente, TensorFlow está disponível para as linguagens Java, C, Go,
Tensorflow.js e Swift. O modelo criado com TensorFlow pode ser facilmente
convertido para os formatos utilizados por CoreML (iOS) e MLKit (Android).
Primeiramente, foi criado um classificador de imagens CNN utilizando o
tensorflow na linguagem Python, a fim de realizar testes de acurácia com o modelo
criado. Neste modelo foram utilizadas 400 imagens, extraídas do ImageNet e do
Google Images, de cada uma das 20 raças selecionadas, totalizando 8000 imagens
de cachorros enumeradas de 1 a 400 da seguinte forma: “numero_raça.jpg”. Estas
imagens foram convertidas para uma escala cinza (para a realização do pooling),
utilizando uma biblioteca chamada OpenCV, para então servirem como base para o
treinamento do modelo. Além disso, parte das imagens foram separadas para serem
utilizadas como teste de validação do modelo, apresentando a acurácia do
treinamento.
As imagens 20 a 25, a seguir, trazem trechos de código utilizado para o
treinamento do modelo.
29
Figura 20: Função para extrair a classe
30
As 400 imagens de cada raça do dataset foram renomeadas no padrão
“<Numero>_<Raça>”, no caso das imagens de Beagles, por exemplo, foram
renomeadas como “001_Beagle”, “002_Beagle, etc. Esse processo facilita a
extração da classe de cada imagem utilizada.
A função apresentada na Figura 20 tem como entrada uma imagem, para
então verificar no nome da imagem a raça do cachorro, descrita logo após o
caractere “_”. Sua saída é um array do tipo one-hot que representa a raça.
Figura 21: Função para criar o arquivo contendo os dados das imagens usadas no treinamento
Para criar os dados do treinamento é necessário percorrer todo o diretório de
treinamento, encontrando a raça do cachorro presente em cada imagem, além de
converter as imagens para um padrão de escala cinza, redimensioná-las todas para
o mesmo tamanho e finalmente transformá-las em um array correspondente aos
pixels da imgem.
Com a lista de arrays criado, é realizado uma randomização na ordem dos
mesmos, para então salvar a lista de arrays.
Figura 22: Funções de convolução e pooling
31
As funções “conv2d” e “maxpool2d” realizam a convolução das layers, e o
pooling da imagem, conforme mostrado na Figura 16.
Figura 23: Função para encontrar o custo, a acurácia e pegar o próximo batch
Durante o treinamento de uma rede neural deseja-se diminuir o custo, que é a
função distância entre a saída do modelo e o resultado esperado.
Outra função importante, diz respeito ao cálculo da acurácia do modelo,
representando o quão próximo do resultado esperado estão as predições.
Para evitar sobrecarregar a memória RAM dos dispositivos é necessário que
as imagens sejam carregadas no sistema em pequenas quantidades, chamadas de
batch, a função “get_next_batch” faz exatamente isso.
32
Figura 24: Função para gerar CNN
Conforme mostrado na Figura 17, a Convolutional Neural Network é composta
por pesos, biases, hidden layers, fully-connected layer e uma função dropout
opcional. A entrada da rede neural é um vetor que representa uma imagem, e a
saída é a múltiplicação de todos os neurônios da última camada (fully-connected
layer) pelos pesos, somados aos biases.
33
Figura 25: Função para treinar o modelo
O treinamento do modelo é realizado percorrendo todos os batches de
imagens, e colocando essas imagens como entrada na rede neural. Para cada batch
é utilizado uma função otimizadora, a fim de minimizar o custo, melhorando a
precisão do modelo. Estes procedimentos são repetidos para o número de épocas
desejado.
Ao final do treinamento é calculada a acurácia do modelo, utilizando as
predições das raças e as raças esperadas para cada imagem.
Realizando o treinamento desse modelo manteve-se uma precisão em torno
de 25%, que é muito baixa para a aplicação.
Mudando parâmetros como o número de Hidden Layers, utilizando o conceito
de dropout, que é a inutilização de alguns neurônios, mudando o tamanho do frame
(ou window) e alterando a taxa de aprendizagem é possível buscar melhores
acurácias para o classificador de imagens. O problema é que o código escrito
puramente em TensorFlow é baixo nível, portanto é fácil de se perder e cometer
algum erro. A fim de testar diferentes parâmetros no modelo de forma simples foi
criado um código utilizando TFLearn [24], que é uma biblioteca de alto nível para
Tensorflow.
34
Figura 26: CNN utilizando TFLearn
Aumentando o número de Hidden Layers, diminuindo o Learning Rate (taxa
de aprendizagem) e mudando o tamanho do frame obteve-se uma acurácia em torno
de 46%.
Mesmo variando diversos parâmetros no modelo CNN, a acurácia continuou
baixa, indicando que o problema era na baixa quantidade de imagens no dataset. A
solução adotada para aumentar a acurácia foi a utilização da transferência de
aprendizado com um modelo pré-treinado, o Inception-V3 [25]. Este modelo é um
CNN com 16 Hidden Layers e que foi treinado com o dataset do ImageNet, capaz de
classificar a imagem em 1000 classes.
A biblioteca do TensorFlow vem com um checkpoint do modelo Inception-V3 e
com um código para utilizá-lo. Nesse código é possível informar as imagens que se
deseja inserir no classificador, bem como as classes, o learning rate, o tamanho do
batch e o número de vezes que a função irá percorrer todo o dataset, também
conhecido como número de épocas.
Utilizando o Inception-V3, com as 8000 imagens de cachorros separadas por
raças, um learning rate de 0.01, tamanho do batch igual a 600 e treinando para 100
épocas obteve-se 96,5% de precisão no treinamento e 95,3% na validação.
35
Figura 27: Resultado do treinamento com TensorFlow e InceptionV3
Utilizando a biblioteca Tensorboard é possível visualizar gráficos
correspondentes à variação de loss (em porcentagem) e accuracy (variando de 0 a
1) para o modelo treinado. As figuras 28 e 29 mostram estes gráficos.
Figura 28: Loss para o modelo treinado
36
Figura 29: Accuracy para o modelo treinado
Analisando os gráficos é possível verificar que conforme o modelo foi treinado
ele diminuiu a perda (loss) como era esperado. Quanto a acurácia, verifica-se um
possível caso de overfitting utilizando os dados do treinamento, que é quando o
modelo “decora” as imagens. Entretanto, os dados de teste aumentam de forma
linear, sem a ocorrência de overfitting, que é o desejado para a aplicação.
37
4 TESTES E RESULTADOS
Durante todo o desenvolvimento do projeto, devem ser realizados testes, a
fim de validar o funcionamento de cada parte do sistema. Essa rotina de
procedimentos facilita no rastreamento e correção de eventuais erros, além de
dinamizar o desenvolvimento por modularizar as funções. Isso aumenta as
possibilidades de um funcionamento livre de falhas.
Para essa abordagem de testes, a melhor opção é trabalhar com testes
automatizados e testes unitários. O Xcode possui ferramentas para manipular esses
testes, que, aliadas à arquitetura MVVM, facilitam a implementação.
Todos os casos de teste especificados abaixo retornaram os resultados
esperados.
4.1 TESTES CAIXA PRETA
As tabelas abaixo mostram os testes que podem ser realizados do ponto de
vista do usuário (no aplicativo móvel) e o resultado esperado de tais testes. Os
testes caixa preta buscam validar o funcionamento do sistema como um todo.
Caso de Teste 01 – Registro Descrição: Verificar se um usuário
consegue se registrar na plataforma
com um novo email
Resultado esperado: O usuário deve ser
redirecionado para a tela de gerenciamento
de cães.
Caso de Teste 02 – Registro com email já cadastrado Descrição: Verificar se um usuário
consegue se registrar na plataforma
com um email que já fora previamente
cadastrado
Resultado esperado: Uma mensagem de
erro deve ser exibida ao usuário
38
Caso de Teste 03 – Autenticação com credenciais incorretas Descrição: Verificar se um usuário
consegue realizar a autenticação com
credenciais incorretas
Resultado esperado: O acesso deve ser
negado e uma mensagem de erro exibida
ao usuário
Caso de Teste 04 – Autenticação com credenciais corretas Descrição: Verificar se um usuário
consegue realizar a autenticação com
credenciais corretas
Resultado esperado: O usuário deve ser
redirecionado para a tela de gerenciamento
de cães
Caso de Teste 05 – Cadastro de cão com informações incompletas Descrição: Verificar se um usuário
autenticado consegue realizar o
cadastro de um cão na plataforma sem
preencher todos os campos
Resultado esperado: O botão para
efetuar cadastro de cães deve estar inativo
Caso de Teste 06 – Cadastro de cão Descrição: Verificar se um usuário
autenticado consegue realizar o
cadastro de um cão na plataforma
Resultado esperado: O usuário deve ser
redirecionado para a tela com informações
do novo cão
Caso de Teste 07 – Marcar cão como perdido com informações incompletas Descrição: Verificar se um usuário
autenticado consegue marcar seu cão
como perdido, sem informar o último
local e data que o cachorro foi visto
Resultado esperado: O botão para
atualizar informações do cão deve estar
inativo
39
Caso de Teste 08 – Marcar cão como perdido Descrição: Verificar se um usuário
autenticado consegue marcar seu cão
como perdido, informando o último
local e data que o cachorro foi visto
Resultado esperado: O usuário deve ser
redirecionado para a tela com informações
atualizadas do cão
Caso de Teste 09 – Relatar cão encontrado Descrição: Verificar se um usuário
consegue enviar foto e localização de
um cão ao sistema
Resultado esperado: O usuário deve ser
redirecionado para uma tela que lista cães
perdidos semelhantes ao encontrado
4.2 TESTES CAIXA BRANCA
As tabelas a seguir contêm os testes que devem ser realizados durante o
desenvolvimento do projeto a fim de verificar o funcionamento dos mesmos. Os
casos de teste 10 a 20 validam o funcionamento do conjunto API e banco de dados,
que foi apresentado no diagrama de blocos da figura 1.
Caso de Teste 10 – Registro Descrição: POST em /api/register/
com os campos name, email, phone,
password e password_confirmation
Resultado esperado: Resposta com
código 201 e usuário inserido no banco de
dados
Caso de Teste 11 – Registro incompleto Descrição: POST em /api/register/
sem enviar todos os campos
especificados para o Caso de Teste 10
Resultado esperado: Resposta com
código 422 e JSON com informações do
erro
Caso de Teste 12 – Token request, credenciais inválidas Descrição: POST em /oauth/token/
com credenciais incorretas
Resultado esperado: Resposta com
código 401
40
Caso de Teste 13 – Token request Descrição: POST em /oauth/token/
com credenciais corretas
Resultado esperado: Resposta com
código 200 e JSON com informações do
token
Caso de Teste 14 – Listar cães, usuário não autenticado Descrição: GET em /api/dogs/ sem
token de autenticação
Resultado esperado: Resposta com
código 401
Caso de Teste 15 – Listar cães, usuário autenticado Descrição: GET em /api/dogs/ com
token válido
Resultado esperado: Resposta com
código 200 e JSON com cães pertencentes
ao usuário
Caso de Teste 16 – Mostrar cão Descrição: GET em /api/dogs/{id}/ Resultado esperado: Resposta com
código 200 e JSON com cão. Caso cão
com o id informado não exista, resposta
com código 404
Caso de Teste 17 – Cadastrar cão Descrição: POST em /api/dogs/ com
token válido
Resultado esperado: Resposta com
código 201, JSON com cão e cão inserido
no banco de dados. Caso alguma
informação esteja incorreta, resposta com
código 422 e JSON com erro
41
Caso de Teste 18 – Atualizar cão Descrição: PUT em /api/dogs/{id}/ com
token válido e correspondente ao dono
do cão
Resultado esperado: Resposta com
código 200, JSON com cão e cão
atualizado no banco de dados. Caso
alguma informação esteja incorreta,
resposta com código 422 e JSON com erro
Caso de Teste 19 – Relatar cão encontrado Descrição: POST em /api/found/ Resultado esperado: Resposta com
código 201, JSON com cães semelhantes
e cão encontrado inserido no banco de
dados. Caso alguma informação esteja
incorreta, resposta com código 422 e
JSON com erro
Caso de Teste 20 – Listar cães encontrados Descrição: GET em /api/found/{raça}/ Resultado esperado: Resposta com
código 200 e JSON com cães encontrados
classificados como sendo da raça
especificada. Resposta com código 404
caso a raça seja inválida
Os casos de teste 21 a 29 são testes unitários e validam as funções das
figuras 7 a 11, que fazem o preparo de imagens e aplicam os modelos de
aprendizado de máquina.
Caso de Teste 21 – Conversão de imagem para buffer de pixels Descrição: Verifica o retorno do
método de conversão de UIImage para
CVPixelBuffer
Resultado esperado: CVPixelBuffer não
nulo
42
Caso de Teste 22 – Redimensionamento de imagem Descrição: Verificar o retorno do
método de redimensionamento de
imagem dado uma imagem com
largura igual a altura
Resultado esperado: Nenhum erro
lançado e retorna UIImage com dimensões
iguais às fornecidas como parâmetro
Caso de Teste 23 – Redimensionamento de imagem Descrição: Verificar o retorno do
método de redimensionamento de
imagem dado uma imagem com
largura diferente da altura
Resultado esperado: Lançamento do erro
ImageError.imageNotSquare
Caso de Teste 24 – Classificação de raças Descrição: Verificar o retorno do
método de classificação de raças dada
uma imagem com um cão da raça
maltês
Resultado esperado: Nenhum erro
lançado e retorna vetor que contenha uma
raça com ID “maltese”
Caso de Teste 25 – Classificação de raças Descrição: Verificar o retorno do
método de classificação de raças dada
uma imagem com um cão da raça
yorkshire
Resultado esperado: Nenhum erro
lançado e retorna vetor que contenha uma
raça com ID “yorkshire_terrier”
Caso de Teste 26 – Detecção de cachorros Descrição: Verificar o retorno do
método de detecção de cachorros dada
uma imagem que não contém
cachorros
Resultado esperado: Lançamento do erro
ImageError.noDogDetected
43
Caso de Teste 27 – Detecção de cachorros Descrição: Verificar o retorno do
método de detecção de cachorros dada
uma imagem que contém apenas um
cachorro
Resultado esperado: Nenhum erro
lançado e retorna CGRect
Caso de Teste 28 – Detecção de cachorros Descrição: Verificar o retorno do
método de detecção de cachorros dada
uma imagem que contém dois ou mais
cachorros
Resultado esperado: Lançamento do erro
ImageError.multipleDogsDetected
Caso de Teste 29 – Redimensionamento de imagem Descrição: Verificar o retorno do
método de recortar imagems
Resultado esperado: Retornada UIImage
com dimensões iguais à do CGRect
fornecido como parâmetro
44
4.3 TESTES DE APRENDIZADO DE MÁQUINA
Os testes dos modelos de aprendizado de máquina são realizados com
auxílio das próprias bibliotecas de treinamento. As bibliotecas automaticamente
dividem o grupo de imagens de treinamento para utilizar parte delas como referência
de validação ao decorrer das iterações do treinamento, porém ainda deve ser feita
uma avaliação da acurácia dos modelos treinados.
4.3.1 Detecção de objetos
Para a detecção de objetos, as caixas delimitadoras são criadas
manualmente, com precisão humana, logo, é estatisticamente impossível que o
modelo treinado consiga predizer exatamente a caixa delimitadora de cada imagem
para a avaliação. Por conta disto, é utilizado o Índice de Jaccard (também conhecido
como IoU – intersection over union, que é a intersecção da união, da teoria de
conjuntos) para avaliar a saída do modelo. O índice de Jaccard nos fornece um valor
de 0 a 100%, sendo 0% quando não há intersecção entre a caixa delimitadora
predefinida e a caixa obtida do modelo, e 100% quando as duas caixas são
idênticas. A figura 30, abaixo, traz exemplos do índice de Jaccard para diversas
caixas geradas pelo modelo (marcadas como prediction).
Figura 30: Exemplos de Índice de Jaccard – Fonte: TuriCreate [19]
Neste projeto, foi escolhido, arbitrariamente, o valor de 75% como threshold
para classificar um resultado como correto.
Utilizando 150 novas imagens para esta avaliação (nenhuma das 750
imagens utilizadas para treinamento e validação foram reutilizadas), o modelo
45
obteve uma precisão de 82%, que significa que 82% das predições possuem um
índice de Jaccard maior do que 75%. Vale ressaltar que mesmo resultados que
foram considerados incorretos ainda conseguem ser utilizados para classificar a raça
corretamente, o classificador é treinado para ser capaz de classificar imagens
mesmo se grande parte do cachorro não estiver enquadrada.
4.3.2 Classificação de imagens
Para a avaliação dos modelos, foram utilizadas 400 fotos (novamente,
nenhuma das fotos utilizadas para treinamento e validação são utilizadas para
avaliação).
O modelo treinado com CreateML atingiu uma precisão de 84% (336 acertos)
e o modelo treinado no TensorFlow atingiu 95.5% (382 acertos). O modelo gerado
com TensorFlow foi cerca de 10% mais preciso do que o modelo do CreateML, logo,
foi escolhido para ser integrado no aplicativo. A única desvantagem do modelo do
TensorFlow é o tamanho do arquivo, 87.5 MB, em contraste aos 312KB do modelo
do CreateML.
Um estudo de caso feito por Russakovsky [26] determinou que a precisão
média de humanos para classificação de imagens é de, aproximadamente, 95%,
então pode-se considerar que o modelo é preciso o suficiente para a aplicação.
46
5 CONCLUSÃO A criação de um ecossistema para facilitar o encontro de animais perdidos foi
motivada pela atual dificuldade de alertar uma comunidade sobre a perda, e contatar
o dono de um animal doméstico encontrado. O método convencional de identificação
animal se mostra ineficiente em relação ao processo, pois depende do
deslocamento do bicho até um local que possua um leitor compatível com os
microchips implantados. A criação de uma plataforma que não depende do
deslocamento e dos leitores aumenta significativamente a possibilidade de animais
perdidos voltarem para a suas casas. É um fato que os aparelhos de telefone celular
são muito populares e que em sua maioria possuem câmeras, portanto não existem
impeditivos técnicos para a utilização da plataforma.
A plataforma atingiu os objetivos propostos com sucesso, porém ainda
existem aspectos que poderiam ser melhorados. Os modelos de aprendizado de
máquina podem ser treinados com conjuntos de imagens maiores, para aumentar a
precisão da detecção de cães em imagens. Estes modelos também podem ser
treinados para identificar outros animais, como gatos e suas diversas raças.
Também poderia ser desenvolvida uma versão do aplicativo para dispositivos
Android, visto que todo o projeto foi feito visando a compatibilidade com outros
sistemas operacionais.
47
REFERÊNCIAS
[1] Petfinder - Why Microchip Your Pet? Disponivel em: https://www.petfinder.com/dogs/lost-and-found-dogs/why-microchip/
[2] Dias, Celso F. Microchips em animais de estimação. Disponível em: http://www.petbr.com.br/infor22.asp
[3] Band News. 50 mil cães nas ruas em Curitiba. Disponível em: https://bandnewsfmcuritiba.com/50-mil-caes-nas-ruas-em-curitiba-ajuda-da-sociedade-e-fundamental-para-controlar-a-situacao/
[4] AnimallTag. Disponível em: http://animalltag.com.br
[5] Virbac. BackHome. Disponível em: https://www.backhome.com.br
[6] Abrachip. Disponível em: http://www.abrachip.com.br
[7] MePerdi. Disponível em: http://www.meperdi.club
[8] NFC21. Dog Tap. Disponível em: https://dog-tap.com/en
[9] QRBicho. Disponível em: http://qrbicho.com.br
[10] Apple. A12 Bionic. Disponível em: https://www.apple.com/iphone-xs/a12-bionic/
[11] Laravel. Disponível em: https://laravel.com
[12] Apple. Xcode. Disponível em: https://developer.apple.com/xcode/
[13] Apple. Swift. Disponível em: https://developer.apple.com/swift/
[14] Rojas, R. Neural Networks chapter 3. Disponível em: http://www.inf.fu-berlin.de/inst/ag-ki/rojas_home/documents/1996/NeuralNetworks/K3.pdf
[15] Chaudhuri, S. Image Processing. Disponível em: http://graphics.stanford.edu/courses/cs148-10-summer/docs/04_imgproc.pdf
[16] Stanford University – Computer Science Department. CS231n – Convolutional Neural Networks for Visual Recognition. Disponível em: http://cs231n.github.io/convolutional-networks/
[17] ImageNet. Disponível em: http://image-net.org/
[18] Perez, S. G. Simple Image Annotator. Disponível em: https://github.com/sgp715/simple_image_annotator
[19] Apple. TuriCreate. Disponível em: https://github.com/apple/turicreate
[20] Redmond, J. et al. You Only Look Once: Unified, Real-Time Object Detection Disponível em: https://arxiv.org/abs/1506.02640
48
[21] Stanford. Stanford Dogs Dataset. Disponível em: http://vision.stanford.edu/aditya86/ImageNetDogs/
[22] Apple. CreateML. Disponível em: https://developer.apple.com/documentation/createml
[23] Google. TensorFlow. Disponível em: https://www.tensorflow.org
[24] TFLearn. Disponível em: http://tflearn.org
[25] Szegedy, C. et al. Rethinking the Inception Architecture for Computer Vision. Disponível em: https://arxiv.org/abs/1512.00567
[26] Russakovsky, O. et al. ImageNet Large Scale Visual Recognition Challenge. Disponível em: https://arxiv.org/abs/1409.0575
