Você está na página 1de 98

SERVIÇO PÚBLICO FEDERAL

MEC - SETEC
INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIA E TECNOLOGIA DE
MATO GROSSO - CAMPUS CUIABÁ
DEPARTAMENTO DE ELETORELETRÔNICA
BACHARELADO EM ENGENHARIA DE CONTROLE E AUTOMAÇÃO

LUIZ FERNANDO SEDREZ ROSSATO

Navegação Autônoma de Veículos Via Rede Neural


Convolucional e Detecção de Sinais de Trânsito utilizando
YOLO

Cuiabá - MT
Fevereiro 2019
Dados Internacionais de Catalogação na Publicação CIP)
Biblioteca Orlando Nigro – Campus Cuiabá
Jorge Nazareno Martins Costa – CRB1 - 3205

R823d Rossato, Luiz Fernando Sedrez

Navegação autônoma de veículos via rede neural convolucional e detecção de sinais de


trânsito utilizando yolo / Luiz Fernando Sedrez Rossato . – Cuiabá: Ifmt, 2019.
103f., il. ; 30 cm.

Orientação : Prof. Dr. Mário Anderson de Oliveira

Trabalho de Conclusão de Curso (Engenharia de Controle e Automação ) – Instituto Federal de Educação,


Ciência e Tecnologia de Mato Grosso, Departamento da Área de Eletroeletrônica .

Inclui referência.

1. Redes Neurais Convolucionais. 2. Redes Neurais – Sistemas embarcados . I.


Oliveira , Mário Anderson de (Orientador). II. Titulo

001.64404
CDD –
CDU – 004.8
LUIZ FERNANDO SEDREZ ROSSATO

Navegação Autônoma de Veículos Via Rede Neural


Convolucional e Detecção de Sinais de Trânsito utilizando YOLO

Trabalho de Conclusão de Curso


apresentado ao Departamento da Área de
Eletroeletrônica do Curso Superior de
Bacharelado em Engenharia de Controle e
Automação, do Instituto Federal de
Educação, Ciência e Tecnologia de Mato
Grosso, Campus Cuiabá – Octayde Jorge
da Silva, como requisito para a obtenção
do título de Bacharel em Engenharia de
Controle e Automação.

Orientador: Prof. Dr. Mário Anderson de Oliveira

Cuiabá - MT
Fevereiro 2019
Ao meu pai, minha mãe, meus amigos e ao
meu amor Loyse Fiametti.
AGRADECIMENTOS

A meus pais que sempre me incentivaram e apoiaram, além de me dar apoio


financeiro

Aos meus amigos que sempre me ajudaram e apoiaram para que eu conseguisse
concluir o Curso

A minha namorada Loyse Fiametti, por todo apoio emocional, e por ajuda concluir este
TCC

A todos os professores do IFMT que me proporcionaram o conhecimento ao longo do


curso

Ao meu orientador, Prof. Dr. Mario Anderson de Oliveira, pela oportunidade que me
deu de trabalhar com ele, pela sua compreensão e pela dedicação em me ajudar a
concluir este trabalho.

Ao Instituto Federal de Educação, Ciência e Tecnologia – IFMT, ao Departamento da


Área de Informática e ao Departamento da Área de Eletroeletrônica, por cederem um
laboratório para a realização das pesquisas. Também, aos técnicos e terceirizados do
IFMT pelo suporte dado durante todo meu processo de formação acadêmico.

À PROIC-IFMT-CBA/DPIEx, pelo apoio financeiro do projeto aprovado no edital


019/2018, com a compra de materiais que permitiram a viabilidade da pesquisa.
RESUMO

Veículos autônomos têm se tornando uma nova tendência tecnológica, a qual


promete grandes benefícios para a humanidade tais como redução significativa de
acidentes e mortes no trânsito, redução de trânsito, menos gastos com multas, maior
conforto e conveniência. Até o presente momento diversas tecnologias têm sido
utilizadas no desenvolvimento dos mesmos: sensores, câmeras e sistemas de freios
potentes, permitindo que o carro entenda o mundo ao seu redor. O custo de alguns
sensores, como o LIDAR, faz com que se busquem alternativas mais baratas no
desenvolvimento de carros autônomos. Assim, um dos candidatos para substituir o
LIDAR são as câmeras conjuntamente com técnicas de visão computacional. As
Redes Neurais Convolucionais (CNNs) são modelos de aprendizado de máquina que
têm alcançado resultados promissores em uma variedade de diversas tarefas de visão
computacional. Neste sentido, este trabalho propõe o uso da CNN para detecção das
bordas de pistas a fim de guiar o veículo de forma autônoma em um determinado
trajeto e, a utilização do YOLO (You Only Look Once) para detecção de sinais de
trânsito em tempo real. Experimentos práticos conduzidos revelam que as CNNs são
capazes de aprender a seguir uma pista ou estrada apenas a partir de imagens de
suas bordas. Já o YOLO mostra-se uma ferramenta poderosa e rápida para detecção
de objetos em tempo real sendo esta tarefa considerada crucial para condução
autônoma de veículos.

Palavras-chave: Carros Autônomos, Redes Neurais Convolucionais, Redes Neurais


embarcados em Raspberry PI, Detecção de objetos, YOLO.
ABSTRACT

Self-driving cars have become a new trend in the technology which promises great
benefits to humanity, like a significant reduction in traffic accidents and deaths, less
traffic, less traffic fines, more comfort and convenience. Nowadays, there are several
technologies involved in its operation, such as sensors, cameras and powerful brake
systems, making cars understand the world around itself. The cost of some sensors,
like LIDAR, has demanded cheaper alternatives. Hence, one of LIDAR's replaceable
candidates is the cameras along with the computer vision. The Convolutional Neural
Network (CNNs) are Machine Learning models that have achieved outstanding results
in a variety of computer vision tasks. In this sense, this work proposes the use of CNNs
to detect the runaway edges to guide the vehicle autonomously in a certain route. Also,
YOLO (You Only Look Once) is employed to detect traffic signals in real time. We
carried practical experiments out, revealing that CNNs can learn how to follow a track
or road with only images of its edges. Furthermore, YOLO shows a powerful and fast
tool to detect objects, in real time, in which it considers a crucial task for autonomous
driving.

Keywords: Autonomous Cars, Convolutional Neural Network, Neural Networks


embedded in Raspberry PI, Object Detection, YOLO.
LISTA DE ILUSTRAÇÕES

Figura 1 – Raspberrry Pi 3 Model B .................................................................... 17


Figura 2 - Mapa Dos Pinos Gpio Raspberry Pi 3 ................................................ 19
Figura 3 - Representação De Uma Rede Neural Simples E Rede Neural De
Aprendizagem Profunda. .................................................................................... 21
Figura 4 - Um Único Neurônio ............................................................................ 22
Figura 5 - A Saída De Um Neurônio Sigmoid. .................................................... 23
Figura 6 - A Saída De Um Neurônio Tanh. ......................................................... 23
Figura 7 - A Saída De Um Neurônio Relu. .......................................................... 24
Figura 8 – Rede Neural Feedforward De Camada Única. ................................. 25
Figura 9 – Rede Neural Feedforward De Múltiplas Camadas. ............................ 25
Figura 10 – Ilustração Do Algoritmo Do Gradiente Descendente. ...................... 27
Figura 11 – Representação Matriz Rgb .............................................................. 29
Figura 12 – Número De Conexões Entre Camadas Aumenta Conforme O
Tamanho Da Imagem. ........................................................................................ 30
Figura 13 - Ilustração Da Convolução Entre Um Filtro 3x3 E A Entrada. ........... 31
Figura 14 – Mapa De Recurso Resultante Da Convolução. ............................... 31
Figura 15 - Aplicação De Max Pooling (2x2) Em Uma Imagem 4x4. .................. 32
Figura 16 – Arquitetura De Uma Rede Neural Convolucional Comum. .............. 33
Figura 17 – Imagem De Entrada Dividida Em Grades ........................................ 34
Figura 18 – Elementos De Uma Caixa Delimitadora .......................................... 34
Figura 19 – Exemplo Objetos Pertencentes Em Células Individuais De Classe. 35
Figura 20 – Dois Objetos Com O Mesmo Centro Na Grade De Célula. ............. 35
Figura 21 – Duas Saídas Para Uma Célula De Grade. ...................................... 36
Figura 22 – Exemplificação Iou (Intersection Over Union). ................................. 36
Figura 23 – Exemplo De Supressão Não Máxima. ............................................. 37
Figura 24 – Arquitetura Yolo. .............................................................................. 38
Figura 25 - Taxa De Visualização De Tópicos De Programação Na Stackoverflow.
............................................................................................................................ 39
Figura 26 - Plataformas De Hardware Que O Tensorflow Trabalha. .................. 41
Figura 27 – Etapas Da Metodologia Utilizada Para A Navegação Via Cnn. ...... 45
Figura 28 – Carrinho De Controle Remoto Utilizado. .......................................... 46
Figura 29 – Motores Presente No Chassi Do Carrinho. ...................................... 46
Figura 30 - Partes Removidas Do Carrinho. ....................................................... 47
Figura 31 – Placa Mdf Inserida No Lugar Do Suporte De Pilhas. ....................... 47
Figura 32 – Pinagem Driver Ponte H L298n. ...................................................... 48
Figura 33 – Ponte H Colocado No Interior Do Veículo Com Os Motores
Conectados......................................................................................................... 49
Figura 34 – Câmera E Raspberry Pi Colocadas Em Cima Do Carrinho. ............ 50
Figura 35 – Bateria 18650 Lítio Samsung........................................................... 50
Figura 36 - Conversor De Tensão Dc-Dc Step-Up Xl6009. ................................ 51
Figura 37 – Sistema De Alimentação Raspberry Pi 3. ........................................ 51
Figura 38 – Sistema De Alimentação Driver Ponte H L298n. ............................. 52
Figura 39 – Sistema De Alimentação Do Hardware No Carrinho. ...................... 52
Figura 40 – Protótipo Final Do Veículo Concebido Para Testes. ........................ 53
Figura 41 – Esquema Da Comunicação Entre O Computador E O Raspberry ... 54
Figura 42 – Primeira Pista. ................................................................................. 55
Figura 43 – Segunda Pista (Metade Pista Oval). ................................................ 55
Figura 44 – Caixa Criada Pelo Modulo Tkinter .................................................. 56
Figura 45 – Parte Dos Comandos Armazenados ............................................... 56
Figura 46 – Parte Do Conjunto De Dados Pronto Para O Treinamento. ............ 57
Figura 47 – Modificações Na Arquitetura Da Nvidea. ......................................... 59
Figura 48 – Arquitetura Da Cnn Proposta Para Navegação Autônoma. ............. 60
Figura 49 – Sinais De Trânsito (Placa Pare E Semáforo). .................................. 60
Figura 50 – Imagens Renomeadas ..................................................................... 61
Figura 51 – Formato Das Anotações De Cada Imagem ..................................... 61
Figura 52 – Desenho Da Caixa No Objeto.......................................................... 63
Figura 53 – Transferência De Aprendizagem ..................................................... 63
Figura 54 – Arquitetura Tiny Yolo Voc Pré-Treinada. ......................................... 64
Figura 55 – Novo Modelo Tiny Yolo Para 4 Classes. ......................................... 65
Figura 56 – Arquitetura Tiny Yolo Modificada. .................................................... 66
Figura 57 – Resultados Teste Do Modelo Cnn Para O Conjunto De Dados 1.... 69
Figura 58 - Análise De Desempenho Da Cnn Para O Conjunto De Dados 2: (A)
Acurácia Para As Fases De Treinamento E Teste Em Função Do Número De
Épocas; (B) Taxa De Perda Para As Fases De Treinamento E Teste Em Função
Do Número De Épocas. ...................................................................................... 71
Figura 59 – Resultados Teste Modelo Cnn Para O Conjunto De Dados 2. ........ 72
Figura 60 – Realização Do Teste Na Pista 1 ..................................................... 72
Figura 61 – Realização Do Teste Na Pista 2 ...................................................... 73
Figura 62 - Análise De Desempenho Da Cnn Para O Conjunto De Dados 3 (A)
Acurácia Para As Fases De Treinamento E Teste Em Função Do Número De
Épocas; (B) Taxa De Perda Para As Fases De Treinamento E Teste Em Função
Do Número De Épocas. ...................................................................................... 74
Figura 63 – Resultados Teste Modelo Cnn Para O Conjunto De Dados 3. ........ 75
Figura 64 – Representação Da Forma Da Pista ................................................. 76
Figura 65 – Imagem Do Rotulo “Frente” Para Visualização Do Mapa De Recursos.
............................................................................................................................ 77
Figura 66 – Saída Mapa De Recursos Da Primeira Camada Convolucional. ..... 77
Figura 67 – Saída Mapa De Recursos Da Segunda Camada Convolucional ..... 78
Figura 68 – Saída Mapa De Recursos Da Terceira Camada Convolucional. ..... 79
Figura 69 – Saída Mapa De Recursos Da Quarta Camada Convolucional. ....... 79
Figura 70 – Saída Mapa De Recursos Da Quinta Camada Convolucional. ........ 80
Figura 71 – Mapa De Recurso De Cada Camada Convolucional Da Classe
“Direita”. .............................................................................................................. 80
Figura 72 – Mapa De Recurso De Cada Camada Convolucional Da Classe
“Esquerda”. ......................................................................................................... 80
Figura 73 – Resultados Confiabilidade Rede Yolo Primeira Base De Dados ..... 81
Figura 74 – Resultado Confiabilidade Rede Yolo Segunda Base De Dados. .... 82
Figura 75 – Resultado Confiabilidade Rede Yolo Segunda Base De Dados ...... 83
LISTA DE TABELAS

TABELA 1 - COMPARAÇÃO DOS MODELOS E GERAÇÕES DO RASPBERRY PI


.................................................................................................................................. 18
TABELA 2 – ESPECIFICAÇÕES TÉCNICAS PONTE H L298N ............................... 48
TABELA 3 – ATIVAÇÃO DOS MOTORES ATRAVÉS DOS PINOS DE ENTRADA . 49
TABELA 4 – LIGAÇÕES ENTRE RASPBERRY PI 3 E DRIVER PONTE H L298N.. 53
TABELA 5 – RÓTULOS PARA CLASSIFICAÇÃO CNN ........................................... 58
TABELA 6 – COMPOSIÇÃO DOS CONJUNTO DE DADOS OBTIDOS ................... 67
TABELA 7 -DIVISÃO CONJUNTO DE DADOS 1 E RESULTADOS DO
TREINAMENTO ........................................................................................................ 68
TABELA 8 - DIVISÃO CONJUNTO DE DADOS 2 E RESULTADOS DO
TREINAMENTO ........................................................................................................ 70
TABELA 9 - DIVISÃO CONJUNTO DE DADOS 2 E RESULTADOS DO
TREINAMENTO ........................................................................................................ 74
LISTA DE ABREVIATURAS

RPi Raspberry Pi
CNN Convolutional Neural Network
DNN Deep Neural Network
DL Deep Learning
IA Inteligência Artificial
RELU Rectified Linear Unit
Sumário

1. Introdução ..................................................................................................... 12

1.1. Objetivo Geral ............................................................................................. 14

1.2. Objetivos Específicos .................................................................................. 14

1.3. Justificativa ................................................................................................. 15

1.4. Organização do trabalho ............................................................................. 16

2. Fundamentação Teórica............................................................................... 17

2.1. Raspberry Pi ............................................................................................... 17

2.1.1 GPIO ...................................................................................................... 19

2.2. Aprendizagem Profunda (Deep Learning) ................................................... 20

2.2.1 Rede Neurais Artificiais .......................................................................... 21

2.2.2 Redes Neurais Feedforward .................................................................. 24

2.2.3 Processo de aprendizagem.................................................................... 26

2.2.4 Underfitting e Overfitting ........................................................................ 28

2.3. Redes Neurais Convolucionais (CNN) ..................................................... 28

2.3.1 Arquitetura CNN .......................................................................................... 33

2.4. You Only Look Once (YOLO) ...................................................................... 33

2.4.1 Arquitetura YOLO........................................................................................ 37

2.5. Python......................................................................................................... 38

2.5.1 TensorFlow ............................................................................................ 40

2.5.2 Keras ..................................................................................................... 41

2.5.3 Tkinter .................................................................................................... 42

2.5.4 Socket .................................................................................................... 42

2.5.5 OpenCv.................................................................................................. 42

2.5.6 Numpy ................................................................................................... 43

2.5.7 Matplotlib ............................................................................................... 43

3. Metodologia .................................................................................................. 45

3.1. Construção do Veiculo ................................................................................ 46


3.2. Aquisição do conjunto de dados.................................................................. 53

3.3. Treinamento da Rede Neural Convolucional ............................................... 57

3.4. Detecção de Objetos com YOLO ................................................................ 60

4. Resultados e Discussão............................................................................... 67

4.1. Performance da CNN aplicada a Navegação Autônoma ............................. 67

4.1.1 Primeira fase de Testes ......................................................................... 68

4.1.2 Segunda fase de Teste .......................................................................... 70

4.1.3 Terceira fase de Testes ......................................................................... 73

4.2. Parte interna da CNN .................................................................................. 76

4.3. Confiabilidade da Detecção de Objetos com YOLO .................................... 80

4.4. Dificuldades ................................................................................................ 83

5. Considerações Finais................................................................................... 85

5.1. Conclusões ................................................................................................. 85

5.2. Propostas para Trabalhos Futuros .............................................................. 86

Referências ............................................................................................................. 88
12

1. Introdução

Atualmente a condução autônoma de veículos tem se tornado cada vez mais


popular, onde se há uma corrida tecnológica acirrada entre empresas, as destaca-se
Google, Tesla, Uber, GM, Ford, Apple, Renault dentre outros. Há muitos candidatos
competindo, mas quem largou na frente foi a Waymo, que faz parte do grande
aglomerado da Google para projetos de carros autônomos. Seu trabalho iniciou-se em
2008, sendo que no ano de 2018 a empresa anunciou o Jaguar I-Pace, um veículo
autônomo cuja expectativa é que se tenha 20 mil unidades nas ruas até 2020
(GALVÃO, 2018). Até o presente momento, nenhuma montadora lançou um veículo
totalmente autônomo, valendo salientar que segundo a Sociedade Internacional de
Engenheiros Automotivos (SAE Internacional) há seis níveis de automação: nesta
escala o nível 0 não possui nenhuma automação, sendo assim o motorista realiza
todas as funções de controle do carro, já o nível 5 a automação é total, onde não há
nenhuma interferência humana permitindo que o veículo seja capaz de dirigir sozinho,
em qualquer situação adversa. Embora este nível ainda não tenha sido atingido por
nenhuma companhia (UDACITY, 2018), a NVIDIA (NVIDIA, 2017) que produz boa
parte do hardware dos veículos autônomos, anunciou um supercomputador com
inteligência artificial que tornaria possível a automação nível 5. Atualmente a maioria
dos veículos autônomos em testes se encontram em nível 3, no qual há uma
automação condicional onde um sistema autônomo tem total liberdade de conduzir o
veículo em situações e ambientes específicos, mas em situações climáticas não
favoráveis ou trafego intenso, transfere o controle ao motorista (SANTOS, 2018). O
primeiro veículo autônomo no mundo nível 4 é o SYMBIOZ da Renault, revelado na
França, este possui alta automação, onde não há nenhuma intervenção humana e,
este é capaz de monitorar tudo que acontece em sua volta. Atualmente em muitos
países é permitido apenas que se façam testes, supervisionado por um motorista, com
veículos de nível 4. A expectativa é que veículos deste nível apareçam no mercado
em 2022, dependendo das aprovações dos governos de cada país (MORRIS, 2018).
Para o funcionamento de um veículo autônomo faz-se necessárias diversas
tecnologias como sensores, câmeras e sistemas de freios potentes. Entre os sensores
aparece o radar, que utiliza ondas de rádio para detecção de objetos de 10 a 100
metros de distância. Este sistema é comumente utilizado para ACC (Adaptive Cruise
13

Control), sendo que neste sistema o veículo acelera ou freia de acordo com o tráfego
a sua frente, além de evitar colisão frontal. Também, o mesmo identifica pontos cegos
e possível aproximação de pedestres a sua volta (MARSHALL, 2018). Outro sensor
bastante utilizado é o LIDAR. Este utiliza o mesmo princípio de funcionamento do
RADAR, ao invés de ondas de rádio, se utiliza laser, capaz de criar um mapa 3D
preciso com 360º graus entorno do veículo (FERREIRA, 2017). Uma das grandes
vantagens do Radar é seu bom funcionamento em condições climáticas adversas
como chuva, neve e neblina, casos onde o uso de câmeras e o LIDAR são ineficientes
(BARNARD, 2018). O sucesso do LIDAR para navegação autônoma consiste no seu
enorme alcance, cerca de 500 metros, permitindo prever com antecedência os limites
das pistas, ou se há sinais de trânsito e semáforos a frente além de conseguir detectar
objetos e obstáculos a sua volta (CAMERON, 2017). Em contraste, as câmeras
surgem como uma alternativa mais barata que o LIDAR, que tem um custo alto.
Câmeras são capazes de fornecer maiores detalhes além de ótima resolução bem
como permitem identificar sinais de trânsito e linhas das pistas (DAVIES, 2018). Elon
Musk (CEO da TESLA) é o maior entusiasta no uso de câmeras para condução de
veículos autônomos e, segundo ele, as câmeras podem realizar o trabalho com
precisão e consequentemente não há necessidade de se utilizar o LIDAR. O mesmo
acredita que as câmeras podem fazer o papel do olho humano com bastante acurácia
(JONES, 2018). Câmeras são sensores que fornecem apenas imagens e, para o
processamento dos sinais atualmente tem-se utilizado técnicas de aprendizado
profundo ou redes neurais para classificação do que é cada imagem representa e
tomar a decisão do que o veículo deve fazer. Tal processamento é realizado de forma
semelhante ao nosso cérebro, demandando assim um hardware poderoso para a sua
implementação (AUTOPILOT REVIEW, 2018).
Atualmente a utilização de redes neurais com aprendizado profundo tem se
tornado cada vez mais importante, principalmente na área da visão computacional, no
qual as redes neurais convolucionais (Convolutional Neural Networks - CNN) têm sido
utilizadas nas mais diversas aplicações. Marr (2018) explica que o aprendizado
profundo ensina máquinas a realizar tarefas que requer a inteligência humana, sendo
estas capazes de aprender assim como nós humanos. Para detecção e classificação
de imagens a CNN é considerada a mais promissora ferramenta, pois sua habilidade
de “enxergar” e classificar imita o cérebro humano em uma maior totalidade
(SAMPATH, 2018). A Nvidia, dois anos atrás, publicou uma demonstração de um
14

veículo autônomo utilizando a CNN. Eles realizaram testes em um circuito traçado,


onde o veículo permaneceu totalmente autônomo em 98% do percurso e, precisou da
intervenção humana em apenas 2% mostrando ser muito promissor. Porém, ainda
não se pode considerar a aplicação mais segura que um ser humano. A tecnologia da
CNN é considerada ainda muito recente na área de automação de veículos (ARYA,
2018),(WELLING, 2018). A fim da identificação em tempo real de forma rápida
obstáculos, o YOLO (You Only Look Once) é considerado uma tecnologia recente,
onde se utiliza a CNN como base. Diferentemente, a imagem passa apenas uma vez
pelas camadas sendo que os objetos são delimitados por uma caixa. O YOLO possui
alta confiabilidade além de se apresentar como uma tecnologia rápida e precisa
(CHABLANI, 2017).

1.1. Objetivo Geral

O presente trabalho tem como objetivo geral o desenvolvimento de um protótipo


de navegação autônoma de veículo utilizando CNN para sua navegação, e realizar a
identificação de sinais de trânsito via YOLO.

1.2. Objetivos Específicos

Para alcançar o objetivo geral, foram considerados os objetivos específicos


abaixo:
• Construir um protótipo de carro integrando o Raspberry Pi 3 em conjunto com
uma câmera;
• Criar um percurso para a navegação do veículo;
• Utilizar a linguagem Python e algumas bibliotecas: TensorFlow (Google), Keras
e OpenCV, para implementação, treinamento e teste da CNN;
• Comunicar computador e Raspberry Pi 3 via servidor para enviar imagens da
câmera em tempo real para identificação de sinais de trânsito;
• Desenvolver o algoritmo de controle do veículo e a associação de comandos
com as imagens utilizadas para o treinamento da CNN;
• Embarcar Bibliotecas no Raspberry Pi 3 a fim de utilizar a rede treinada para
navegação autônoma do veículo;
15

• Fazer sinais de trânsito, treinar a rede YOLO para sua identificação e testá-la
para tomadas de ações.

1.3. Justificativa

Este trabalho visa comprovar a vasta utilização da CNN, além de mostrar sua
aplicabilidade na condução autônoma de veículos, tecnologia esta que está se
aproximando cada vez mais de nossa realidade cotidiana. Neste contexto, tornam-se
indispensáveis estudos que abordam este tema no sentido de trazer os diversos
benefícios da direção autônoma tais como a redução de acidentes de trânsito
causados por falhas humanas, redução de trafego nas vias, conforto, mobilidade para
deficientes (físicos e visuais) para a vida cotidiana das pessoas.
A criação do protótipo integra diversas disciplinas estudadas ao longo do
presente curso: inteligência artificial, eletrônica analógica, microcontroladores,
eletrônica de potência, controle, sistemas embarcados e linguagens de programação.
Esta multidisciplinaridade faz com que esta pesquisa seja de extrema importância,
possibilitando ao estudante aprimorar e aplicar os seus conhecimentos em
experiências de aplicações práticas.
Em suma, estudar redes CNN permite ao estudante ter a vivência de
tecnologias recentes que certamente estará embarcada nos veículos autônomos que
estão/serão produzidos mundo afora. Recentemente, apesar do seu enorme
potencial, ainda há dúvidas da sua confiabilidade quando se trata de emprega-la em
veículos autônomos, pois implica em utilizar um computador para todas tomadas de
decisões durante a locomoção. Por isso, a realização de pesquisas e testes são
passos mais que necessários no sentido de se ter uma aplicação minimamente segura
aos usuários dos veículos autônomos.
A detecção de objetos é considerada uma tarefa crucial para a condução
autônoma. Além de exigir alta precisão para garantir a segurança, a detecção de
objetos para condução autônoma também requer velocidade de inferência em tempo
real para garantir controle rápido do veículo. Neste sentido a rede YOLO tem se
mostrando uma ferramenta bastante confiável para esta função.
16

1.4. Organização do trabalho

Este trabalho está estruturado em cinco capítulos conforme segue:

• Capítulo 1: Introdução, objetivos e justificativas para o presente trabalho;


• Capítulo 2: São apresentados os conceitos sobre Raspberry pi, Redes
Neurais Artificiais, especificando a sua formação, arquitetura e os processos de
aprendizagem. Também são apresentados conceitos acerca da CNN e YOLO.
E por últimos alguns aspectos relevantes sobre Python e suas bibliotecas;
• Capítulo 3: Apresenta a metodologia utilizada para obtenção dos
resultados e também os materiais utilizados neste trabalho;
• Capítulo 4: São apresentados e discutidos os resultados obtidos em
testes de navegação realizados em pistas além da confiabilidade do YOLO em
detecção de objetos.
• Capítulo 5: Apresenta as considerações finais e as propostas para os
trabalhos futuros.
17

2. Fundamentação Teórica

Neste capítulo serão abordados os conceitos sobre Raspberry Pi, importante


hardware para o funcionamento da navegação autônoma. Também são apresentados
os conceitos sobre redes neurais artificiais e CNN. Além disso, serão abordados os
principais conceitos sobre o YOLO (You Look Only Once), uma poderosa ferramenta
em visão computacional para detecção e classificação de imagens em tempo real. Por
último um breve histórico sobre Python e suas poderosas bibliotecas para
manipulação de imagens e criação de redes neurais.

2.1. Raspberry Pi

O Raspberry Pi (Figura 1) é um pequeno computador de placa única,


inicialmente criado para promover o estudo em ciências da computação em escolas
de nível básico e secundário no Reino Unido. Este foi construído pela Raspberry Pi
Foundation em conjunto com a Universidade de Cambridge (CARDOSO, et al. 2013).
Devido seu baixo custo, surgiu então a ideia de disseminar o conhecimento da área
da ciência da computação para os países ainda em desenvolvimento. Rapidamente
houve um grande interesse da comunidade acadêmica e este transcendeu as
fronteiras das universidades principalmente devido a este ser um computador de
pequena dimensão, simples e de baixo custo. Imediatamente surgiram diversas
aplicações de pequenas escalas (THE PI, 2017).

Figura 1 – Raspberrry Pi 3 Model B

Fonte: (RASPBERRY, 2018).


18

Seu sistema operacional foi baseado em Linux, entre os mais populares o


Debian, que para o Raspberry Pi foi chamado de Raspbian. O Raspian está disponível
de forma gratuita no site oficial do Raspberry Pi. O Raspbian fornece acesso fácil a
todas as funcionalidades além de permitir o uso de poderosas linguagens de
programação como C e Python, permitindo aos iniciantes aprender programação e
execução desde projetos simples até os mais complexos (DUTTA, 2015).
Atualmente o Raspberry Pi é considerado como catalisador para engenheiros,
fabricantes e startups lançarem novos experimentos e, tem sido utilizado para
diversas aplicações: robôs, drones e etc (HINNER ,2017). Além de possuir baixo
custo, seu sucesso se deu também por ser pequeno, leve e de baixa potência. Este
ainda conta com diversas portas logicas e comunicação I2C. Ferramentas essas que
são úteis desde aplicações simples, como acender LEDs, até aplicações complexas,
como utilização de sensores, controle de motores com aplicação em robótica,
sistemas de segurança doméstica inteligente dentre outras. A última geração foi
lançada foi em fevereiro de 2016 ( Raspberry Pi 3). Este possui um processador quad-
core 1,2 Ghz, rede sem fio e Bluetooth. A Tabela 1 apresenta uma comparação entre
as gerações e modelos do Raspberry Pi (HITALTECH, 2018).

Tabela 1 - Comparação dos modelos e gerações do Raspberry Pi


Raspberry Pi 3 Raspberry Pi 2 Raspberry Pi Raspberr Raspberr
Modelo B Modelo B Modelo B + y Pi Modelo A + y Pi Zero e Zero W
Processador Processador Processador
Processador quad- Processador quad
Chipset do Broadcom Broadcom Broadcom
core Broadcom core Broadcom
Processador BCM2835 de 32 BCM2835 de 32 BCM2835 de 32
BCM2837 de 64 bits BCM2837 64 bits
bits bits bits
Velocidade do
1,2 GHz 900 MHz 700 Mhz 700 Mhz 1 GHz
processador
RAM 1 GB 1 GB 512 MB 256 MB 512 MB
Armazenamento MicroSD MicroSD MicroSD MicroSD MicroSD
1 porta
Saída 4 portas USB 4 portas USB 4 portas USB 1 porta USB
micro-USB
GPIO 40 pinos 40 pinos 40 pinos 40 pinos 40 pinos
Conexão de Rede Sim sim sim Não Não
Não (zero) / sim
Wi-fi Sim Não Não Não
(zero W)
Bluetooth Sim Não Não Não Não
Fonte: ThePi (2017)

O modelo B+ é a versão mais atual do Raspberry Pi 3 e este conta com algumas


melhorias, em relação ao antecessor, tais como processador Quad Core 1,4Ghz, rede
sem fio mais rápida e bluetooth 4.2, além de um HDMI com melhor resolução de vídeo
(RASPBERRY, 2018).
19

2.1.1 GPIO

O Raspberry Pi (RPi) possui uma capacidade de se conectar diretamente com


uma vasta variedade de dispositivos eletrônicos. Além das conexões já conhecidas
como as portas USB, Ethernet e HDMI, ele possui pinos GPIO (General Purpose
Input/Output) cuja sua função é fazer comunicação de entrada e saída de sinais
digitais (TERJE, 2018), (ARAUJO, 2014). Um dos pontos fracos do RPi consiste na
ausência de entradas e saídas analógicas que são bastante úteis em aplicações que
empregam sensores analógicos. Para suprir essa deficiência, conversores
Analógicos/Digitais (DA) externos devem ser usados quando se trabalha com
sensores analógicos (BAPTISTA, 2014).
Os pinos GPIO podem ser utilizados facilmente com a linguagem Python e a
documentação da sua biblioteca para esta linguagem é encontrada no site oficial do
RPi. Também há uma lista de todos os comandos para usufruir das portas lógicas,
pinos para comunicação serial, PWM, I2C (Inter-Integrated Circuit) e SPI (Serial
Peripheral Interface bus) (Taylor, et al. 2015). RPi 2 e RPi 3 possuem 40 pinos e
seguem a pinagem mostrada na Figura 2.

Figura 2 - Mapa dos Pinos GPIO Raspberry Pi 3

Fonte: (Clay,2017)
20

O RPi pode fornecer energia de 5 volts (pinos 2 e 4), 3,3 volts (pinos 1 e 17) e
cerca de 500 mA de corrente, já os pinos de aterramento (GND) são: 6, 9, 14, 20, 25,
30, 34 e 39.
A GPIO padrão é capaz de fornecer 3,3 volts em nível alto (HIGH) e 0 volts
quando o pino está em nível baixo (LOW). Podem ser utilizadas também como entrada
de no máximo 3,3 volts, que o pino irá ler como nível alto (HIGH), os pinos para as
finalidades citadas são praticamente todos, exceto os de alimentação e os pinos 27 e
28 (Buckley, 2018).
O PWM (Pulse Width Modulation) no qual é cotidianamente utilizado para se
controlar a quantidade de tensão enviada a um LED ou servo motores, por exemplo,
está disponível nos pinos 12 e 35 (Rezende, 2017).
O SPI permite que dispositivos se comuniquem com o RPi de forma síncrona,
ou seja, diversos dados passando entre mestre e escravo. Existem vários dispositivos
e extensões que utilizam à comunicação SPI, como o Sense HAT produto oficial da
comunidade Raspberry Pi que fornece uma matriz de LED e uma ampla variedade de
sensores (Buckley, 2018). O I2C permite uma comunicação assíncrona utilizada em
dispositivos como DAC ou LCD.

2.2. Aprendizagem Profunda (Deep Learning)

Aprendizagem Profunda é uma área importante dentro da inteligência artificial.


Consiste numa subcategoria de aprendizado de máquina (Machine Learning), que usa
redes neurais de várias camadas, para que de forma precisa realize diversas tarefas
como detecção de objeto, reconhecimento de fala e tradução de idiomas (NVIDIA,
2018). O funcionamento do Deep Learning basicamente consiste em inserir muitos
dados em um sistema de computador, a partir destes dados as maquinas “aprendem”
de forma automática, extraindo características e verificando padrões, por fim
classificando-as de acordo com a finalidade designada (MARR, 2016).
O aprendizado das maquinas se dá por meio da implantação de redes neurais,
cuja estrutura é baseada no cérebro humano. Nesta estrutura cada neurônio é uma
fórmula matemática que é alimentado por dados na camada de entrada e a previsão
final é gerada na camada de saída. Toda rede neural possui estas camadas (entrada
e saída) (HEATH, 2018). O termo aprendizagem profunda provem das várias camadas
ocultas entre a camada de entrada e saída e, normalmente são mais que 3 camadas.
21

As camadas ocultas, de entrada e saída, são representadas na Figura 3, nas cores


amarela, vermelha e azul respectivamente.

Figura 3 - Representação de uma rede neural simples e rede neural de aprendizagem profunda.

Fonte: (RAJAT,2018)

Camadas ocultas são capazes de extrair características em cada camada,


como por exemplo, reconhecimentos visuais onde os neurônios da primeira camada
podem aprender a reconhecer bordas, já a segunda camada pode aprender formas
mais complexas como quadrado ou triângulo, assim por diante, tornando essas redes
profundas propícias a aprender e resolver problemas complexos (NIELSEN, 2018).

2.2.1 Rede Neurais Artificiais

As redes neurais artificiais consistem num conjunto de algoritmos, inspiradas


nas redes neurais do cérebro humano, as quais interpretam dados por meio de um
tipo de percepção de máquina, rotulagem ou agrupamento de entrada bruta. As redes
neurais artificiais reconhecem padrões numéricos, contidos em vetores, agrupando e
classificando dados do mundo real, como imagens, sons e textos (SKYMIND, 2016).
Um neurônio artificial consiste na unidade básica da rede neural, na qual o
mesmo calcula a soma ponderada de entradas de outros nós ou de uma fonte externa
e em seguida, aplica uma função de ativação para normalizar a soma (GUPTA, 2017).
Cada entrada tem um peso associado (w), que é atribuído de acordo com sua
importância relativa para outras entradas. Um neurônio artificial pode ser representado
conforme a Figura 4. Sendo 𝑥1 , 𝑥2 , … , 𝑥𝑛 as entradas numéricas, e 𝑤1 , 𝑤2 , … , 𝑤𝑛 ,
22

representam seus pesos. Há outra entrada b chamada Bias (UJJWAKARN, 2016).


Bias é uma constante que ajuda o modelo a se adequar melhor aos dados fornecidos
sendo utilizado para aumentar ou diminuir a entrada da função de ativação
(OLIVEIRA, 2005).

Figura 4 - Um único neurônio

Fonte: (GUPTA, 2017).

A saída do neurônio é calculada como mostra a Figura 4. A função de ativação


ƒ é não linear e introduz a não linearidade na saída de um neurônio. Isso se deve ao
fato de que a maioria dos dados do mundo real não é linear. As funções de ativação
basicamente decidem se um neurônio deve ser ativado ou não, ou seja, se há ou não
há alguma informação relevante que o neurônio está recebendo (GUPTA, 2017). As
três principais funções de ativação utilizadas são: Sigmoid (Φ), tanh e ReLU (Rectified
Linear Unit).
A função do neurônio Sigmoid é dada pela Equação 1.

1
Φ(z) = (1)
1 + 𝑒 −𝑧

Esta função é utilizada em modelos para prever probabilidades pois a saída


sempre estará no intervalo entre (0,1), ou seja, se o valor de entrada (z) for pequeno
se aproximara de 0, caso for muito grande se aproximara de 1. Entre esses dois
extremos, o neurônio assume a forma representada na Figura 5.
23

Figura 5 - A saída de um neurônio Sigmoid.

FONTE: BUDUMA, 2017

O neurônio tanh se assemelha com o Sigmoid logístico, mas ao invés de


intervalo entre (0,1), utiliza intervalo entre (-1,1). Sua vantagem é que as entradas (z)
negativas serão mapeadas dentro do intervalo negativo e as entradas (z) zero serão
mapeadas próximas a zero (Figura 6). Sua função é dada por 𝑓(𝑧) = tanh(𝑧).

Figura 6 - A saída de um neurônio tanh.

FONTE: BUDUMA, 2017

A ReLU é a função de ativação usada em quase todas as CNN ou redes de


aprendizado profundo, tornando-a atualmente a função mais utilizada. Ao comparar a
ReLU com a Sigmoid e tanh ela é seis vezes mais rápida (Krizhevsky et al. 2012). A
principal vantagem da função ReLU é que nem todos os neurônios são ativados ao
mesmo tempo, pois qualquer entrada (z) negativa será convertida em zero, portando,
o neurônio neste caso não será ativado. Com apenas alguns neurônios sendo
ativados, torna-se a rede mais espalhada, fazendo com que a mesma seja mais
24

eficiente (GUPTA, 2017). A função de ativação ReLU é dada pela função 𝑓(𝑧) =
max(0, 𝑧) e seu gráfico está representado na Figura 7.

Figura 7 - A saída de um neurônio ReLU.

FONTE: BUDUMA, 2017

Quando não se tem a função de ativação, o peso e o bias simplesmente fazem


uma transformação linear. Embora uma equação linear seja simples de resolver, mas
esta é limitada em relação a sua capacidade de resolver problemas complexos.

2.2.2 Redes Neurais Feedforward

Os neurônios individuais são considerados poderosos, mas não são tão


expressivos para resolução de problemas complexos de aprendizagem. Por exemplo,
um único neurônio não seria capaz de diferenciar dígitos manuscritos. A fim de lidar
com tarefas desta complexidade que as arquiteturas de redes neurais empregam o
uso de vários neurônios (BUDUMA, 2017).
Existem duas categorias principais de arquiteturas de rede, na qual depende
do tipo de conexões entre os neurônios. Se não houver realimentação (feedback) das
saídas em direção as entradas em toda a rede, então a rede referida é a rede neural
feedforward. Caso houver a retroalimentação, isto é, uma conexão sináptica das
saídas em direção as entradas, a rede é chamada de rede neural recorrente (SAZLI,
2006). As redes neurais feedforward dividem-se em duas categorias, em relação ao
número de camadas, camada única ou de camadas múltiplas. A Figura 8 ilustra uma
rede neural feedforward de camada única. A camada de entrada não é considera pois
não há nenhuma computação sendo executada nessa camada.
25

Figura 8 – Rede Neural feedforward de camada única.

Fonte: (SAZLI, 2006).

A Figura 9 representa a Rede Neural feedforward de múltiplas camadas ou


Redes Multilayer Perceptron (RMP). Esta rede possui três tipos de camadas: entrada,
oculta e de saída. A camada de entrada fornece informações do mundo externo para
rede (nenhuma computação é executada nos nós de entrada). Elas apenas fazem a
transmissão para os nós ocultos. A camada oculta executa os cálculos e transferem
as informações dos nós de entradas paras os nós de saídas. Por fim a camada de
saída é responsável por cálculos e transferência de informações para o mundo externo
(UJJWAKARN, 2016).

Figura 9 – Rede Neural feedforward de múltiplas camadas.

Fonte: (SAZLI, 2006)


26

Tanto na Figura 8 como na Figura 9, as redes estão totalmente conectadas,


pois cada neurônio de cada camada está conectado com os outros neurônios da
próxima camada.
As redes RMP são modelos de redes profundas (deep learning) mais utilizadas
para desempenho de tarefas, pois os neurônios ocultos presentes permitem a rede
extrair características de ordem superior, tornando-as mais úteis. Ademais, o
perceptron de camada única só pode aprender funções lineares, já um perceptron de
múltiplas camadas aprende funções não lineares.

2.2.3 Processo de aprendizagem

Entre vários algoritmos de aprendizado, o Back-Propagation é o mais popular


e o mais muito utilizado para o treinamento de redes neurais Feedforward. Este
algoritmo consiste basicamente em aprender com erros. O objetivo do aprendizado é
ajustar parâmetros (pesos e bias) a fim de conseguir o menor erro possível. Para
treinar uma rede classificadora necessita-se prover dados rotulados, para que o
algoritmo possa calcular e ajustar os parâmetros minimizando assim os erros. Ao final
do treinamento espera-se que a rede tenha generalizado os dados para classificação
correta de elementos de fora do conjunto de dados de treinamento.
Inicialmente os pesos e bias são atribuídos aleatoriamente para cada entrada
de dados na rede e, e, seguida os neurônios artificiais são ativados e a sua saída é
observada. Essa saída é comparada com a saída que já conhecemos, gerando um
erro que é propagado de volta (Back-Propagation) para a camada anterior. A partir do
erro anotado, os pesos e bias são ajustados. Este processo é repetido até que o erro
de saída esteja abaixo de um limite predeterminado. Durante o treinamento o conjunto
de dados inteiro é passado para frente e para trás através da rede neural, este
processo quando realizado uma vez, denomina-se uma “época” (epoch).
O algoritmo conhecido como gradiente descendente consiste no método de
otimização mais popular para ajuste dos pesos e bias na rede objetivando reduzir o
erro na camada de saída por meio de uma função de custo. Esta função objetiva
monitorar o erro das previsões da rede neural. A função de custo utilizada para
minimizar o erro, possui diferentes tipos sendo o mais utilizado o custo quadrático
27

(Equação 2). Onde o 𝑤 são todos os pesos na rede, 𝑏 todos os bias, 𝑛 é o número
total de entradas de treinamento, 𝑎 é o vetor de saídas da rede e, 𝑥 é a entrada.

1
C(w, b) = ∑ ||𝑦(𝑥) − a ||2 (2)
2𝑛
𝑥

Os pesos e bias iniciam-se de forma aleatória, e o gradiente descendente


começa no ponto de início (Figura 10) e em seguida, um passo (cálculo) após o outro
ele move na direção mais acentuada para baixo, ou seja, até chegar ao ponto em que
a função de custo for a menor possível (DONGES, 2018). O gradiente de uma função
multivariável consiste num vetor na direção mais íngreme desta função em relação
valor da função de custo.

Figura 10 – Ilustração do algoritmo do gradiente descendente.

Fonte: (MLXTEND, 2017).

A equação (3) descreve o que a descida de gradiente faz. Onde 𝑏 será a próxima
posição do gradiente, 𝑎 representa a posição atual, o sinal negativo refere-se a parte
de minimização do gradiente de descida, o 𝛾 é um fator de espera, e o termo ∇ f(a) é
o gradiente que consiste em um vetor de direção íngreme.

b = a – γ ∇ f(a) (3)
28

2.2.4 Underfitting e Overfitting

Uma rede neural para ser considerada ótima não pode generalizar demais os
dados de treinamento, porém não pode ser muito especifico, sendo assim deve manter
o balanço entre os dois termos. Existem dois conceitos em Machine Learning que
resume bem cada situação: Underfitting e Overfitting.
Underfitting refere-se ao um modelo que não aprendeu muito bem os dados de
treinamento, e também não conseguiu generalizar para os dados de testes. Sua
ocorrência significa que o modelo não se ajustou bem aos dados. Geralmente isso
acontece quando há poucos dados de treinamento para construir um modelo preciso,
ou quando estamos tentando treinar um modelo linear com dados não-lineares. O
Underfitting pode ser evitado empregando maior quantidade de dados e também
alterando alguns parâmetros internos da rede.
Overfitting refere-se a um modelo que aprendeu muito bem o conjunto de dados
de treino, mas quando este modelo treinado é aplicado a um conjunto de teste obtém-
se um desempenho insatisfatório. Isso pode ocorrer quando se utiliza muitos dados
na geração do modelo, fazendo com que a rede passe a considerar atributos que não
deveria. Então, o modelo não categoriza os dados corretamente devido ao excesso
de detalhes e ruídos. Nesse caso devemos deixar o algoritmo mais livre para
conseguir generalizar melhor, aumentando dados que ofereçam situações ruins. Vale
ressaltar que nem sempre uma alta taxa de acerto no conjunto de treinamento diz
necessariamente que acontecerá o overfitting.

2.3. Redes Neurais Convolucionais (CNN)

Redes neurais convolucionais (CNN) é um subconjunto de aprendizado


profundo as quais foram concebidas baseadas no estudo de Hubel e Wiesel (1968)
sobre córtex visual de animais. Importante salientar que este é composto por milhões
de agrupamentos celulares complexos chamados de campos receptíveis (MANSANO,
2017). Uma das primeiras aplicações bem-sucedidas com a CNN foi em 1989 quando
LeCun et al. (1998), treinou uma CNN para reconhecer dígitos escritos a mão. Este
trabalho pioneiro foi nomeado LeNet (LECUN et al., 1998). Após um longo período,
em 2012, surgiu a AlexNet (Krizhevsky, 2012) uma versão mais profunda e ampla da
29

LeNet (LECUN et al., 1998) que fez a CNN se popularizar abrindo caminho para a
concepção de diversas outras arquiteturas como a OverFeat (SERMANET et al.,2013)
e GoogLeNet (SZEGEDY et al., 2015) (CULURCIELLO, 2017). Atualmente as redes
CNN são amplamente usadas principalmente para classificar imagens, reconhecer
objetos dentro de cenas, identificar rostos, sinais de transito e muitos outros aspectos
dos dados visuais (PRABHU, 2018).
A visão humana inicia-se nos olhos, mas a interpretação do que vemos
acontece no córtex visual primário, que consiste em uma estrutura hierárquica
profundamente complexa de neurônios e conexões no cérebro, nos permitindo, assim,
lembrar e rotular objetos (CORNELISSE, 2018). Nós humanos aprendemos a
classificar objetos desde crianças, de maneira semelhante funciona os computadores
fazendo necessário mostrar a um algoritmo imagens para aprender a classifica-la. A
maneira que os computadores “enxergam” é bem diferente da nossa, sendo que o
mundo dos computadores consiste apenas em números, cada imagem é representada
em matrizes bidimensionais de números (pixels).
O tamanho da matriz irá depender do tamanho da imagem, por exemplo, uma
imagem de dimensões 6x6x3, representando respectivamente altura, largura e o
canal, onde o valor 3 são as cores vermelho, verde e azul (RGB – Red, Green e Blue)
(representada na Figura 11). Esta figura mostra 3 matrizes 2D empilhadas (uma para
cada cor), cada uma com valores de pixel entre 0 a 255, por exemplo, a mistura das
3 cores em valor mínimo (0,0,0) resulta na cor preta, em valor máximo (255,255,255)
resulta na cor branca (KARN, 2016).

Figura 11 – Representação Matriz RGB

Fonte : (PRABHU, 2018)


30

Redes neurais regulares possuem uma arquitetura diferente das CNN. Redes
Neurais regulares recebem uma entrada (em único vetor) e a transformam através de
uma série de camadas ocultas. Cada camada possui um conjunto de neurônios, e
cada neurônio está totalmente conectado a todos os demais neurônios da camada
anterior. A última camada está totalmente conectada e é chamada de camada de
saída, que representa as previsões (CORNELISSE, 2018). Redes Neurais regulares
não se tornam atrativas quando se trata de imagens maiores e coloridas (Figura 12).
Em um conjunto de dados de imagens preto e branco de dimensões 28 x 28, um único
neurônio na camada oculta totalmente conectada teria uma entrada de 784 pesos,
esta quantidade é gerenciável do ponto de vista computacional, mas claramente a
estrutura de uma rede neural regular não é dimensionada para imagens maiores. Por
exemplo, uma imagem colorida de dimensões 200 x 200, teria uma camada de entrada
de 200 x 200 x 3 = 120.000 pesos. Com vários neurônios em múltiplas camadas os
parâmetros iriam se acumular, sendo assim, essa total conectividade seria um
desperdício e o grande número de parâmetros poderia levar rapidamente ao
overfitting. A rede CNN é vantajosa para lidar com imagens, pois restringe
sensatamente a arquitetura da rede profunda, reduzindo drasticamente o número de
parâmetros em um modelo (BUDUMA, 2017).

Figura 12 – Número de conexões entre camadas aumenta conforme o tamanho da imagem.

FONTE: BUDUMA, 2017

A camada convolucional é executada nos dados de entrada com uso de filtros


ou kernel, para produzir um mapa de características. Cada filtro possui uma dimensão
bem menor que o dado de entrada, estendendo-se em toda sua profundidade
(ARAÚJO. et al 2017). A convolução é executada deslizando o filtro sobre a imagem
31

de entrada, produzindo um mapa de ativação bidimensional que fornece as


informações do filtro em todas as posições espaciais, ou seja, a rede aprenderá filtros
que são ativados quando reconhecem algum recurso visual relevante (KARPATH,
2017). A função de ativação não linear mais utilizada nas CNN é a ReLU. A Figura 13
mostra uma imagem de três dimensões (RGB) como entrada em uma camada
convolucional. Nesta é aplicado um filtro 3x3 gerando um pixel de saída.

Figura 13 - Ilustração da convolução entre um filtro 3x3 e a entrada.

Fonte: ARAÚJO. et al 2017

Ao final do processo de convolução, aplicando o filtro por toda a imagem,


a saída produzida é uma matriz denominada mapa de característica (Figura 14). O
tamanho do mapa é controlado por três parâmetros: profundidade, stride (Passos) e
zero-padding (preenchimento zero).

Figura 14 – Mapa de recurso resultante da convolução.

Fonte : (PRABHU, 2018)

A profundidade corresponde ao número de filtros utilizados para operação de


convolução. O Stride é para especificar o passo em que o filtro irá deslizar na imagem,
32

quando o stride é 1, o filtro movera um pixel por vez, quando o stride é 2, o filtro irá
mover 2 pixels por vez, isso produzirá saídas menores (KARPATH, 2017). As vezes o
filtro não se encaixa perfeitamente em uma imagem de entrada, sendo assim é
aplicado o zero-padding, que preenche as bordas com valores de pixels iguais a 0
(PRABHU, 2018).
Um conceito importante presente nas CNNs é o compartilhamento de pesos,
na qual permite que em vez da rede aprender pesos específicos para cada região da
imagem, ela aprenda apenas um conjunto de filtros menores que poderá ser aplicado
a todas as regiões da imagem, reduzindo o número de parâmetros (KARPATH, 2017),
(WANG et al., 2012). Uma camada muito utilizada nas CNN é o pooling
(agrupamento), com o objetivo de reduzir de maneira agressiva a dimensionalidade
dos mapas de recursos, retendo as informações mais importantes (BUDUMA, 2017).
O pooling pode ser de diferentes tipos, sendo o mais utilizado o Max Pooling que dividi
uma matriz do mapa de recurso em uma dimensão e pegando o valor máximo da
região, conforme mostrado na Figura 15. Outra técnica bastante utilizada nas CNNs é
o dropout, que consiste em ignorar neurônios durante o processo de treinamentos, e
tem como objetivo de reduzir overffiting.

Figura 15 - Aplicação de max pooling (2x2) em uma imagem 4x4.

Fonte : (PRABHU, 2018)

As últimas camadas de uma CNN são as camadas totalmente conectadas que


é uma Rede Multilayer Perceptron (RMP) tradicional cujo objetivo é pegar os recursos
de nível alto obtidas das camadas convolucionais e pooling, e classificá-las em várias
classes, com base no conjunto de dados de treinamento (UJJWAL 2016).
33

2.3.1 Arquitetura CNN

Os conceitos definidos na seção 2.3 são utilizados em conjuntos formando a


arquitetura de uma CNN. A Figura 16 representa uma CNN completa para
classificação de dígitos, onde a imagem de entrada passa pela primeira camada
convolucional, depois pela subamostragem (Max pooling), e depois se repete,
chegando na camada totalmente conectada para fazer a predição. Nota-se que ao
longo da rede o tamanho da imagem diminuiu, bem como o número de parâmetros.
Neste processo extraem-se as características mais relevantes da imagem nas
camadas de convolução e subamostragem (como maior eficiência em relação as
redes neurais regulares). Observa-se que na primeira camada de convolução, para
uma dada imagem de entrada onde se utiliza quatro filtros distintos, têm-se quatro
mapas de características diferentes (UJJWAL 2016).

Figura 16 – Arquitetura de uma rede neural convolucional comum.

Fonte: (GOODFELLOW et al., 2016).

2.4. You Only Look Once (YOLO)

YOLO é um algoritmo de detecção de objetos baseado em


aprendizagem desenvolvido por Joseph Redmon e Ali Farhadi (REDMON, et al.
2016) na Universidade de Washington. O Funcionamento do YOLO consiste em
pegar uma imagem de entrada, passa-la por uma rede neural semelhante a uma
CNN e obter um vetor de caixas delimitadoras e predições de classe na saída
(AGRAWAL, 2017).
34

A imagem de entrada é dividida em grades S x S de células (Figura 17) e, caso


o centro de um determinado objeto estiver presente nesta célula de grade, a mesma
será responsável por sua previsão. As células preveem caixas delimitadoras e, a
pontuações de confiança de cada caixa se configura em uma porcentagem de certeza
de o objeto estar contido em uma dada caixa (REDMON, et al. 2016).

Figura 17 – Imagem de entrada dividida em grades

Fonte: (REDMON, et al. 2016)

A previsão de uma caixa delimitadora contem 5 componentes: bx, by, bw, bh e


a confiança (Figura 18). O bx e by representam o centro, relativo à localização da
célula da grade. O bw e bh representam respectivamente a largura e altura da caixa
delimitadora. A confiança determina como classe está presente na caixa delimitadora.

Figura 18 – Elementos de uma caixa delimitadora

Fonte: (Zhang, 2018)

Para exemplificar como se é associado os objetos pertencentes em células


individuais de classe, a Figura 19 foi dividida em grades, onde a classificação do
35

veículo localizado mais à direita, é realizada de maneira fácil, pois sua caixa
delimitadora está dentro da célula de grade. Já a caixa delimitadora da camioneta
cruza várias células de grade, para a localização o algoritmo YOLO pega o ponto do
meio da caixa delimitadora e o associa à célula da grade que o contém (ZHANG, 2018)
. Ainda na Figura 19 o parâmetro “pc” significa se há ou não há objetos, caso não
houver, ignora todos os demais parâmetros.

Figura 19 – Exemplo objetos pertencentes em células individuais de classe.

Fonte: (Zhang, 2018)

A identificação de dois objetos (Figura 20) em uma mesma célula grade torna-
se possível com o uso do conceito de caixas de âncora.

Figura 20 – Dois objetos com o mesmo centro na grade de célula.

Fonte: (REDMON, et al. 2016)

A ideia da caixa de ancoragem é acrescentar mais uma “dimensão” aos rótulos


de saída, onde as mesmas são pré-definidas antes do treinamento. A forma da saída
36

irá conter informações de dois objetos em cada célula de grade ao invés de uma,
conforme mostrado na Figura 21 (SHARMA, 2018). As predefinições das caixas
âncora podem ser de variadas formas, para que o modelo se especialize melhor,
durante o treinamento, podendo assim detectar objetos mais amplos como o carro, ou
mais altos como pedestres.

Figura 21 – Duas saídas para uma célula de grade.

Fonte: (Zhang, 2018)

A confiança do objeto é definida por: Pr(Objeto) ∗ IOU, se não existir nenhum


objeto na célula de grade a pontuação de confiança este deve ser zero, caso houver
objeto a pontuação de confiança deve ser igual à interseção sobre união (IOU) entre
as caixa prevista e a verdade básica (REDMON, et al. 2016). IoU (Intersection over
Union) é usada para calcular a interseção sobre a união da caixa delimitadora real e
a caixa prevista (Figura 22) : IoU = Área da intersecção / Área da união, caso o IoU
for maior que 0,5 pode-se considerar uma boa previsão, porém o nível de avaliação é
variada de acordo com o problema proposto (SHARMA, 2018).

Figura 22 – Exemplificação IoU (Intersection over Union).

Fonte: (SHARMA, 2018).


37

O YOLO não procura regiões interessadas em uma imagem que pode conter
algum objeto, em vez disso, divide a imagem em grades de células, em uma imagem
com 19 x 19 grades, onde cada célula será responsável por prever 5 caixas
delimitadoras gerando assim um número alto de 1805 caixas (MAJ, 2018). A maioria
dessas caixas terá pontuação de confiança muito baixa, uma delimitação de 30% faz
com que limpe caixas indesejadas, pois a probabilidade de determinado objeto estar
ali ou não, é muito baixa. O valor da delimitação pode ser alterado dependendo do
detector (HOLLEMANS, 2017). O conceito de limpeza denomina-se supressão não
máxima (Non-Max-Suppression) (Figura 23).

Figura 23 – Exemplo de supressão não máxima.

Fonte: (HOLLEMANS, 2017)

2.4.1 Arquitetura YOLO

A arquitetura YOLO é inspirada pelo modelo da GoogLeNet (SZEGEDY et al.,


2015), possuindo 24 camadas convolucionais e 2 camadas totalmente conectadas
(Figura 24). As camadas convolucionais irão extrair características das imagens
enquanto as totalmente conectadas irão prever as probabilidades e as coordenadas
das caixas (REDMON, et al. 2016). O YOLO possui várias versões, onde atualmente
está na versão 3. Também há arquitetura denominadas Fast Yolo a qual utiliza menos
camadas convolucionais e filtros.
38

Figura 24 – Arquitetura YOLO.

(REDMON, et al. 2016)

A diferença entre YOLO e CNN está explicita na última camada, na qual em


uma CNN a última camada é totalmente conectada com as predições designadas, já
o YOLO a última camada é um volume, definindo a divisão da grade (7x7) com o
número de canais (Profundidade). Isso é calculado considerando a relação entre o
número de caixa delimitadoras por células de grade B = 2 e pelo número de classes
(C). A arquitetura da Figura 24 fora construída para 20 classes. Utilizando a formula
(𝐵 ∗ 5 + 20), onde o número 5 representa os elementos (bx, by, bw, bh e confiança),
chega-se no resultado de 30 canais (MENEGAZ,2018). Tais cálculos para última
camada variam, de acordo com as classes e arquitetura utilizada para treinamento da
rede YOLO.

2.5. Python

Python foi criado por Guido Van Rossum no final dos anos 80 e sua primeira
versão 0.9.0 foi lançada em 1991. Assim como outras linguagens de programação, o
Python possui várias versões e atualmente se encontra na versão 3.x (WOLFE, 2018).
Com a popularização da linguagem Python, em 2001 foi criada a Python Software
Foundation (entidade sem fins lucrativos), mantida com patrocínios de grandes
empresas como a Google e a Microsoft. Esta possui uma grande comunidade aberta
para que a linguagem de programação se mantenha em constante evolução (SILVA,
2018).
39

A linguagem de programação Python é considerada de alto nível e de fácil


aprendizagem, onde a mesma consegue ligar com cenários complicados permitindo,
assim, que iniciantes foquem em aprender conceitos de programação e não se
preocupem com muitos detalhes. Também é uma linguagem versátil que possui mais
de cento e trinta mil bibliotecas de terceiros, fazendo essa linguagem ser
extremamente proveitosa para destinos específicos como, por exemplo,
desenvolvimento de web, processamento de imagem e até mesmo aplicações de
Deep Learning (RAMOS, 2018).
Essa linguagem é apenas interpretada, não compilada, o que a torna mais lenta
e requer mais tempo para teste, uma vez que acusa erros apenas quando é
executada. Por esse motivo, Python é linguagem que é acessível em diferentes
plataformas, sendo assim, basta ter um interpretador para poder processá-la em
qualquer sistema (RAMOS, 2018) (SOLUTIONS, 2017).

Figura 25 - Taxa de visualização de tópicos de programação na StackOverFlow.

Fonte: (RAMOS, 2018)

Assim a importância que Python tem para a inteligência artificial (IA) engloba
todas as vantagens do próprio Python. Por ser uma linguagem de fácil aprendizagem
ela proporciona acessibilidade para desenvolvedores que não estão ligados à área de
40

ciência da computação deixando-os concentrados na solução de um problema invés


de codificação ou implementação. Como já dito, Python possui uma vasta opção de
bibliotecas para projeto de IA e, por ser uma linguagem de programação com código
completamente aberto, a mesma possui uma comunidade de programadores muito
ampla na solução de problemas de desenvolvimento. A Figura 25 mostra a evolução
da taxa de visualização de tópico relacionados a Python na StackOverFlow com o
passar dos anos (GALL, 2018) (NEWGENAPPS, 2017). Ademais, a flexibilidade que
o Python possui consiste num outro recurso interessante para a inteligência artificial,
considerando que ele é independente de plataforma, como já dito.

2.5.1 TensorFlow

TensorFlow é uma biblioteca desenvolvida por pesquisadores da Google Brain


Team, departamento da Google de inteligência de máquina, e é um software de código
aberto, rápido, flexível e pronto para a produção que foi utilizado para extrair
características de imagens para treinamento, aquisição de dados e previsão e
refinamento de resultados futuros (YEGULALP, 2018) (TENSORFLOW, 2015). Ele
funciona em quase todas as plataformas de hardware como, por exemplo, Unidades
Centrais de Processamento (CPUs), Unidades de Processamento Gráficos (GPUs) e
Unidades de Processamento de Tensor (TPUs) (UNRUH, 2017) (Figura 26).
De acordo com Yegulalp (2018), o TensorFlow também pode treinar e executar
reconhecimento de imagens, ser aplicados a redes neurais recorrentes e muitos
outros. Através da linguagem de programação Python, o TensorFlow opera em
conjuntos de dados que são conhecidos como nós computacionais em forma de
gráfico, cada nó reflete uma operação matemática e entre os nós tem um tensor
multidimensional. Sua aplicação está sendo utilizada em larga escala nos domínios
de Deep Learning e Machine Learning e foi usado para melhorar os recursos de
recuperação de informações de pesquisa de empresas.
41

Figura 26 - Plataformas de hardware que o TensorFlow trabalha.

Fonte: (UNRUH, 2017).

2.5.2 Keras

O Keras é uma biblioteca desenvolvida e mantida por François Chollet, um


engenheiro da Google, usando quatro princípios: modularidade, minimalismo,
extensibilidade e Python. É uma biblioteca que usa Python e se organiza através de
uma sequência de gráficos. Esta possui um design suficiente sem muita maximização
de implementação. Além disso, ela trata-se de uma plataforma flexível permitindo
assim adicionar novos componentes a ela. Ela pode ser executada no Theano ou o
TensorFlow. Quando utilizada conjuntamente com o TensorFlow, ela trabalha para
desenvolver uma rede neural mais rápida, compacta e de fácil acesso (KERAS, 2018)
(BROWNLEE, 2016).
Além de ser uma biblioteca minimalista e de fácil entendimento, o Keras é
usado para construir o modelo sequencial, camada por camada da rede neural
(ALLIBHAI, 2018).
42

2.5.3 Tkinter

O Tkinter é uma interface padrão fornecida junto com o Python e vem dentro
de um kit de ferramentas Tk, mas também pode ser instalada separadamente do
Python em algumas distribuições do Linux, como, por exemplo, o Ubuntu e o Derbian.
Foi, anteriormente, desenvolvida pela Sun Labs e é utilizado para desenvolver
Interface Gráficas de Usuário (GUI). Várias plataformas apresentam pacotes de
ferramentas diferentes, mas as operações das mesmas não se diferem muito entre
elas. Sua principal função é criar uma interface rápida e fácil de aplicativos GUI
(EFFBOT, 2018) (TOWN, 2014).
O modulo Tkinter exporta apenas classes de widgets, e tem uma programação
chamada de orientada a eventos. Assim, cada interação do usuário com o aparelho,
como, por exemplo, apertar um botão, um atalho do teclado ou até mesmo uma tarefa
concluída em segundo plano são chamadas de eventos. Assim, as funções que
executam a ação em resposta a um evento são chamadas de manipuladoras de
evento (GEEKS, 2018).

2.5.4 Socket

O Socket é uma estrutura de aplicativos do tipo cliente-servidor e é a biblioteca


responsável para realizar a comunicação entre dois processos diferentes em
máquinas iguais ou diferentes. Esse tipo de estrutura, para programadores, se parece
muito com os comandos read (ler) e write (escrever) da linguagem de programação
C++, pois funcionam da mesma maneira. Assim sua estrutura de cliente-servidor
funciona a partir do princípio que o servidor processa e executa as funções do cliente
(TUTORIALSPOINT, 2018).
Existem vários tipos de Sockets, mas não há restrições que impossibilita a
comunicação entre eles. Os Sockets mais comuns são os da interface Berkerley UNIX
C, e eles também podem ser utilizados em transações orientadas à conexão (ROUSE,
2015).

2.5.5 OpenCv

Opencv é uma biblioteca de código aberto para visão computacional,


43

processamento de imagens, Machine Learning e possui aceleração de GPU para


operações em tempo real. Ela é concebida em C, C++, Python e muitas outras
linguagens. Ele suporta o Linux, Windows e MacOS (NVIDIA, 2019). A principal
motivação para sua criação foi no sentido de buscar eficiência computacional para a
utilização de identificação de objetos, reconhecimento de rostos, classificação de
ações humanas e entre outros. Por ser uma biblioteca tão versátil para a IA, ela é
aplicada em uma ampla variedade de projetos desde costura de imagens do Street
View a vigilância e navegação e controle de carros autônomos (OPENCV, 2019).
Por ser uma biblioteca de código aberto, ela dá total autonomia para adicionar
complementos e até mesmo tornar seu projeto público e apto para venda com seu
uso. Seu primeiro lançamento foi em janeiro de 1999 e teve várias aplicações, como,
por exemplo, escaneamento de imagens, união de imagens em mapas via satélite e
web e até mesmo redução de ruídos de imagens médicas (KAEHLER; BRADSKI,
2019).

2.5.6 Numpy

O NumPy é um pacote acoplado em Python fundamental para computação. Ele


pode ser usado em uma matriz multidimensional de dados genéricos ou pré-definidos
o qual permite que o NumPy se integrar de forma fácil e rápida a uma ampla variedade
de banco de dados. Ele também inclui manipulações matemáticas, lógicas, álgebra
linear básica, Transformada de Fourier e muito mais. Ele é está sob licença BSD, o
que permite utilizá-lo com algumas restrições (NUMPY, 2018).
O cerne deste pacote está no objeto ndarray que encapsula arrays n-
dimensionais de tipos de dados homogêneos, com a exceção de matrizes de objetos
que permite guardar elementos de tamanhos diferentes, com muitas operações sendo
executadas em código compilado para desempenho (SCIPY, 2017).

2.5.7 Matplotlib

A Matplotlib é uma biblioteca de plotagem 2D do Python que produz número de


qualidade em variados formatos e também em ambientes de plataformas interativas,
44

é possível gerar gráficos, histogramas, espectros, diagramas de dispersão e muitos


outros, tornando-a uma biblioteca que facilita o desenvolvimento de plotagem 2D
(MATPLOTLIB, 2018).
Além disso, por ser uma biblioteca que tenta facilitar ao máximo as plotagens
que o usuário deseja, ela acaba se tornando uma biblioteca enorme, com muitas linhas
de código, assim ela é capaz de interagir com diferentes backends (SOLOMON,
2018).
45

3. Metodologia

Este capítulo aborda a metodologia empregada para o desenvolvimento da


navegação autônoma com a CNN e detecção de objetos utilizando YOLO. Para o
desenvolvimento do sistema de navegação autônoma utilizando a CNN, dividiu-se a
metodologia em três etapas (Figura 27). A primeira etapa consiste na montagem do
veículo que será usado para os testes da navegação via CNN. A segunda etapa é
desenvolvida em um computador, onde é realizada a coleta das imagens seguido do
treinamento da CNN. Por fim, a terceira etapa é realizada no Raspberry pi 3 onde é
embarcado o modelo treinado da CNN para realização de testes a fim de verificar a o
desempenho da CNN aplicada a navegação autônoma.

Figura 27 – Etapas da metodologia utilizada para a navegação via CNN.

Fonte: Próprio autor.


46

3.1. Construção do Veiculo

Está seção descreve todos os passos da montagem do veículo que foi utilizado
para testes das redes neurais propostas (CNN e YOLO). Também é apresentado os
principais componentes utilizados para realização do mesmo. Todo o processo de
construção foi dividido em três partes: alocação do Raspberry pi 3 junto a câmera,
sistema de controle dos motores e alimentação. A construção do veículo se deu início
com a utilização de um chassi de carrinho de controle remoto pronto (Figura 28).

Figura 28 – Carrinho de controle remoto utilizado.

Fonte: (Mercado Livre, 2019)

Junto ao chassi, dois motores de corrente continua (CC), um motor dianteiro


para controle da direção (esquerda, direita e reto), e motor traseiro para a
movimentação do veículo (Figura 29).

Figura 29 – Motores presente no chassi do carrinho.

Fonte: Próprio autor.


47

A fim de reduzir o peso do veículo e aumentar o espaço internamente foi


retirado algumas partes relacionadas a estética consideradas irrelevantes para o
projeto (Figura 31). O suporte das pilhas presente no chassi do veículo também foi
retirado e em seu lugar foi colocado uma fina placa de MDF (Medium Density
Fiberboard) (Figura 32).

Figura 30 - Partes removidas do carrinho.

Fonte: Próprio autor.

Figura 31 – Placa MDF inserida no lugar do suporte de pilhas.

Placa
MDF

Fonte: Próprio autor.

Para o controle dos motores se fez necessário o uso de uma ponte h, cuja sua
principal função é controlar o sentido dos motores (horário e anti-horário), para tal
finalidade foi escolhido o Driver Ponte H L298N. A escolha se deu devido seu fácil
manuseio e por possuir PWM (Pulse Width Modulation). Assim, por meio da variação
na largura do pulso de uma onda quadrada realizou-se o controle da velocidade dos
motores. A Tabela 2 apresenta algumas especificações do Driver Ponte H L298N.
48

Tabela 2 – Especificações técnicas ponte H L298N.


Circuito integrado do driver L298N
Quantidade de canais 2
Tensão máxima de alimentação 7 – 35v
Tensão de operação 5V
Corrente máxima por canal 2ª
Corrente máxima por entrada 36mA
digital
Potência máxima dissipada 25W
Limites de temperatura -20ºC – 135ºC
Dimensões 43mm x 43mm x 27mm
Peso 30g
Fonte: FILIPIFLOP (2013)

Os comandos para ativar os motores, controlar os sentidos e a velocidade vem


do Raspberry Pi 3. Para isso, utilizaram-se os pinos GPIO conectadas ao Driver Ponte
H L298N, a qual sua pinagem é representada na Figura 32.

Figura 32 – Pinagem Driver Ponte H L298N.

Fonte: FILIPIFLOP (2013)

• Motor A e Motor B são os conectores para a ligação dos motores CC


(Corrente Continua).
49

• Ativa MA e Ativa MB - refere-se aos pinos PWM para controle de


velocidade dos motores A e B. Quando há um jumper os pinos estarão
ligados a 5 volts, não havendo controle de velocidade.
• Ativa 5v e 5v – Há um regulador de tensão integrado a este Driver Ponte
H L298N que ao utilizar um jumper no Ativa 5v, o regulador disponibiliza
uma saída de +5v para uso externo, sendo assim não se deve alimentar
o pino 5v com outra fonte. Sem o jumper ele se torna uma entrada para
alimentação dos motores, sendo máximo 5 volts.
• 6-35v e GND são conectores para alimentação externa do drive. Utiliza-
se quando os motores conectados a ele operam entre 6 – 35 volts.
• Entrada – São pinos responsáveis pelo sentido da rotação do motor
(horário e anti-horário), sendo IN1 e IN2 para o motor A e IN3 e IN4 para
o motor B. O esquema para a ativação dos Motores A e B estão
representados na Tabela 3.

Tabela 3 – Ativação dos motores através dos pinos de entrada


Motor A Motor B
IN1 IN2 IN3 IN4

Horário 5v GND 5v GND

Anti-horário GND 5v GND 5v

Ponto Morto GND GND GND GND

Freio 5v 5v 5v 5v
Fonte: Próprio autor

A ponte H L298N foi fixada através de parafusos na parte interna do carrinho


em cima da placa de MDF e em seguida feita a ligação dos motores. Motor A
corresponde ao motor dianteiro, enquanto o motor B o traseiro conforme a Figura 33.

Figura 33 – Ponte H colocado no interior do veículo com os motores conectados.

Fonte: Próprio autor


50

O Raspberry Pi 3 foi colocado em uma case (caixa) para proteção da placa


contra impacto e para facilitar sua fixação na parte externa do veículo. Para prender o
Raspberry pi 3 se fez uso de uma fita dupla face colada na parte mais alta da carcaça
do veículo. Para a câmera utilizou-se palitos de picolé com o intuito de fazer uma
estrutura para dispor a câmera em uma posição alta e para que a mesma fique imóvel.
A estrutura foi inserida de forma centralizada em cima da case do Raspberry Pi 3. O
resultado final do protótipo é apresentado na Figura 34.

Figura 34 – Câmera e Raspberry pi colocadas em cima do carrinho.

Fonte: Próprio autor

Com o Driver Ponte H L298N e o Raspberry pi 3 instalados, o próximo passo


foi a montagem do sistema de alimentação para ambos. Para toda alimentação foi
utilizado cinco baterias 18650 de lítio da Samsung (Figura 35) com capacidade de
2200mha e 3,6v de tensão nominal.

Figura 35 – Bateria 18650 Lítio Samsung.

Fonte: Próprio autor.

De acordo com as especificações da Raspberry Foundation, o Raspberry Pi 3


necessita de uma alimentação de 5 volts e 2,5 amperes (corrente mínima). Uma fonte
51

de alimentação inferior a tais especificações pode prejudicar o funcionamento da


placa. Para cumprir as especificações consideras ideais, se fez uso de um conversor
de tensão DC-DC Step-Up Xl6009 (Figura 36) cuja função é elevar a tensão de 3,6v
da bateria de lítio 18650 para 5v. Quanto a corrente, a bateria de lítio 18650 consegue
fornecer até 4,4 amperes de maneira continua, mais que o suficiente para um bom
funcionamento do Raspberry Pi 3.

Figura 36 - Conversor de tensão DC-DC Step-Up Xl6009.

Fonte: FILIPEFLOP.

Utilizou-se três baterias de lítio 18650 conectadas em paralelo para a


alimentação do Raspberry Pi 3, aumentando assim a capacidade para 6600mha,
permitindo que o mesmo fique ligado por mais tempo para realização dos objetivos do
projeto. Para alimentação da ponte H, foram necessárias duas baterias de lítio
conectadas em série (tensão nominal de 7,2 volts para os motores). Fez-se necessário
o uso de um suporte próprio para as baterias, facilitando a remoção para carrega-las
e também para efetuar as ligações serie e paralelo exigidas. A entrada para
alimentação do Raspberry Pi 3 foi realizado via micro USB. Portando utilizou-se um
cabo com essa saída, conforme a Figura 37.

Figura 37 – Sistema de alimentação Raspberry pi 3.

Fonte: Próprio autor.


52

Para não ter a necessidade de remover as baterias para desligar o Driver Ponte
H L298N foi adicionada uma chave de liga- desliga no circuito de alimentação (Figura
38).

Figura 38 – Sistema de alimentação Driver Ponte H L298N.

Fonte: Próprio autor.

Os três suportes e o conversor DC-DC da alimentação do Raspberry foram


colocados na parte de trás do carrinho, já os outros dois suportes para a ponte H estão
fixados nas laterais (Figura 39).

Figura 39 – Sistema de alimentação do Hardware no carrinho.

Fonte: Próprio autor.

Por último, já com todos os componentes presentes no carrinho, foram


realizadas as ligações entre Raspberry e a Ponte H L298N, para isso foram utilizados
Jumpers Macho-Fêmea. As configurações (Tabela 4) foram determinadas a partir
53

Figura 2 da seção 2.1.1. É importante salientar que o GND (-) dos dois componentes
deve ser o mesmo, para que os pinos tenham a mesma referência e funcionem de
maneira correta.

Tabela 4 – Ligações entre Raspberry pi 3 e Driver Ponte H L298N.


Driver Ponte H L298N Raspberry pi 3
Ativa MA Pino 33 (GPIO 13)
IN1 Pino 11 (GPIO 17)
IN2 Pino 13 (GPIO 27)
Ativa MB Pino 12 (GPIO 18)
IN3 Pino 16 (GPIO 23)
IN4 Pino 18 (GPIO 24)
GND GND
Fonte: Próprio autor.

Com todos os passos concluídos o resultado final de toda montagem do veículo


de testes é mostrado na Figura 40.

Figura 40 – Protótipo final do veículo concebido para testes.

Fonte: Próprio autor.

3.2. Aquisição do conjunto de dados

A aquisição de dados para o treinamento da CNN iniciou-se com a comunicação


entre o Raspberry Pi 3 e um computador equipado com processor i7 2.8 Ghz, memória
54

Ram de 16 GB, placa de vídeo AMD e sistema operacional Windows 10. A


comunicação foi realizada via rede Wireless, a qual se fez uso de um roteador (D-Link
DIR-615). Para enviar e receber dados através dessa rede utilizou-se uma biblioteca
da linguagem de programação Python chamada Socket cuja função é criar uma
comunicação servidor-cliente para a transferência dos dados. Para este projeto foi
designado como servidor o computador e o cliente Raspberry pi 3. Os dados a serem
enviados do computador são os comandos para a movimentação do carrinho
montado, e os dados recebidos serão as imagens da câmera que está conectada ao
Raspberry (Figura 41). É importante ressaltar que a biblioteca Socket faz uso do tipo
de objeto “byte”, não permitindo o uso do tipo “string”, sendo assim se faz necessário
fazer a codificação (string – bytes) para enviar, e a descodificação (bytes – string) ao
receber tais dados, e também não é possível enviar e receber dados simultaneamente
em uma mesma conexão, para tal finalidade deve-se criar uma nova comunicação
utilizando outra porta da rede.

Figura 41 – Esquema da comunicação entre o computador e o Raspberry

Fonte: Próprio Autor

O processo para adquirir as fotos que serão utilizadas no treinamento foi


realizado forma manual conduzindo o carrinho na pista, enviando e salvando os
comandos um a um objetivando rotular as imagens que foram guardadas em um
arquivo (pasta). Para a realização deste método desenvolveu-se dois procedimentos,
sendo o primeiro a captura dos comandos e o segundo a aquisição das imagens.
55

Foram montadas duas pistas no piso utilizando fita crepe brancas. A primeira
foi utilizada para aquisição de dados e também para testes (Figura 42). A segunda
consiste em uma pista oval a qual foi utilizada apenas para obtenção da metade das
imagens utilizadas (Figura 43).

Figura 42 – Primeira pista.

Fonte: Próprio Autor

Figura 43 – Segunda pista (Metade Pista Oval).

Fonte: Próprio Autor

Para capturar os comandos para controle do carrinho através do teclado do


computador, foi utilizado um módulo Tkinter já embutido no Python. A função do
Tkinter é criar aplicativos GUI (Graphical User Interface) que permita a interação do
usuário com o computador. O uso do Tkinter neste projeto é para apenas criar uma
caixa (Figura 44), onde cada tecla pressionada/soltada será armazenada e enviada
ao Raspberry Pi 3.
56

Figura 44 – Caixa criada pelo modulo Tkinter

Fonte: Próprio Autor

São três teclas designadas aos movimentos do carrinho: para mover-se para
frente usa-se “w”, para direita “e” e para esquerda “q”. Cada tecla irá gerar dois
comandos (tecla pressionada e tecla soltada). A importância de se enviar quando a
tecla é solta para o Raspberry Pi 3, se dá pela necessidade de desativar as GPIOs.
Por exemplo, ao pressionar a tecla “w” as GPIOs responsáveis pelo movimento de ir
para frente serão ativadas e permanecerão nesse estado, até receberem outro
comando para serem desativadas. Todos os comandos são gravados em um arquivo
de texto (“.txt”) da forma apresentada na Figura 45.

Figura 45 – Parte dos Comandos armazenados

Fonte: Próprio Autor

As imagens que serão utilizadas para o treinamento da CNN foram obtidas


através da câmera do Raspberry e enviadas para o computador através de uma nova
conexão servidor-cliente, na qual são transmitidas por meio de frame (Quadro) de
imagem colorida de tamanho 640 x 320, sendo possível a visualização em tempo real
57

no computador. Todo este sistema de transmissão de imagem entre Raspberry e


computador foi desenvolvido por Wang (2015) em Python. Ele utilizou-se de
bibliotecas como OpenCV, Numpy, Time e Socket, com algumas modificações para
se adequar ao projeto.
O modulo Time do Python foi empregado para armazenar em outro arquivo de
texto (“.txt”) o tempo em segundos de cada tecla pressionada, a partir de uma época
(Ponto em que o tempo começa), que depende da plataforma utilizada, no caso o
Windows 10. Este procedimento tem por finalidade obter um conjunto de dados maior
para treinamento da CNN, pois as imagens que serão obtidas irão possuir como nome
o tempo em que foi disparada, com o mesmo princípio utilizado com as teclas, e por
meio deste tempo serão associadas através de um algoritmo em Python onde em
média quatro imagens são unidas a uma tecla pressionada (Figura 46).

Figura 46 – Parte do Conjunto de dados pronto para o Treinamento.

Fonte: Próprio Autor

3.3. Treinamento da Rede Neural Convolucional

O treinamento da CNN tem como objetivo classificar três classes (reto, direita
e esquerda), com a finalidade de controlar os movimentos do veículo objetivando que
o mesmo complete o circuito proposto de forma autônoma. Para desenvolvimento da
aplicação da CNN, foi utilizada a linguagem de programação em Python, por possuir
58

ferramentas poderosas de deep learning (bibliotecas), como Keras, TensorFlow,


scikit-learn e Numpy, que facilitam a construção das redes CNN. A biblioteca Keras
possui suporte a CNN e foi desenvolvida para facilitar as implementações do modelo
da rede, sendo capaz de rodar em cima da biblioteca TensorFlow cuja a função neste
projeto é abstrair características das imagens.
Como disposto na seção anterior, os nomes dos comandos estão presentes no
nome das imagens adquiridas, na qual serão separadas no algoritmo e atribuídas em
números (Rótulos) para classificação das imagens, conforme a Tabela 5.

Tabela 5 – Rótulos para classificação CNN


Movimentos Comandos Rótulos
Reto W 0
Esquerda Q 1
Direita E 2

Fonte: Próprio Autor

A arquitetura da CNN escolhida para a classificação foi baseada no artigo End


of End Learning for Auto-Driving Cars da NVIDIA (BOJARSKI, et al. 2016), com
algumas modificações, tais como adição de mais um Dropout e a diminuição de uma
camada totalmente conectada. As modificações realizadas na arquitetura são
ilustradas na Figura 47. O propósito da Nvidea é a navegação autônoma, porém a
forma que foi obtida o conjunto de dados aliada a posição desempenhada pela CNN
ser muito mais complexa do que foi realizado neste projeto. Assim a arquitetura foi
modificada para adequar a realidade do projeto aqui proposto. O fato de as imagens
serem obtidas em um mesmo ambiente com proporções de pista iguais faz com que
gere dados iguais fazendo com que possa ocorra overfitting. Assim, a fim de
solucionar o referido problema se fez o uso de mais um Dropout na arquitetura.
Ainda na Figura 47 é possível observar uma camada de normalização na qual
é inserida para evitar saturação, pois as imagens podem conter partes escuras ou
estar obstruídas, em resumo, sua função é reformular as imagens para que no final
do treinamento gere boas classificações.
A CNN utilizada para o treinamento (Figura 48) é composta por oito camadas.
A primeira camada é composta por uma camada de convolução com filtros 5x5x24,
com strides 2x2 (passos), seguida de uma ativação. A segunda e terceira camadas
seguem praticamente a mesma composição da primeira camada, alterando-se apenas
59

a dimensão dos filtros sendo, respectivamente, 5x5x36 e 5x5x48. A quarta camada


possui uma camada de convolução com filtro 5x5x64, com stride 1x1 (passos) seguida
de uma ativação. A mesma configuração foi empregada para a quinta camada. Depois
das camadas convolucionais, a técnica dropout é aplicada, seguida do Flatten, cuja a
função é achatar as características obtidas para começar alimentas as camadas
totalmente conectadas. A primeira camada totalmente conectada possui 100
neurônios, seguida de um dropout. A segunda camada totalmente conectada possui
10 neurônios, a terceira e última camada totalmente conectada possui 3 neurônios
(saída das 3 classes designadas).

Figura 47 – Modificações na Arquitetura da Nvidea.

Fonte: Próprio Autor.


60

Figura 48 – Arquitetura da CNN proposta para navegação autônoma.

Fonte: Próprio Autor.

3.4. Detecção de Objetos com YOLO

Esta seção apresenta o processo de detecção de sinais de trânsito via rede


YOLO a partir de um conjunto de dados. A criação do detector consiste em três etapas:
coleta de imagens, anotação das imagens e o treinamento do modelo para detecção.
Todas as etapas foram baseadas no tutorial fornecido pelos criadores da rede
(REDMON, et al. 2016). Os dados a serem detectados são sinais de trânsito, para este
projeto foram escolhidos dois: placa de pare e o semáforo (Vermelho, amarelo e
verde), portando serão quatro classes para o treinamento.
As imagens foram obtidas de dois modos: a partir de sinais de trânsitos feitos
em miniaturas (Figura 49), e imagens coletadas usando o Google imagens.

Figura 49 – Sinais de Trânsito (Placa Pare e Semáforo).

Fonte: Próprio Autor


61

Todas as imagens coletadas estão no mesmo formato (“.jpg”), as quais foram


divididas em pastas de acordo com sua classe e renomeadas utilizando um algoritmo
em Python com o nome de sua a classe junto com uma numeração crescente
começada em 0 (Figura 50). Este passo é importante para a etapa seguinte a qual
consiste nas anotações das imagens. As anotações de cada imagem estão em
formato (“.xml”) e carregam informações importantes que serão utilizadas no
treinamento. A forma que está escrita as informações neste arquivo é mostrada na
Figura 51.

Figura 50 – Imagens renomeadas

Fonte: Próprio Autor

Figura 51 – Formato das Anotações de cada imagem

Fonte: Próprio Autor


62

• folder: o nome da pasta onde está contida a imagem;


• filename: o nome do arquivo de imagem;
• segmented: Se a imagem é ou não segmentada (0 e 1), no caso todas
serão 0;
• size: onde está contido as dimensões da imagem:
▪ width: largura da imagem;
▪ height: altura da imagem;
▪ depth: profundidade da imagem, como se trata de imagens
coloridas todas serão três (RGB).
• object: Contém algumas informações sobre o objeto a ser detectado:
▪ name: nome do objeto;
▪ truncated: se há ou não algo na frente do objeto;
▪ difficult: se há alguma dificuldade em reconhecer
determinada imagem.
• bndbox: contém as coordenadas da caixa desenhada em volta do objeto
a ser detectado.

Para desenhar a caixa mostrando o objeto a ser detectado e gerar o arquivo


(“.xml”) de cada imagem, se fez uso de um programa em Python criado por Jay (2018),
onde se faz uso de algumas bibliotecas importantes, como OpenCv, lxml e matplotlib.
Quando iniciado o algoritmo abre-se uma janela com a imagem coletada, onde de
forma manual (com o mouse) se faz o desenho da caixa em cima do objeto conforme
a Figura 52, em seguida pressiona-se a tecla “q” para passar de imagem e repetir o
processo. A cada imagem que é passada gera um arquivo (“.xml”), na qual as
informações de coordenadas da caixa (bndbox), dimensões da imagem (size) e o
nome do arquivo de imagem (filename) são preenchidas de forma automática, e as
demais são escritas manualmente no algoritmo, sendo assim se faz necessário
realizar o processo para cada classe separadamente.
63

Figura 52 – Desenho da caixa no objeto

Fonte: Próprio Autor

Figura 53 – Transferência de Aprendizagem

Fonte: Próprio Autor

Com o conjunto de dados completo, a última etapa será o treinamento. Assim,


inicia-se o processo de treinamento, onde a principal ideia de fazer a detecção a partir
dos próprios dados ou um modelo de classificação personalizado é transferir a
64

aprendizagem, que significa reutilizar um modelo pré-treinado eficiente como VGG,


VOC, Inception ou Resnet, como ponto de partida em outra tarefa. Para este projeto
utilizou-se o modelo pré-treinado Tiny Yolo VOC da Pascal Visual Object Classes
(VOC), uma página Web que fornece muitos conjuntos de dados padronizados com
classes variadas para detecção de objetos, todas as etapas realizadas anteriormente
são baseadas neste padrão. A Figura 53 ilustra o processo da transferência de
aprendizagem, que constituiu na remoção da camada do modelo antigo (Tiny Yolo
VOC) e adicionado em seu lugar o novo classificador, que é ajustado a partir do
conjunto de dados personalizado.
A arquitetura Tiny Yolo VOC pré-treinada foi configurada para classificação de
20 rótulos, possuindo a arquitetura mostrada na Figura 54, na qual as imagens de
entrada são redimensionadas para 416x416x3 e trilhadas por 6 camadas
convolucionais com filtros de 3x3, seguidas de MaxPooling com filtros de 2x2 para
reduzir a largura e a altura e deixar a terceira dimensão inalterada, por fim, mais três
camadas convolucionais. A versão “tiny” (minúscula) do YOLO que será utilizada não
possui camada totalmente conectada, possuindo uma arquitetura simples de apenas
9 camadas convolucionais e 6 MaxPooling. O YOLO disponibiliza outras versões mais
complexas com arquiteturas três vezes maiores.

Figura 54 – Arquitetura Tiny Yolo VOC pré-treinada.

FONTE: (RAVAL, 2017)


65

A última camada da Arquitetura da Figura 54 possui filtro 1x1 e tem por


finalidade reduzir os dados para forma 13x13x125. As dimensões 13x13 é o tamanho
da grade que irá dividir a imagem, a 125 é o número de canais para cada célula da
grade que será a parte modificada da arquitetura, para se adequar a detecção
proposta. Para chegar a este valor de canais (125) foram realizados cálculos a partir
do número de caixas delimitadoras de cada grade que será 5 e a quantidade de dados
de cada caixa delimitadora. Os dados são:
• As coordenadas e dimensões para cada caixa delimitadora (x, y, altura,
largura) = 4 Dados;
• Pontuação de confiabilidade = 1 Dado;
• Número de classes (20 classes) = 20 Dados.

Somando os dados obtém-se 25, multiplicando pelo número de caixas


delimitadoras, 5x25 = 125 canais, aplicando este mesmo cálculo para 4 classes do
objetivo proposto, tem-se: 5x9 (número de dados) = 45 canais. Obtendo a arquitetura
usada para o treinamento (Figura 55).

Figura 55 – Novo Modelo Tiny Yolo para 4 classes.

FONTE: Próprio autor.

A Figura 56 mostra arquitetura da rede YOLO representada de outra forma. O


Computador utilizado para o treinamento é equipado com i5 -3317U com 2 núcleos de
2.60 Ghz, 8 GB de memória RAM, placa de vídeo GEFORCE GTX 970 de 4 GB e
66

rodando o sistema operacional Windows 10. Para aprendizagem da rede, utilizou-se


a linguagem de programação Python 3.6, as bibliotecas TensorFlow 1.5 GPU
(Graphics Processing Unit) e OpenCV. As operações de treinamento foram rodadas
utilizando a placa gráfica presente no computador, fazendo com que se acelere o
processo, que é iniciado fornecendo as anotações, o diretório da imagem, modelo e
pesos pré-treinados.

Figura 56 – Arquitetura Tiny Yolo modificada.

Fonte: Próprio Autor


67

4. Resultados e Discussão

Nesta seção são apresentados os resultados obtidos com a metodologia


apresentada para navegação autônoma e classificação de objetos em tempo real. A
seção 4.1 apresenta a performance da CNN com base de dados e ambientes de testes
diferentes. Na seção 4.2 são analisadas as partes internas da CNN. A seção 2.3
apresenta resultados sobre a confiabilidade da rede neural YOLO para detecção de
objetos. Por fim a seção 4.4 mostras algumas dificuldades e problemas ao longo do
desenvolvimento do projeto.

4.1. Performance da CNN aplicada a Navegação Autônoma

A performance da CNN foi avaliada, a partir da métrica presente no artigo da


NVIDIA (BOJARSKI, et al. 2016). Tal métrica leva em consideração o tempo em que
o veículo é autônomo contando o número de intervenções humanas para corrigir a
posição do carro. O tempo de durabilidade da intervenção utilizada pela Nvidia foi de
seis segundos, para este projeto utilizou-se três segundos, pois os testes realizados
foram em uma escala bem menor. Portanto a métrica é definida pela Equação 4.

num interveções ∗ 3 (segundos)


𝑎𝑢𝑡𝑜𝑛𝑜𝑚𝑖𝑎 = 1 − ∗ 100 (4)
tempo teste (segundos)

Como apresentado na seção 3.2, foram construídas duas pistas, para aquisição
de dados para treinamento e testes. Assim, ao todo foram obtidos três conjuntos de
dados. A Tabela 6 mostra a composição de cada conjunto de dados e, em qual pista
à mesma foi obtida.

Tabela 6 – Composição dos conjuntos de dados obtidos.


Conjunto Pista Composição do Conjunto de Dados Total
de dados Frente Direita Esquerda
1 Pista 1 1817 445 657 2919
2 Pista 1 1635 1233 854 3722
3 Pista 2 2594 1690 2101 6385
FONTE: Próprio autor.
68

A pista 2 (Figura 43), como descrito na seção 3.2, consiste em uma pista oval,
onde foi utilizada apenas a metade da mesma para obtenção do conjunto de dados 3
(Tabela 6).
Os modelos obtidos após o treinamento dos três conjuntos de dados foram
inseridos no Raspberry pi 3, para realização de testes. Os testes realizados com cada
modelo da CNN foram divididos em três fases. Na primeira fase foram realizados
testes somente na pista 1 (Figura 42) com o modelo obtido do primeiro conjunto de
dados. A segunda fase utilizou-se o modelo obtido do segundo conjunto de dados, e
os testes feitos nas duas pistas. A última fase fora realizada testes apenas na pista 2
(Figura 43), com o terceiro conjunto de dados.

4.1.1 Primeira fase de Testes

O primeiro conjunto de dados possui 2920 imagens, obtidas seguindo a


metodologia descrita na seção 3.2. Foram divididas da seguinte forma para iniciar o
treinamento: 70% (2044) das imagens foram utilizadas para treinamento da CNN e
30% (876) para a fase de teste da rede. A Tabela 7 mostra como o conjunto de dados
foi dividido. ‘F’ corresponde ao movimento frente, ‘E’ esquerda e ‘D’ direita. Os
resultados do treinamento foram obtidos após 20 épocas.

Tabela 7 - Divisão conjunto de dados 1 e resultados do treinamento.


Conjunto Dados Dados Acurácia Acurácia
de dados (Treinamento) (Teste) (treinamento) (teste)
F E D F E D
1 1272 460 311 545 197 134 96,91% 95,61%
FONTE: Próprio autor

É possível notar na Tabela 7 um conjunto de dados desbalanceado onde possui


maior número de dados para o rotulo frente do que as demais. Isso pode levar a uma
interpretação errônea se analisar a métrica da acurácia (Equação 5).

𝑃𝑜𝑠𝑖𝑡𝑖𝑣𝑜𝑠 𝑉𝑒𝑟𝑑𝑎𝑑𝑒𝑖𝑟𝑜𝑠 + 𝑁𝑒𝑔𝑎𝑡𝑖𝑣𝑜𝑠 𝑉𝑒𝑟𝑑𝑎𝑑𝑒𝑖𝑟𝑜𝑠


𝐴𝑐𝑢𝑟á𝑐𝑖𝑎 = (5)
𝑇𝑜𝑡𝑎𝑙 𝑑𝑒 𝐴𝑚𝑜𝑠𝑡𝑟𝑎𝑠
69

Ao possuir um conjunto de dados com diferença discrepante entre as classes,


faz com que se eleve a acurácia mostrada pela rede, e ao realizar testes com a mesma
fica provado, que a acurácia apresentada não corresponde real. No caso deste
primeiro conjunto ficou evidente que o fato de se ter muito mais dados do movimento
‘Frente’ fez com que a rede basicamente identifica-se esta classe no teste realizado
na pista 1 (Figura 42).
Fazendo uma análise do conjunto de dados permitiu-se compreender o
comportamento da rede e entender o porquê do não funcionamento ao realizar os
testes na pista 1 (Figura 42). Foram introduzidas 100 imagens de cada classe na rede,
a fim de confirmar a causa do mau funcionamento da rede. A Figura 57 apresenta o
resultado das predições das imagens introduzidas. Analisando-se a Figura nota-se
que dos 100 dados do rotulo ‘Frente’ foram classificadas 90 corretamente, um número
consideravelmente bom. Por outro lado, o rotulo ‘Direita’ apenas 28 imagens foram
classificadas corretamente e cerca de 41 imagens classificadas como rotulo ‘Frente’
reduzindo a performance do classificador. Os resultados para o rotulo ‘Esquerda’
foram um pouco melhores, porém com resultados ainda pobres.

Figura 57 – Resultados teste do modelo CNN para o conjunto de dados 1.

FONTE: Próprio autor

Em resumo não houve dados suficientes para as classes ‘Direita’ e ‘Esquerda’,


para que a rede CNN possa aprender pois, na realização de uma curva são geradas
70

imagens relativamente diferentes ao se comparar com uma reta onde não há grandes
alterações (Frente).

4.1.2 Segunda fase de Teste

O conjunto de dados 2 consiste em 3722 imagens, onde se buscou focar em


movimentos de curva a fim de diminuir a diferença de dados entre as classes e obter
um modelo de rede com melhores resultados. Para o treinamento e teste a base de
dados foram divididas da mesma forma da subseção anterior, 70% (2606) para
treinamento e 30% (1117) para validação da rede, gerando a Tabela 8.

Tabela 8 - Divisão conjunto de dados 2 e resultados do treinamento.


Conjunto Dados Dados Acurácia Acurácia
de dados (Treinamento) (Teste) (treinamento) (teste)
F E D F E D
2 1145 598 863 490 256 370 98,46% 95,77%
FONTE: Próprio autor

Os resultados do treinamento da rede foram obtidos após 20 épocas. A Figura


58 (a) representa o comportamento da rede durante o processo, onde pode-se notar
que a curva da acurácia na fase treino atingiu números maiores que a fase de
validação, subindo rapidamente até a quinta época e depois aos poucos até o final do
treinamento atingindo 98,46% de acurácia, enquanto a fase teste (validação) atingiu
seu pico máximo na sétima época. Após isso oscilou em pontos altos e baixos até o
fim do treinamento, indicando que o modelo não generalizou muito bem. Isso se deve
ao fato de que o modelo não foi treinado utilizando um conjunto de dados que
oferecesse condições ruins, isto é, com obstruções, luz baixa ou imagens invertidas.
Já a Figura 58 (b) mostra as curvas de perdas do treinamento e teste, na qual é
possível notar uma diferença considerável entre elas, onde o erro (perda) na fase de
validação (teste) é maior que o erro do treinamento o que indica que a rede tentou
memorizar os dados de treinamento, podendo assim, considerar um sinal de
overfitting (Sobre ajuste). No geral o erro de treinamento é menor do que o erro do
teste, porém em termos de avaliação, a diferença entre as duas deve ser baixa e o
erro pequeno, para ser considerado um Good fitting (Ajuste bom).
71

Figura 58 - Análise de desempenho da CNN para o conjunto de dados 2: (a) acurácia para as fases
de treinamento e teste em função do número de épocas; (b) taxa de perda para as fases de
treinamento e teste em função do número de épocas.

(a)

(b)

FONTE: Próprio autor

Uma forma de confirmar se de fato houve Overffiting no modelo treinado é testa-


la com dados diferentes dos usados no treinamento e validação. Para o teste da rede
treinada a partir do conjunto de dados 2, foram introduzidas as mesmas 100 imagens
de cada classe da subseção anterior. Os resultados obtidos estão representados na
Figura 59. Analisando-os pode-se ver que foram bem satisfatórios para realização dos
testes em pista. Pode-se notar ainda que para o rótulo ‘Esquerda’, na qual foram
treinadas menos dados em relação aos outros rótulos, obteve o pior resultado.
72

Figura 59 – Resultados teste modelo CNN para o conjunto de dados 2.

FONTE: Próprio autor

O primeiro teste com o modelo CNN criado foi realizado na pista 1 (Figura 60)
que constitui em um percurso com começo e fim, sendo assim, o propósito inicial do
experimento consiste em verificar se o veículo construído completará tal trajetória. A
primeira avaliação se deu com o veículo em baixa velocidade, completando o caminho
sem necessitar de nenhuma intervenção, realizando tanto a curva para esquerda,
quanto para direita. Na segunda avaliação, foi verificada a capacidade de
processamento do Raspberry e quão rápida seria sua resposta. Para isso, aumentou-
se a velocidade do veículo que novamente completou o percurso com sucesso.

Figura 60 – Realização do teste na pista 1

FONTE: Próprio autor


73

Para confirmar de fato a performance da CNN, o modelo treinado foi testado na


segunda pista (Figura 61). Importante mencionar que não foi adquirido nenhum dado
para aprendizagem da rede na referida pista para esta etapa. Como forma de
avaliação para este teste foi utilizada a métrica apresentada na seção 4.1 para definir
a autonomia do veículo. Por consequência de o design da pista ser oval, realizaram-
se dois testes, o primeiro fazendo a curva para esquerda e o segundo para direita. No
primeiro teste o percurso durou cerca de 70 segundos, onde se fizeram necessários
cinco intervenções para corrigir a posição do veículo, resultando em 83% de
autonomia. Já o segundo teste durou cerca de 86 segundos, com apenas uma
intervenção, resultando em 97% de autonomia.
As intervenções realizadas no primeiro teste foram em finais de curva, na qual
o veículo deveria seguir virando à esquerda para completá-la, porem seguiu-se reto.
Estes resultados são condizentes com os da Figura 60, onde algumas imagens que
deveriam ser classificadas com o rotulo “esquerda”, foram classificadas como
“Frente”.

Figura 61 – Realização do teste na pista 2

FONTE: Próprio autor

4.1.3 Terceira fase de Testes

Com o objetivo de melhorar os resultados da subseção anterior foi então


concebida uma nova base de dados (conjunto de dados 3) com 6385 imagens (Tabela
6). Para o treinamento foram usados os mesmos procedimentos das subseções
anteriores, dividindo-se os dados em 70% para treinamento e 30% para validação da
rede (teste), as divisões estão representadas na Tabela 9.
74

Tabela 9 - Divisão conjunto de dados 3 e resultados do treinamento


Conjunto Dados Dados Acurácia Acurácia
de dados (Treinamento) (Teste) (treinamento) (teste)
F E D F E D
3 1816 1183 1471 778 507 630 99,07% 97,85%
FONTE: Próprio autor

Após 20 épocas se obteve resultados melhores que a subseção anterior, em


termos de acurácia, porém mesmo com o aumento do número de dados obtidos,
observa-se na Figura 62 (a), que o modelo não conseguiu generalizar bem obtendo
curvas parecidas com a Figura (58 a), onde a acurácia para o treinamento foi maior
que para a fase de validação. Apesar de um maior número de imagens, as mesmas
continuam ainda muito parecidas umas com as outras. É importante mencionar que
esta base de dados fora utilizadas imagens invertidas, a fim de criar uma situação ruim
para rede com objetivo de melhorá-la, entretanto esta estratégia não se mostrou
exitosa. A Figura 62 (b) mostra as curvas de erro para a fase de treino e teste. Os
resultados apresentaram um aumento se comparado com a Figura (59 b), porém ainda
se apresenta uma acurácia abaixo da esperada, podendo concluir apenas que o
modelo treinado apresentou um pequeno sinal de Overffiting.

Figura 62 - Análise de desempenho da CNN para o conjunto de dados 3 (a) acurácia para as fases de
treinamento e teste em função do número de épocas; (b) taxa de perda para as fases de treinamento
e teste em função do número de épocas.
75

FONTE: Próprio autor

Ao inserir 100 dados de cada classe no modelo treinado, obteve-se um excelente


resultado (Figura 63), podendo concluir que a acurácia obtida é de fato verdadeira.

Figura 63 – Resultados teste modelo CNN para o conjunto de dados 3.

FONTE: Próprio autor

Curiosamente o rotulo “frente” obteve o pior resultado, mesmo possuindo mais


dados que os demais rótulos. Acredita-se que pelo formato da pista (Figura 64),
algumas imagens do rotulo “esquerda” e “frente” foram muito parecidas, pois após
concluir a primeira curva o comando na obtenção dos dados foi para seguir em frente
76

até o início da segunda curva, onde em seguida utilizou-se o comando para virar para
esquerda, obtendo assim imagens iguais para ambos os rótulos do início desta curva.

Figura 64 – Representação da forma da pista

FONTE: Próprio autor

Os testes foram realizados apenas na pista 2 (43), tanto para curva a direita
quanto esquerda. Para o percurso com curvas para direita, o veículo completou duas
voltas, sem haver necessidade de intervenção, após isso, em uma curva já
completada duas vezes pelo carrinho, o mesmo acabou se perdendo, saindo da
delimitação da pista. O teste durou cerca de 105 segundos, com apenas uma
intervenção. Assim, aplicando-se a métrica da seção 4.1 obteve-se 97,15% de
autonomia. O trajeto para a curva da esquerda durou cerca de 114 segundos, com
apenas uma intervenção realizada, resultando em 97,4% de autonomia.
O fato de não usar imagens com várias posições diferentes, faz com que seja
necessária a correção do veículo em uma curva que o mesmo realizou sem tal
necessidade, explicitando assim que o modelo treinado não generalizou muito bem,
ou seja, não foi capaz de fazer a predição correta em uma situação menos favorável.

4.2. Parte interna da CNN

Está seção apresenta como ocorre a extração de característica mais


aprofundada em uma CNN. Como visto na subseção 2.1.1 um filtro convolucional
opera na imagem executando várias operações de convolução e, como resultado,
obtém-se o mapa de recursos ou mapas de características. A saída de uma camada
77

de convolução é um volume 3D onde se tem a altura, largura do mapa de recursos e


cada canal de profundidade, que corresponde a um mapa de características que
codifica recursos independentes. Será visualizado os mapas de recursos individuais,
plotando cada canal como figura 2D.
A arquitetura CNN utilizada para treinamento dos dados da pista possui cinco
camadas convolucionais e cada camada possui número de filtros diferentes, obtendo-
se respectivamente 24, 36, 48, 64 e 64 mapas de recursos. A Figura 65 representa a
imagem com dimensões 320x160x3 (RGB) utilizada para passar por cada camada
convolucional, para a visualização do mapa de características.

Figura 65 – Imagem do Rotulo “Frente” para visualização do mapa de recursos.

FONTE: Próprio autor

Figura 66 – Saída mapa de recursos da Primeira Camada Convolucional.

FONTE: Próprio autor


78

A saída da primeira camada convolucional, ilustrada na Figura 66, possui 24


mapas de características, a qual nota-se que se mantem a maior parte das
informações presentes na imagem. Geralmente em arquiteturas do tipo CNN as
primeiras camadas atuam como detectores de bordas e/ou de formas mais simples.
As áreas claras são as regiões "ativadas" isso significa que o filtro detectou o padrão
que estava procurando.
A segunda camada contém 36 mapas de recursos. Dentre eles foram plotados
aleatoriamente 24 para propósito de análise (Figura 67). Observa-se que mudou um
pouco em relação a primeira camada com ‘ativações” mais centrais.

Figura 67 – Saída mapa de recursos da Segunda Camada Convolucional

FONTE: Próprio autor.

As Figuras 68, 69 e 70 representam respectivamente a terceira, quarta e quinta


camada, onde de maneira aleatória plotou-se 24 mapas com características de cada.
À medida que nos aprofundamos na rede, o mapa de recursos se parece menos com
a imagem original ficando cada vez mais abstrata. Como mostrado para a primeira
camada, a pista ainda é visível, mas ao chegar na quinta camada, a mesma torna-se
irreconhecível. A razão para tal comportamento, é que mapas de recursos mais
profundos buscam características mais especificas como bordas únicas, cantos e
ângulos, contendo assim menos informações sobre a imagem e mais sobre a classe
em que a imagem pertence.
79

Figura 68 – Saída mapa de recursos da Terceira Camada Convolucional.

FONTE: Próprio autor


Figura 69 – Saída mapa de recursos da Quarta Camada Convolucional.

FONTE: Próprio autor

Os mapas de recursos nas camadas mais profundas ficam mais dispersos,


significando que os filtros detectam menos recursos, assim, por este motivo é possível
observar que nas últimas camadas há mapas de recursos em branco, ou seja, não
houve nenhuma característica ali presente “ativada”. Caso a CNN tivesse mais
camadas convolucionais, chegaria a um ponto em que haveria apenas imagens em
branco, significando que não há mais nada para aprender da imagem de entrada.
As Figuras 71 e 72 mostram um mapa de recurso selecionado de cada camada
das classes “direita” e “esquerda”, a fim de mostrar como foram ficando mais abstratos
os mapas na medida em que foram aprofundadas e quais informações foram extraídas
para distinção das classes.
80

Figura 70 – Saída mapa de recursos da Quinta Camada Convolucional.

FONTE: Próprio autor

Figura 71 – mapa de recurso de cada camada convolucional da classe “direita”.

FONTE: Próprio autor.

Figura 72 – mapa de recurso de cada camada convolucional da classe “esquerda”.

FONTE: Próprio autor.

4.3. Confiabilidade da Detecção de Objetos com YOLO

A avaliação da confiabilidade do detector de objetos com YOLO se deu através


de testes em tempo real variando-se os ângulos e posições, a fim de verificar se a
predição fora correta para os objetos propostos (sinais de trânsito). Foram realizados
dois treinamentos, com bases de dados distinta, obtidas pela metodologia descrita na
seção 3.4. A primeira base de dados possui 500 imagens para cada uma das quatro
classes (placa pare, sinal verde, amarelo e vermelho do semáforo), já a segunda base
de dados constitui em 1000 imagens para cada classe. Para obtenção de uma boa
confiabilidade da rede YOLO é indicado pelos criadores (REDMON, et al. 2016) utilizar
no mínimo 1000 imagens para cada classe em cenários diferentes e variados ângulos.
81

O processo de treinamento demanda bastante tempo, e mesmo com a


utilização de GPU, exigiu cerca de 6 horas de treinamento para a primeira base de
dados e 10 horas para segunda base de dados, ambas considerando 50 épocas.
A Figura 73 mostra alguns resultados obtidos do modelo criado da primeira
base de dados, a detecção da “Placa_pare” (Figura 73 a) obteve uma boa
confiabilidade e por mais que variasse os ângulos e posições. A predição continuava
correta, porém a confiabilidade variava entre valores altos e baixos. Por se tratar de
um objeto (Placa_pare) que se difere muito das outras classes, dificilmente a rede fará
uma predição errada durante o teste, a aproximação do objeto na câmera fazia a
confiabilidade aumentar e ao se distanciar muito a rede não detectou nenhum objeto.
Isso se dá pelo fato de que cada imagem é dividida em grades e cada célula da grade
prevê caixas delimitadoras e pontuações de confiança para essas caixas. Para mostrar
para o usuário a predição dentro de uma caixa, à pontuação deve ser maior que 10%,
sendo que tal delimitação pode ser configurada.

Figura 73 – Resultados confiabilidade rede YOLO primeira base de dados

FONTE: Próprio autor

As Figuras 73 b, c e d apresentam os resultados para as posições que


alcançaram a melhor confiabilidade para os sinais de semáforo ao variar a angulação
ou distanciamento. Infelizmente a rede não previu nenhum objeto indicando a
82

importância do aumento dos dados em variadas situações, pois o YOLO aprende a


prever caixas delimitadoras de dados, o mesmo se é forçado a generalizar objetos em
proporções ou configurações novas ou incomuns. Também, se faz uso de recursos
relativamente grosseiros para prever caixas delimitadoras, já que a arquitetura utilizada
possui várias camadas de redução de resolução a partir da imagem de entrada.
O treinamento de um segundo modelo da rede YOLO teve com objetivo
melhorar os resultados obtidos anteriormente. Para tal fim, aumentou-se o número de
imagens e a variação de posições dos objetos. Os resultados não foram satisfatórios,
pois a rede conseguiu indentificar apenas a classe “Placa_pare” sem haver as
melhorias desejadas (Figura 74).

Figura 74 – Resultado confiabilidade rede YOLO segunda base de dados.

FONTE: Próprio autor

As demais classes da segunda base de dados não foram identificadas pela


rede em nenhuma posição apesar do aumento dos dados, o motivo teve como
decorrência a luz dos LEDs do semáforo estarem mais fracas nas imagens (Figura
75) impossibilitando a rede de extrair as características necessárias para
classificação. A arquitetura da rede tiny YOLO é mais rápida e menos precisa fazendo
com que a base de dados treinada não seja suficiente para obtenção de melhores
resultados. Há arquiteturas de redes YOLO maiores que poderiam levar a resultados
mais satisfatórios com a mesma base de dados, porém exige um poder computacional
grande e o treinamento pode durar dias.
83

Figura 75 – Resultado confiabilidade rede YOLO segunda base de dados

FONTE: Próprio autor

A rede YOLO exige a utilização da GPU para melhorar sua performance em


detecção em tempo real, pois ao utilizar CPU consegue-se 2 FPS (frames por
segundo) isso faz com que a visualização seja lenta e com muito atraso. Com a GPU
(GeForce GTX 970 4GB) obteve-se 20 FPS, aumentando muito a performance em
tempo real.

4.4. Dificuldades

A presente seção abordará problemas e dificuldades obtidas ao longo do


desenvolvimento do projeto, tais como, comunicação entre o computador e RPi, o
funcionamento dos motores CC e a integração da rede YOLO em conjunto com a
navegação autônoma.
O veículo construído para testes dos modelos treinados da CNN para
navegação autônoma ficou pesado, isso fez com que sobrecarregasse os motores CC
presentes tanto na parte dianteira como traseira no veículo. O motor CC dianteiro é
ativado para direcionar o veículo tanto para esquerda quanto para direita. Durante os
testes, o mesmo ficava por bastante tempo ativado conjuntamente com o peso do
veículo fazendo com que o carro parasse de funcionar com o tempo, pois a corrente,
apesar de limitada pela Ponte H, era muito elevada, fazendo com que queimasse o
motor necessitando-se fazer a substituição por 2 vezes.
A comunicação entre o computador e o RPi, como fora explicito na seção 3.2,
se deu através de um modem, o mesmo era utilizado para outros computadores
84

acessarem a internet, isso fez com que ocorresse atrasos na aquisição de imagens e
não permitiu que o processamento do modelo da CNN já treinado fosse realizada no
computador. Como alternativa a fase teste foi realizada no RPi. As principais
consequências dos atrasos fizeram-se que o veículo facilmente errasse as predições,
saindo da pista. Uma comunicação mais rápida e livre de tais atrasos poderia
aumentar a performance da CNN em navegação autônoma, pois o poder de hardware
de um computador é muito maior que o do RPi.
A integração do YOLO em conjunto com a CNN não pode ser implementada
devido o processamento da CNN estar sendo realizado no RPi. Devido ao seu baixo
poder de processamento, torna-se impossível utilizar a câmera para obtenção de
frames a fim de classificar os movimentos ao mesmo tempo enviar as imagens através
da comunicação com roteador para o processamento da rede YOLO no computador
(que necessita de uma GPU poderosa para um bom funcionamento).
85

5. Considerações Finais

5.1. Conclusões

Este trabalho teve como objetivo o desenvolvimento de um protótipo de um


veículo para navegação autônoma utilizando redes CNN e detecção de objetos em
tempo real com a rede YOLO. Ao longo do texto foram apresentados detalhes dos
métodos utilizados para alcançar objetivo proposto. A metodologia proposta para
desenvolvimento da navegação autônoma foi inspirada no projeto desenvolvido pela
Nvidea. A técnica aplicada consiste em capturar quadros de imagens RGB obtidas a
partir de comandos manuais em uma pista construída rotulando imagens em três
classes, “esquerda”, “direita” e “frente”. Depois, estas imagens foram classificadas por
uma rede CNN, para predições de comandos do veículo de forma autônoma. Devido
a proposta por se tratar de forma mais simples, optou-se por simplificar a metodologia
usada pela Nvidea.
Os procedimentos metodológicos para construção do veículo e treinamento da
CNN foram apresentados, bem como foram revelados os materiais utilizados no
experimento. Baseado na análise dos resultados obtidos em três bases de dados
diferentes nota-se que a CNN alcançou bons resultados na classificação do conjunto
de testes, sendo a maior taxa atingida de 97,85%, resultado este obtido através do
modelo treinado usando a terceira base de dados (subseção 4.1.3). A partir de testes
realizados em pistas, comprovou-se que as CNNs são capazes de aprender todo o
trabalho de seguir as delimitações da trajetória construída, sem necessitar de
marcações na pista, ou qualquer tipo de planejamento de caminhos e controle. O
sistema aprende a detectar o contorno da estrada com rótulos explícitos no
treinamento. O veículo conseguiu atingir 97,4% de autonomia, apesar de ser um bom
resultado, se fazem necessários o melhoramento da robustez da rede CNN, e a
obtenção de uma base de dados de imagens com maiores variações e melhor
selecionadas para obtenção de melhores resultados. Isso permitiria a CNN generalizar
os rótulos e possibilitar a autonomia do veículo em diferentes pistas. O processamento
da CNN no Raspberry Pi para a operação da navegação autônoma, foram bastante
satisfatórias, levando em consideração a limitação que o hardware possui.
O trabalho apresentou uma explicação detalhada das operações que ocorrem
dentro das camadas da CNN (Capítulo 4). Baseado nos resultados é possível observar
86

o passo a passo de como a imagem é utilizada e, transformada dentro de cada


camada da rede. Esta explicação explora as camadas ocultas da rede, contribuindo
para a consolidação do entendimento de suas operações internas.
Para complemento do trabalho, fora apresentado a rede YOLO, um detector de
objetos rápido e preciso, ideal para desenvolvimento de atividades na área de visão
computacional. O YOLO possui uma arquitetura quase igual à da CNN, com algumas
modificações, a fim de fazer detecções em caixas e em tempo real, de maneira rápida
e robusta. A criação de um modelo YOLO para detecção de objetos a partir dos
próprios dados, é bem trabalhosa, demandando muito tempo, pois exige uma base de
dados grande, com bastantes variações. Os resultados obtidos apesar de predições
corretas não se mostraram muito confiáveis, pelo fato de haver muitas imagens iguais,
e pouca varação de ambientes e angulações.
Na visão geral o trabalho proporcionou aprofundamento em conceitos de
aprendizado profundo, que se tem crescido muito nos últimos anos, e que vem se
tornando cada vez mais importante e difundido no âmbito tecnológico. A CNNs em
veículos autônomos mostrou-se uma ferramenta poderosa para tal desenvolvimento,
com aprofundamentos na mesma, poderá substituir sensores caros e esta já vem
sendo utilizada em veículos autônomos fabricados pela Tesla. O YOLO mostrou ser
um detector de objetos de propósito geral mais rápido da literatura, impulsionando o
estado-da-arte na detecção de objetos em tempo real.

5.2. Propostas para Trabalhos Futuros

Propostas para continuidade e melhoria do projeto, são sugeridas nos seguintes tópicos:

I. Aumentar o grau de liberdade do eixo de direção do veículo e inserir um servo motor,


que permitirá definir a posição da direção, havendo maior controle para realização
de curvas e controle dentro das limitações definidas na pista.
II. Inserir uma comunicação mais precisa (Bluetooth ou radio), para que diminua o
tempo de transferência de dados, permitindo o processamento da CNN no
computador, com o envio das classificações de maneira mais rápida ao Raspberry
pi 3.
III. Diminuir o peso no veículo ou adicionar um motor de maior torque, para fazer um
controle de velocidade mais amplo, aumentando nas retas e diminuindo nas curvas.
87

IV. Tratar as imagens de treinamento, onde foque apenas nos trechos das pistas,
cortando o resto do ambiente, fazendo com que a CNN identifique melhor as
delimitações da pista.
V. Integrar o YOLO junto a classificação de direção do carrinho, realizando a detecção
de sinais de trânsito e se comportando a partir delas, por exemplo, parando em
semáforos, controlando a velocidade a partir de placas e desviando de obstáculos.
VI. Fazer uso do sensor ultrassônico para medir as distâncias dos objetos a ser
identificados pelo YOLO, para que o veículo tome decisões mais precisas.
VII. Treinar a CNN identificando graus do eixo de direção, fazendo com que se aumente
o número de rótulos de classificação, permitindo que o veículo tome decisões mais
precisas dentro da pista de testes.
VIII. Aumentar o grau de visibilidade da câmera a fim de obter imagens melhores para
treinamento e testes do YOLO e CNN.
88

Referências

AGRAWAL, Varun. Improving Real-Time Object Detection with YOLO: A new perspective
for real-time object detection. 2017. Disponível em: <https://statsbot.co/blog/real-time-
object-detection-with-yolo/>. Acesso em: 14 fev. 2019.

ALLIBHAI, Eijaz. Building a Convolutional Neural Network (CNN) in Keras. 2018.


Disponível em: <https://towardsdatascience.com/building-a-convolutional-neural-network-
cnn-in-keras-329fbbadc5f5>. Acesso em: 11 fev. 2019.

ARAUJO, Thayron. Raspberry Pi B+: Introdução a Porta GPIO. 2014. Disponível em:
<http://blog.fazedores.com/raspberry-pi-b-introducao-porta-gpio/>. Acesso em: 23 jan. 2019.
AWASTHI, Himanshu. Python Programming Language in AI. 2018. Disponível em:
<https://www.zeolearn.com/magazine/python-programming-language-in-ai>. Acesso em: 10
fev. 2019.

BAPTISTA JÚNIOR, Antônio. Raspberry Pi, construa aplicações para seu


cotidiano. 2014. Disponível em: <https://www.codigofonte.com.br/artigos/raspberry-pi-
construa-aplicacoes-para-seu-cotidiano>. Acesso em: 23 jan. 2019.

BARNARD, William. LiDAR v. Cameras - The Autonomous Vehicle Race. 2018.


Disponível em: <https://www.motivo.com/single-post/2018/02/07/LiDar-v-Cameras---The-
Autonomous-Vehicle-Race>. Acesso em: 23 jan. 2019.

BROWNLEE, Jason. Introduction to Python Deep Learning with Keras. 2016. Disponível
em: <https://machinelearningmastery.com/introduction-python-deep-learning-library-keras/>.
Acesso em: 11 fev. 2019.

BROWNLEE, Jason. What is Deep Learning? 2016. Disponível em:


<https://machinelearningmastery.com/what-is-deep-learning/>. Acesso em: 23 jan. 2019.

BUDUMA, Nikhil; LOCASCIO, Nicholas. Fundamentals of Deep Learning: Designing


Next-generation Machine Intelligence Algorithms. São Francisco: O'reilly Media, Inc.,
2017. 298 p. Disponível em: <https://www.oreilly.com/library/view/fundamentals-of-
deep/9781491925607/>. Acesso em: 14 fev. 2019.

CARDOSO, Alexandra; COSTA, Edgar; SOUSA, Graça. O Potencial Educativo do


Raspberry Pi. 2018. 16 f. Dissertação (Mestrado) - Curso de Informática, Universidade
Católica Protuguesa, Braga, 2018. Cap. 6. Disponível em:
<https://www.edgarcosta.net/raspedu/O_Potencial_Educativo_do_Raspberry_Pi.pdf>.
Acesso em: 23 jan. 2019.

CHABLANI, Manish. YOLO—You only look once, real time object detection
explained. 2017. Disponível em: <https://towardsdatascience.com/yolo-you-only-look-once-
real-time-object-detection-explained-492dc9230006>. Acesso em: 23 jan. 2019.
89

CLAY, Sara. Raspberry Pi 2 & 3 Pin Mappings. 2017. Disponível em:


<https://docs.microsoft.com/en-us/windows/iot-core/learn-about-
hardware/pinmappings/pinmappingsrpi>. Acesso em: 23 jan. 2019.

CAMERON, Oliver. An introduction to lidar the key self driving-car-sensor. 2018.


Disponível em: < https://news.voyage.auto/an-introduction-to-lidar-the-key-self-driving-car-
sensor-a7e405590cff>. Acesso em: 12 dez. 2018.

DAVIES, Alex. How Do Self-Driving Cars See? (And How Do They See Me?). 2018.
Disponível em: <https://www.wired.com/story/the-know-it-alls-how-do-self-driving-cars-see/>.
Acesso em: 23 jan. 2019.

DONGES, Niklas. Gradient Descent in a Nutshell. 2018. Disponível em:


<https://towardsdatascience.com/gradient-descent-in-a-nutshell-eaf8c18212f0>. Acesso em:
14 fev. 2019.

EFFBOT. What's Tkinter? 2018. Disponível em: <http://effbot.org/tkinterbook/tkinter-whats-


tkinter.htm>. Acesso em: 11 fev. 2019.

ELETRONICSFORU. Convolutional Neural Networks for Autonomous Cars (Part 1 of


2). 2018. Disponível em: <https://electronicsforu.com/market-
verticals/automotive/convolutional-neural-networks-autonomous-cars-part-1-2/3>. Acesso
em: 23 jan. 2019.

EMPIRES, Forge Of. How important it is to learn RaspberryPi (or any other SOC) for an
electronics student? 2015. Disponível em: <https://www.quora.com/How-important-it-is-to-
learn-RaspberryPi-or-any-other-SOC-for-an-electronics-student>. Acesso em: 23 jan. 2019.

FERREIRA, Michelle. Como Funciona um Carro Autônomo. 2017. Disponível em:


<https://revistaautoesporte.globo.com/revista/noticia/2017/03/como-funciona-um-carro-
autonomo.html>. Acesso em: 23 jan. 2019.

FILIPEFLOP. Conversor Boost DC Ajustável Step Up. 2018. Disponível em: <
https://www.filipeflop.com/produto/conversor-boost-dc-step-up/>. Acesso em: 14 fev. 2019.

GALL, Richard. Why is Python so good for AI and Machine Learning? 5 Python Experts
Explain. 2018. Disponível em: <https://hub.packtpub.com/python-machine-learning-expert-
interviews/>. Acesso em: 10 fev. 2019.

GALVÃO, Celio. Carros autônomos: você acredita que vão dar certo? Saiba o que vem
por aí. 2018. Disponível em: <https://carros.ig.com.br/colunas/carros-do-celio/2018-03-
30/carros-autonomos.html>. Acesso em: 23 jan. 2019.

GEEKS, Geeks For. GUI do Python - tkinter. 2018. Disponível em:


<https://www.geeksforgeeks.org/python-gui-tkinter/>. Acesso em: 11 fev. 2019.

GOODFELLOW, I. et al. Deep learning. [S.l.]: MIT press Cambridge, v. 1, 2016.


90

GUPTA, Dishashree. Fundamentals of Deep Learning – Activation Functions and When


to Use Them? 2017. Disponível em:
<https://www.analyticsvidhya.com/blog/2017/10/fundamentals-deep-learning-activation-
functions-when-to-use-them/>. Acesso em: 14 fev. 2019.

GUPTA, Tushar. Deep Learning: Feedforward Neural Network. 2017. Disponível em:
<https://towardsdatascience.com/deep-learning-feedforward-neural-network-
26a6705dbdc7>. Acesso em: 14 fev. 2019.

HEATH, Nick. What is deep learning? Everything you need to know. 2018. Disponível
em: <https://www.zdnet.com/article/what-is-deep-learning-everything-you-need-to-know/>.
Acesso em: 23 jan. 2019.

JIMBLOM; MTAYLOR. Raspberry GPIO. Disponível em:


<https://learn.sparkfun.com/tutorials/raspberry-gpio/python-rpigpio-api>. Acesso em: 23 jan.
2019.

JONES, Brad. Elon Musk Calls Out LIDAR Tech as “A Crutch” in Autonomous
Vehicles: "You can absolutely be superhuman with just cameras.". 2018. Disponível em:
<https://futurism.com/elon-musk-lidar-tech-autonomous-vehicles>. Acesso em: 23 jan. 2019.

KAEHLER, Adrian; BRADSKI, Gary. Chapter 1. Overview. 2019. Disponível em:


<https://www.oreilly.com/library/view/learning-opencv/9780596516130/ch01.html>. Acesso
em: 11 fev. 2019.

Karpathy, A. (2014). Convolutional neurais networks. Disponível em:


http://andrew.gibiansky.com/blog/machine-learning/convolutional-neural-networks/.

Karpathy, A. (2015). Transfer learning and fine-tuning convolutional neural networkss.


Diponivel em: http://cs231n.github.io/transfer-learning/.

Karpathy, A. (2017). Convolutional neural networks for visual recognition. Disponível em


http://cs231n.github.io/convolutional-networks/

KERAS. Keras: The Python Deep Learning library. 2018. Disponível em:
<https://keras.io/>. Acesso em: 11 fev. 2019.

KRIZHEVSKY, A.; SUTSKEVER, I.; HINTON, G. E. Imagenet classification with deep


convolutional neural networks. Advances in neural information processing systems. [S.l.]:
[s.n.]. 2012. p. 1097-1105.

LECUN, Y. et al. Backpropagation applied to handwritten zip code recognition. Neural


computation, v. 1, n. 4, p. 541-551, 1989.

LECUN, Y. et al. Gradient-based learning applied to document recognition. Proceedings of


the IEEE, v. 86, n. 11, p. 2278-2324, 1998.
MAJ, Michal. What is object detection? Introduction to YOLO algorithm. 2018.
Disponível em: <https://appsilon.com/object-detection-yolo-algorithm/>. Acesso em: 14 fev.
91

2019.

MANSANO, Alex Fernandes. O que é uma Rede Neural Convolucional? 2016. Disponível
em: <https://www.linkedin.com/pulse/o-que-%C3%A9-um-rede-neural-convolucional-alex-
fernandes-mansano>. Acesso em: 23 jan. 2019.

MARR, Bernard. What Is Deep Learning AI? A Simple Guide With 8 Practical
Examples. 2018. Disponível em:
<https://www.forbes.com/sites/bernardmarr/2018/10/01/what-is-deep-learning-ai-a-simple-
guide-with-8-practical-examples/#2cd3f0c68d4b>. Acesso em: 23 jan. 2019.

MARSHALL, Bill. Lidar, Radar & Digital Cameras: the Eyes of Autonomous

Vehicles. 2018. Disponível em: <https://www.rs-online.com/designspark/lidar-radar-digital-


cameras-the-eyes-of-autonomous-vehicles>. Acesso em: 23 jan. 2019.

MATPLOTLIB. Matplotlib. 2018. Disponível em: <https://matplotlib.org/>. Acesso em: 11 fev.


2019.

ME, Best Programming Language For. Why Learn Python? 2018. Disponível em:
<http://www.bestprogramminglanguagefor.me/why-learn-python>. Acesso em: 10 fev. 2019.

MILLER, Lachlan. Machine Learning week 1: Cost Function, Gradient Descent and
Univariate Linear Regression. 2018. Disponível em:
<https://medium.com/@lachlanmiller_52885/machine-learning-week-1-cost-function-
gradient-descent-and-univariate-linear-regression-8f5fe69815fd>. Acesso em: 14 fev. 2019.

MORRIS, Charles. Renault road-tests Level 4 autonomous EV. 2018. Disponível em:
<https://chargedevs.com/newswire/renault-road-tests-level-4-autonomous-ev/>. Acesso em:
23 jan. 2019.

NEWGENAPPS. 6 Reasons: Why choose Python for AI Projects?. 2017. Disponível em:
<https://www.newgenapps.com/blog/python-for-ai-artificial-intelligence-ml>. Acesso em: 10
fev. 2019.

NIELSEN, Michael A.. Neural Networks and Deep Learning. United States Of America:
Determination Press, 2015. Disponível em:
<http://neuralnetworksanddeeplearning.com/chap5.html>. Acesso em: 23 jan. 2019.
NUMPY. NumPy. 2018. Disponível em: <http://www.numpy.org/>. Acesso em: 11 fev. 2019.

NVIDIA. What is OpenCV? 2019. Disponível em: <https://developer.nvidia.com/opencv>.


Acesso em: 11 fev. 2019.

NVIDIA. Deep Learning. Disponível em: <https://developer.nvidia.com/deep-learning>.


Acesso em: 23 jan. 2019.

NVIDIA. NVIDIA Announces World's First AI Computer to Make Robotaxis a


Reality: 25+ Companies Developing Level 5 Robotaxis on NVIDIA CUDA GPUs. 2017.
92

Disponível em: <https://nvidianews.nvidia.com/news/nvidia-announces-world-s-first-ai-


computer-to-make-robotaxis-a-reality>. Acesso em: 23 jan. 2019.

OLIVEIRA, A. R. D. Redes Neurais Artificiais aplicadas na detecção, classificação e


localização de defeitos em linhas de transmissão. Dissertação de Mestrado, Programa
de Pós-Graduação em Engenharia Elétrica, UFJF. [S.l.]. 2005.
OPENCV. About. 2019. Disponível em: <https://opencv.org/about.html>. Acesso em: 11 fev.
2019.

CORNELISSE, Daphne. An intuitive guide to Convolutional Neural Networks. 2018.


Disponível em: <https://medium.freecodecamp.org/an-intuitive-guide-to-convolutional-neural-
networks-260c2de0a050>. Acesso em: 23 jan. 2019.

PI, The. What is a Raspberry Pi? 2018. Disponível em: <https://thepi.io/what-is-a-raspberry-


pi/>. Acesso em: 23 jan. 2019.

PRABHU. Understanding of Convolutional Neural Network (CNN)?—?Deep


Learning. 2018. Disponível em: <https://medium.com/@RaghavPrabhu/understanding-of-
convolutional-neural-network-cnn-deep-learning-99760835f148>. Acesso em: 23 jan. 2019.

RAJAT. MNIST vs MNIST?—?how I was able to speed up my Deep Learning. 2018.


Disponível em: <https://towardsdatascience.com/mnist-vs-mnist-how-i-was-able-to-speed-
up-my-deep-learning-11c0787e6935>. Acesso em: 23 jan. 2019.

RAMOS, Vinícius. Porquê Aprender Python: 5 Motivos para Começar Agora! 2018.
Disponível em: <https://pythonacademy.com.br/blog/porque-aprender-python-5-motivos-
para-aprender-agora>. Acesso em: 10 fev. 2019.

RASCHKA, Sebastian. Gradient Descent and Stochastic Gradient Descent. 2018.


Disponível em: <https://rasbt.github.io/mlxtend/user_guide/general_concepts/gradient-
optimization/>. Acesso em: 14 fev. 2019.

RAVAL, SIRAJ. YOLO Object Detection. 2018. Disponível em: <


https://github.com/llSourcell/YOLO_Object_Detection>. Acesso em: 14 fev. 2019.

REDMON. Joseph et al .2016, Las Vegas. You Only Look Once: Unified, Real-Time
Object Detection. Las Vegas: IEEE, 2016. 10 p. Disponível em: <https://www.cv-
foundation.org/openaccess/content_cvpr_2016/papers/Redmon_You_Only_Look_CVPR_20
16_paper.pdf>. Acesso em: 14 fev. 2019.

REVIEW, Autopilot. Lidar vs. Cameras for Self Driving Cars – What’s Best? 2018.
Disponível em: <https://www.autopilotreview.com/lidar-vs-cameras-self-driving-cars/>.
Acesso em: 23 jan. 2019.

ROUSE, Margaret. Network Socket. 2015. Disponível em:


<https://whatis.techtarget.com/definition/sockets>. Acesso em: 11 fev. 2019.
93

SANTOS, Antônio F. Gaspar. Veículos Autônomos. 2018. Disponível em:


<https://www.ibm.com/developerworks/community/blogs/tlcbr/entry/mp304?lang=en>.
Acesso em: 23 jan. 2019.

SAZLI, Murat H.. A BRIEF REVIEW OF FEED-FORWARD NEURAL NETWORKS.


Researchgate, Ankara, v. 50, n. 1, p.11-17, 06 fev. 2006. Disponível em:
<https://www.researchgate.net/publication/228394623_A_brief_review_of_feed-
forward_neural_networks>. Acesso em: 14 fev. 2019.

SCIPY. What is NumPy? 2017. Disponível em: <https://docs.scipy.org/doc/numpy-


1.13.0/user/whatisnumpy.html>. Acesso em: 11 fev. 2019.

SERMANET, P. et al. Overfeat: Integrated recognition, localization and detection using


convolutional networks. arXiv preprint arXiv:1312.6229, 2013.

SHARMA, Pulkit. A Practical Guide to Object Detection using the Popular YOLO
Framework – Part III (with Python codes). 2018. Disponível em:
<https://www.analyticsvidhya.com/blog/2018/12/practical-guide-object-detection-yolo-
framewor-python/>. Acesso em: 14 fev. 2019.

SHARMA, Sagar. Activation Functions in Neural Networks. 2017. Disponível em:


<https://towardsdatascience.com/activation-functions-neural-networks-1cbd9f8d91d6>.
Acesso em: 14 fev. 2019.

SOLOMON, Brad. Python Plotting With Matplotlib (Guide). 2018. Disponível em:
<https://realpython.com/python-matplotlib-guide/>. Acesso em: 11 fev. 2019.

SOLUTIONS, Mindfire. Advantages and Disadvantages of Python Programming


Language. 2017. Disponível em: <https://medium.com/@mindfiresolutions.usa/advantages-
and-disadvantages-of-python-programming-language-fd0b394f2121>. Acesso em: 10 fev.
2019.

SZEGEDY, C. et al. Rethinking the inception architecture for computer vision.


Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition. [S.l.]:
[s.n.]. 2016. p. 2818-2826.

TECHTARGET. TensorFlow. 2018. Disponível em:


<https://searchdatamanagement.techtarget.com/definition/TensorFlow>. Acesso em: 10 fev.
2019.

TENSORFLOW. Sobre o TensorFlow. 2015. Disponível em: <https://www.tensorflow.org/>.


Acesso em: 10 fev. 2019.

TERJE. Everything You Want to Know About Raspberry Pi GPIO: But Were Afraid to
Ask. 2018. Disponível em: <https://www.circuits.dk/everything-about-raspberry-gpio/>.
Acesso em: 23 jan. 2019.
94

TOWN, University Of Cape. Introduction to GUI programming with tkinter. 2014.


Disponível em: <https://python-
textbok.readthedocs.io/en/1.0/Introduction_to_GUI_Programming.html>. Acesso em: 11 fev.
2019.

TUTORIALSPOINT. What is a Socket? 2018. Disponível em:


<https://www.tutorialspoint.com/unix_sockets/what_is_socket.htm>. Acesso em: 11 fev.
2019.

UDACITY BRASIL. Carros autônomos: entenda o funcionamento e a construção do


transporte do futuro. Disponível em: &lt; https://br.udacity.com/blog/post/carros-autonomos-
funcionamento&gt; Acesso em: 26 de maio de 2018.

UJJWALKARN. A Quick Introduction to Neural Networks. 2016. Disponível em:


<https://ujjwalkarn.me/2016/08/09/quick-intro-neural-networks/#content>. Acesso em: 14 fev.
2019.

UJJWALKARN. An Intuitive Explanation of Convolutional Neural Networks. 2016.


Disponível em: <https://ujjwalkarn.me/2016/08/11/intuitive-explanation-convnets/>. Acesso
em: 23 jan. 2019.

UNRUH, Amy. What is the TensorFlow machine intelligence platform? Learn about the
Google-developed open source library for machine learning and deep neurais networks
research. 2017. Disponível em: <https://opensource.com/article/17/11/intro-tensorflow>.
Acesso em: 10 fev. 2019.

WANG, T. et al. End-to-end text recognition with convolutional neural networks. Pattern
Recognition (ICPR), 2012 21st International Conference on. [S.l.]: [s.n.]. 2012. p. 3304-3308.

YEGULALP, Serdar. What is TensorFlow? The machine learning library explained


TensorFlow is a Python-friendly open source library for numerical computation that
makes machine learning faster and easier. Disponível em:
<https://www.infoworld.com/article/3278008/tensorflow/what-is-tensorflow-the-machine-
learning-library-explained.html>. Acesso em: 10 fev. 2019.

ZHANG, Chengwei. Gentle guide on how YOLO Object Localization works with Keras (Part
1). 2018. Disponível em: <https://hackernoon.com/gentle-guide-on-how-yolo-object-
localization-works-with-keras-part-1-aec99277f56f>. Acesso em: 14 fev. 2019.

ZHANG, Chengwei. Gentle guide on how YOLO Object Localization works with Keras
(Part 2). 2018. Disponível em: <https://heartbeat.fritz.ai/gentle-guide-on-how-yolo-object-
localization-works-with-keras-part-2-65fe59ac12d>. Acesso em: 14 fev. 2019.

Você também pode gostar