2018-StephannieLourettiAlbergariaPerezChiang-tcc

Prévia do material em texto

Universidade de Brasília
Instituto de Ciências Exatas
Departamento de Ciência da Computação
Avaliação do Desempenho da plataforma Intel
Galileo Geração 2 no Treinamento de Redes Neurais
Artificiais
Stéphannie Louretti A. P. Chiang
Monografia apresentada como requisito parcial
para conclusão do Curso de Engenharia da Computação
Orientador
Prof. Dr. Alexandre Zaghetto
Brasília
2018
Universidade de Brasília
Instituto de Ciências Exatas
Departamento de Ciência da Computação
Avaliação do Desempenho da plataforma Intel
Galileo Geração 2 no Treinamento de Redes Neurais
Artificiais
Stéphannie Louretti A. P. Chiang
Monografia apresentada como requisito parcial
para conclusão do Curso de Engenharia da Computação
Prof. Dr. Alexandre Zaghetto (Orientador)
CIC/UnB
Prof. Dr. Bruno Macchiavello Prof. Matheus Mendelson
CIC/UnB FGA/UnB
Prof. Dr. Ricardo Pezzuol Jacobi
Coordenador do Curso de Engenharia da Computação
Brasília, 27 de Fevereiro de 2018
Dedicatória
À minha mãe, Goretti, pelas demonstrações de amor, paciência e carinho.
iii
Agradecimentos
À minha mãe Maria Goretti Albergaria de Jesus Perez, por ter sempre se ded-
icado a mim desde o momento que eu nasci e por ter lutado ao meu lado durante os
momentos mais difíceis da minha vida.
Ao meu avô Moysalvo Albergaria Perez (in memoriam), por ter dedicado a mim
tantos momentos de sua vida e ter sido meu maior exemplo de disciplina.
Ao meu pai Chiang Jin Guan, pela ajuda financeira.
Aos meus padrinhos Ardeckiria Albergaria de Jesus Perez e Manoel Muniz
dos Santos, dois exemplos de dedicação e perseverança.
À minha família que sempre me motivou e me apoiou nas minhas decisões.
Ao meu namorado Gustavo Albergaria Brízida Bächtold, por ter me ajudado
tanto com essa monografia e por ter sempre demonstrado muita paciência comigo.
Aos meus amigos, por terem me propiciado tantos momentos de descontração e apoio.
Ao professor Alexandre Zaghetto, por ter me ajudado tanto durante minha for-
mação acadêmica e por ter demonstrado sempre boa vontade durante a orientação desse
trabalho, sempre fui sua grande admiradora.
Ao professor Flavio Barros Vidal, por ter me ajudado com as matrículas durante o
tempo que o professor Zaghetto esteve fora.
À Steve Jobs, por ter sido minha maior fonte de inspiração durante minha formação
acadêmica.
iv
Resumo
Uma rede neural artificial é um processador paralelamente distribuído formado por
várias unidades de processamento simples que tem a capacidade natural de armazenar
conhecimento experimental e torná-lo disponível para o uso. Dentre as diversas finalidades
possíveis, as mais utilizadas são classificação de padrões, categorização, aproximação de
funções e predição. Neste trabalho, a rede neural será utilizada para a classificação de
padrões da flor Íris. A placa Intel Galileo Geração 2 foi criada com o propósito de
auxiliar comunidades educacionais e criadoras, logo é capaz de realizar diversos tipos de
processos com alta eficiência. Porém, quando se trata de treinamento de redes neurais
não se sabe qual a verdadeira capacidade da placa. Este trabalho consiste na utilização
de redes neurais artificiais na placa Galileo Geração 2 e na avaliação do seu desempenho
no treinamento dessas redes através da analise do consumo energético da mesma por meio
da realização de testes individuais. Nele foi possível observar que a placa Intel Galileo
Geração 2 é uma boa ferramenta para aqueles que buscam trabalhar com redes neurais
sem se preocupar com o consumo energético, já que a placa não apresenta maior consumo
de energia quando utiliza redes neurais mais complexas.
Palavras-chave: redes neurais, Intel Galileo, gasto energético
v
Abstract
"An artificial neural network is a parallel distributed processor made up of several
simple processing units that have the natural ability to store experimental knowledge and
make it available for use"[7]. Among the several possible purposes, the most used are
pattern classification, categorization, approximation of functions and prediction. In this
work, the neural network will be used to classify Iris flower patterns. The Intel Galileo
Generation 2 board was created for the purpose of assisting educational and creative
communities, so it is capable of performing many types of processes with high efficiency.
However, when it comes to neural network training it is not known what is the true
capacity of the board. This work consists in the use of artificial neural networks in the
Galileo Generation 2 board and in the evaluation of its performance in the training of
these networks by analyzing the energy consumption of the same by means of individual
tests. It was possible to observe that the Intel Galileo Generation 2 board is a good
tool for those who seek to work with neural networks without worrying about energy
consumption, since the board does not present greater energy consumption when using
more complex neural networks.
Keywords: neural networks, Intel Galileo, energy expenditure
vi
Sumário
1 Introdução 1
1.1 Motivação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Problema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3 Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.4 Descrição dos capítulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2 Fundamentação Teórica e Trabalhos Correlatos 4
2.1 Redes Neurais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.1.1 O cérebro e o neurônio biológico . . . . . . . . . . . . . . . . . . . . 5
2.1.2 Modelo de Neurônio . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.1.3 Neurônio com um vetor de entrada . . . . . . . . . . . . . . . . . . 8
2.1.4 Representação Matemática . . . . . . . . . . . . . . . . . . . . . . . 9
2.1.5 Funções de Transferência . . . . . . . . . . . . . . . . . . . . . . . . 10
2.1.6 Arquiteturas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.1.7 Fluxo de Trabalho . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.1.8 Preparação de dados . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.2 Classificação de padrões . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.2.1 Percepção de máquina . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.2.2 Matriz de confusão . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.3 Plataforma Intel® Galileo . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.3.1 Placa Intel® Galileo Geração 2 . . . . . . . . . . . . . . . . . . . . 18
3 Metodologia Proposta 20
3.1 Projeto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.1.1 Conjunto de dados Iris . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.2 Algoritmo de treinamento . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.2.1 Feed Forward . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.2.2 BackPropagation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.3 Código . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
vii
3.4 Testes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
4 Resultados Experimentais 26
4.1 Análise de resultados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
5 Conclusões e Trabalhos Futuros 30
5.1 Trabalhos Futuros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Referências 32
Apêndice 33
A Código utilizado no projeto 34
Anexo 42
I Tabela de valores do conjunto de dados Iris 43
viii
Lista de Figuras
2.1 Representação em diagrama de blocos do sistema nervoso [7] . . . . . . . . 5
2.2 Célula Piramidal e suas partes: dendritos, corpo celular e axônio [7] . . . . 6
2.3 Neurônio de entrada única [9] . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.4 Neurônio com um vetor de entrada onde R = número de elementos no vetor
de entrada [9] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.5 Neurôniocom um vetor de entrada em notação abreviada onde R = número
de elementos no vetor de entrada [9] . . . . . . . . . . . . . . . . . . . . . . 9
2.6 Modelo matemático de um neurônio. Independentemente das entradas, a
saída normalizada é normalmente apresentada como um número real no
intervalo [0,1] ou [-1,1], dependendo da função de transferência. [7] . . . . . 10
2.7 Quatro tipos clássicos de funções de ativação: (a) threshold, (b) piecewise
linear, (c) sigmoid e (d) gaussiana. [16] . . . . . . . . . . . . . . . . . . . . 11
2.8 Taxonomia das arquiteturas de redes neurais artificiais [16] . . . . . . . . . 11
2.9 Rede neural com uma camada de neurônios onde R = número de elementos
no vetor de entrada e S = número de neurônios na camada [9] . . . . . . . 12
2.10 Matriz de pesos W [9] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.11 Notação abreviada de uma rede neural com uma camada de neurônios onde
R = número de elementos no vetor de entrada e S = número de neurônios
na camada 1 [9] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.12 Rede neural com múltiplas camadas de neurônios [9] . . . . . . . . . . . . . 14
2.13 Notação abreviada de uma rede neural com múltiplas camadas de neurônios
[9] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.14 Matriz de confusão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.15 Placa Intel® Galileo Geração 2 . . . . . . . . . . . . . . . . . . . . . . . . 18
2.16 Especificações da Placa Intel® Galileo Geração 2 . . . . . . . . . . . . . . . 19
3.1 Espécies de Iris . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.2 Rede Neural com 4 entradas e 2 camadas . . . . . . . . . . . . . . . . . . . 22
3.3 Rede Neural com uma camada de entrada, uma camada escondida e uma
camada de saída [16] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
ix
4.1 Gráfico Neurônios x Épocas e Neurônios x Tempo . . . . . . . . . . . . . . 27
4.2 Gráfico Neurônios x ACC . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
x
Lista de Tabelas
4.1 Valores obtidos na segunda fase de testes . . . . . . . . . . . . . . . . . . . 26
4.2 Matriz de confusão para 10 neurônios. ACC = 0,9333. . . . . . . . . . . . 28
4.3 Matriz de confusão para 40 neurônios. ACC = 0,7200. . . . . . . . . . . . 28
4.4 Matriz de confusão para 80 neurônios. ACC = 0,6400. . . . . . . . . . . . 28
4.5 Matriz de confusão para 160 neurônios. ACC = 0,3333. . . . . . . . . . . . 28
I.1 Conjunto de dados Iris . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
xi
Capítulo 1
Introdução
Redes Neurais Artificiais são compostas por simples elementos operando em paralelo.
Esses elementos procuram imitar a estrutura básica do sistema nervoso biológico, o neurô-
nio [6]. Como na natureza, a funcionalidade da rede é determinada pelas conexões entre
estas pequenas centrais de processamento (modelo conexionista). Pode-se treinar uma
rede neural para realizar uma função particular, ajustando os valores das conexões entre
os neurônios, ou seja, ajustando as eficiências sinápticas. Dessa maneira, o conhecimento
fica armazenado nessas conexões e simplesmente emerge como conseqüência da ação em
paralelo dessa coletividade [15].
Os primeiros documentos mencionados sobre redes neurais ou neurocomputação da-
tam de 1943 com McCulloch e Pitts que projetaram a estrutura que é conhecida como
a primeira rede neural. Estes pesquisadores propuseram um modelo de neurônio como
uma unidade de processamento binária e provaram que esta unidade é capaz de executar
muitas operações. Apesar dele ser muito simples, trouxe uma grande contribuição para as
discussões sobre a construção dos primeiros computadores digitais, permitindo a criação
dos primeiros conceitos matemáticos de dispositivos artificiais que buscavam analogias
biológicas [4].
Com o passar do tempo, em 1948, N. Wiener criou a palavra cibernética para descre-
ver, de forma unificada, controle e comunicação nos organismos vivos e nas máquinas. Em
1949, Donald O. Hebb apresentou uma hipótese a respeito da maneira com que a força
das sinapses no cérebro se altera em resposta à experiência. Em particular, ele sugeriu
que as conexões entre células que são ativadas ao mesmo tempo tendem a se fortalecer,
enquanto que as outras conexões tendem a se enfraquecer. Esta hipótese passou a influir
decisivamente na evolução da teoria de aprendizagem em RNAs [4].
Eventualmente, uma expectativa exagerada criada pelos próprios pesquisadores desta
área caiu sobre o estudo de redes neurais. Essa expectativa fez com que os resultados não
fossem à altura do esperado agravando o financiamento das pesquisas. Em 1969, vários
1
autores passaram a argumentar quanto às limitações básicas das redes da época, a come-
çar pela impossibilidade de se implementar regras lógicas tão simples. Historicamente,
essa discussão paralisou as pesquisas na área de redes neurais, com isso os pesquisadores
passaram a buscar por alternativas dentro do campo da engenharia e, principalmente, da
lógica matemática, que, na época, encontrava-se em franca expansão, devido às grandes
conquistas realizadas na área de computação [3].
Foi somente a partir de 1982 que nomes como Teuvo Kohonen, Stephen Grossberg,
B. Widrow, James Anderson, Edoardo Caianiello, Kunuhito Fukushima, Igor Aleksander,
entre outros, passaram a publicar diversas propostas para o desenvolvimento e para as
aplicações de redes neurais, conseguindo assim, novamente estabelecer um campo con-
creto para o renascimento da área. Esta retomada do interesse pela exploração das redes
neurais artificiais deu-se por principalmente: os melhores conhecimentos da estrutura real
do cérebro; a disponibilidade de computadores com maior capacidade de cálculo; o desen-
volvimento de novos algoritmos de aprendizado [4] [3].
Recentemente, redes neurais artificiais tem se tornado a solução para muitas aplica-
ções computacionais, porém o processamento de redes neurais envolve um alto consumo
de energia devido a sua alta complexidade computacional. Como resultado, aparelhos ali-
mentados por bateria ainda não são capazes de rodar redes neurais artificiais complexas
por causa de seu orçamento energético limitado [14].
1.1 Motivação
Com o aumento da importância das redes neurais, redes mais eficientes e mais econô-
micas precisam ser cada vez mais estudadas. Devido ao fato de ser um tema complexo
e ter uma infinidade de aplicações, essas aplicações tem sido o centro de cada vez mais
estudos e cada vez mais cobiçadas no mercado de trabalho. Apesar desse foco atual em
redes neurais, um denominador em comum de todas essas aplicações tem sido esquecido:
o gasto energético. Devido a tal fato, esse estudo esta sendo realizado para ajudar a suprir
esta demanda.
1.2 Problema
Por um tema recente, a eficiência energética de redes neurais tem sido pouco estudada
no campo científico. Com base nisso, este trabalho busca utilizar placas Intel® Galileo
para analisar esta eficiência energética.
2
1.3 Objetivos
O objetivo principal deste trabalho é analisar o gasto energético da placa Intel® Galileo
no treinamento de Redes Neurais Artificiais
Os objetivos específicos são:
• realizar uma revisão de literatura acerca de Redes Neurais e Intel® Galileo;
• escolher um algoritmo de treinamento da rede neural para a realização dos testes;
• verificar o gasto energético de uma placa Intel® Galileo com Redes Neurais de
configurações diferentes e
• relatar os resultados obtidos da realização dos testes.
1.4 Descrição dos capítulos
• Capítulo 2: apresentação da fundamentação teórica e trabalhos correlatos;
• Capítulo 3: proposta de método para solucionar o problema;
• Capítulo 4: apresentação dos resultados experimentais obtidos;
• Capítulo 5: conclusão observada a partir dos resultados obtidos e proposta de tra-
balhos futuros.
3
Capítulo 2
Fundamentação Teórica e Trabalhos
Correlatos
O projeto se baseia na correta aplicação dos conceitosde redes neurais e Intel Galileo.
Nos tópicos a seguir, cada um dos conceitos essenciais para a implementação do projeto
é explicado em sua singularidade.
2.1 Redes Neurais
O reconhecimento de que o cérebro humano processa informações de forma diferente
de um computador digital vem motivando cada vez mais as pesquisas acerca de redes
neurais. O cérebro, como um computador, pode ser interpretado como um sistema de
processamento de informações, altamente complexo, não linear e paralelo [7]. Assim, a
partir do modelo do cérebro, uma rede neural é uma maquina projetada para realizar uma
tarefa particular ou função de interesse.
Uma rede neural é um processador maciçamente paralelamente distribuído constituído
de unidades de processamento simples, que têm a propensão natural para armazenar co-
nhecimento experimental e torná-lo disponível pra o uso [7]. Ela se assemelha ao cérebro
em dois aspectos: O conhecimento é adquirido pela rede a partir de seu ambiente através
de um processo de aprendizagem; Forças de conexão entre neurônios, conhecidas como
pesos sinápticos, são utilizadas para armazenar o conhecimento adquirido[7].
O algoritmo de aprendizagem modifica os pesos sinápticos da rede de forma ordenada,
desse modo o objetivo pode ser alcançado. A teoria dos filtros adaptativos lineares, já
bem estabelecida e aplicada em diversas áreas, possui princípios similares ao método de
modificação dos pesos sinápticos, sendo esse o tradicional para o projeto de redes neurais.
Uma rede neural pode, também, modificar a sua própria topologia, fato que foi inspirado
no fato em que os neurônios no cérebro humano podem morrer e novas conexões são for-
4
madas.
De modo a atingir um bom desempenho, uma interligação maciça de células compu-
tacionais simples (neurônios ou unidades de processamento) é utilizada pela rede neural.
Os dois principais componentes que geram poder computacional de uma rede neural
são: a sua estrutura maciçamente paralelamente distribuída e a sua habilidade de apren-
der e generalizar.
Assim, o uso de redes neurais oferece as seguintes propriedades úteis e capacidade:
não-linearidade, mapeamento de entrada-saída, adaptabilidade, resposta a evidencias, in-
formação contextual, tolerância a falhas, implementação em VLSI, uniformidade de analise
e projeto e analogia neurobiológica.
2.1.1 O cérebro e o neurônio biológico
O sistema nervoso humano pode ser visto como um sistema de três estágios como
mostrado na Figura 2.1:
Figura 2.1: Representação em diagrama de blocos do sistema nervoso [7]
O cérebro, peça central do sistema, é representado pela rede neural. Essa, por sua
vez, recebe continuamente informações, as interpreta e produz uma resposta adequada.
As setas da imagem acima representam a transmissão de sinal. Os receptores, a pri-
meira camada, recebem os estímulos externos e os convertem em impulsos elétricos, sendo
transmitidos para a rede neural (cérebro). Uma vez a informação sendo interpretada, os
atuadores converterão os impulsos elétricos gerados pela rede neural em respostas discer-
níveis como saídas do sistema [7].
A célula fundamental do sistema nervoso central é o neurônio, tendo a função de con-
duzir impulsos elétricos (estímulos elétricos originados das reações físico-químicas). Esse
componente possui três partes: dendritos, corpo celular e axônio [7].
Os dendritos são finos prolongamentos, que se ramifica e adquirem o formato de uma
árvore (árvore dendrítica). A sua função é receber os estímulos de vários outros neurô-
nios.
O corpo celular é onde as principais organelas celulares do neurônio são encontra-
das(núcleo, mitocôndria, centríolo, lisossomo...) [7]. Ele também é responsável pelo pro-
5
cessamento de toda a informação que chega dos dendritos, pela produção de um potencial
de ativação que indica se o neurônio pode instigar um impulso elétrico junto com seu
axônio.
O axônio, por fim, é um único prolongamento cuja principal função é guiar os impulsos
elétricos para outro neurônios de conexão, ou para neurônios diretamente conectados ao
tecido muscular (junção neuro-muscular). A terminação do axônio é também composta
de ramos chamados terminais sinápticos.
Os neurônios aparecem em uma grande variedade de tamanhos e formas dependendo
da sua localização no cérebro. Na Figura 2.2 pode-se ver uma célula piramidal, que é um
dos tipos mais comuns de neurônios corticais:
Figura 2.2: Célula Piramidal e suas partes: dendritos, corpo celular e axônio [7]
6
Diferentemente das portas lógicas, os neurônios orgânicos possuem uma velocidade de
transmissão mais lenta do que estas. Na tentativa de compensar essa taxa de operação
relativamente lenta, a quantidade de neurônios acaba sendo espantosa, havendo conexões
maciças entre si.
As sinapses são uma região que permite a transmissão do impulso elétrico de um
neurônio para outro. O tipo mais comum de sinapse é a sinapse química. Vale ressaltar
que essa conexão pode impor ao neurônio receptivo excitação ou inibição, mas não ambas.
2.1.2 Modelo de Neurônio
O bloco de construção fundamental para redes neurais é o neurônio de entrada única,
como na Figura 2.3:
Figura 2.3: Neurônio de entrada única [9]
Há três operações funcionais distintas que ocorrem neste neurônio. Em primeiro lugar,
a entrada escalar p é multiplicada pelo peso escalar w para formar o produto wp, também
um escalar. Em segundo lugar, a entrada wp ponderada é adicionado ao viés escalar b
para formar a entrada n. Neste caso, o viés esta movendo a função f para a esquerda por
uma quantidade b. O viés é muito parecido com um peso, exceto que tem uma entrada
constante de 1. E finalmente, a entrada é passada através da função de transferência f,
que produz a saída de um escalar.
Os nomes dados a estes três processos são: a função de peso, a função de entrada e
a função de transferência. Para muitos tipos de redes neurais, a função de peso é um
produto de um o peso vezes a entrada, mas outras funções de peso podem ser utilizadas.
Note que w e b são ambos parâmetros escalares ajustáveis do neurônio. A ideia central
da rede neural é que estes parâmetros podem ser ajustados de modo que a rede apresenta
7
um comportamento desejado ou interessante. Assim, pode-se treinar a rede para fazer
um trabalho específico, ajustando os parâmetros de peso ou viés.
2.1.3 Neurônio com um vetor de entrada
O neurônio simples pode ser estendido para lidar com entradas que são vetores[9]. Um
neurônio com um único vetor de entrada R-elemento é mostrado na Figura 2.4 abaixo:
Figura 2.4: Neurônio com um vetor de entrada onde R = número de elementos no vetor
de entrada [9]
Nele, os elementos de entrada individuais p1, p2...pR, são multiplicados pelos pesos w1,1;
w1,2;...w1,R. E os valores ponderados são alimentados para a junção de soma. A sua soma
é simplesmente Wp, o produto escalar da matriz (de única linha) W e do vetor p.
O neurônio tem um viés b, que é somado com as entradas ponderadas para formar a
entrada n. A entrada n é o argumento da função de transferência f.
Para o modelo acima existe uma notação abreviada (Figura 2.5).
A Figura 2.5 de um único neurônio mostrado acima contém uma grande quantidade de
detalhes. Quando considera-se redes com muitos neurônios, e talvez camadas de muitos
neurônios, há tantos detalhes que os principais pensamentos tendem a ser perdidos. Assim,
os autores criaram uma notação abreviada para um neurônio individual. Nela, o vetor de
entrada p é representado pela barra vertical sólida escura no lado esquerdo. As dimensões
de p são mostradas abaixo do símbolo P na Figura como R × 1. Assim, p representa um
vetor de R elementos de entrada.
Como antes, uma constante 1 entra no neurônio como uma entrada e é multiplicada
por um viés escalar b. A entrada para a função de transferência F é: N, a soma do viés
8
Figura 2.5: Neurônio com um vetor de entrada em notação abreviada onde R = número
de elementos no vetor de entrada [9]
b e o produto Wp. Esta soma é passada para a função de transferência F para obter a
saída A do neurônio,que neste caso é um escalar.
Note que se houvesse mais do que um neurônio, a saída da rede seria um vetor.
A Figura também define uma camada de uma rede. Uma camada inclui os pesos,
a multiplicação e operações de soma (aqui realizadas, tal como um produto vetor Wp),
o viés b, e a função de transferência f. Assim, existem três operações que ocorrem na
camada: a função de ponderação, a função de entrada e a função de transferência.
2.1.4 Representação Matemática
Um modelo matemático não linear de um neurônio pode ser encontrado na Figura 2.6.
Neste modelo é possível perceber que o conjunto de estímulos, p1, p2, p3, ..., pR são
amplificadas ou atenuadas através do uso dos pesos sinápticos w1,1, w1,2, w1,3, ..., w1,R
produzindo uma soma ponderada n apresentada na equação 2.1. Destaca-se que o uso do
índice k indica que trata-se do k-ésimo neurônio de uma rede neural artificial e o uso do
índice i indica tratar-se do i-ésimo estímulo aplicado ao neurônio.
n =
R∑
i=1
w1,ipi (2.1)
À essa soma ponderada pode ser adicionado um valor externo comumente chamado de
viés (b) que tem o intuito de realizar uma polarização no neurônio. A polarização tem por
objetivo elevar ou diminuir de maneira ad hoc o valor de n fazendo com que um neurônio
ative-se mais facilmente ou menos facilmente dependendo do valor de b.
A adição do viés à soma ponderada Wp gera uma saída n (Equação 2.2) que por sua
9
Figura 2.6: Modelo matemático de um neurônio. Independentemente das entradas, a
saída normalizada é normalmente apresentada como um número real no intervalo [0,1] ou
[-1,1], dependendo da função de transferência. [7]
vez é o valor de entrada para a função de transferência f(n) conforme se observa na Figura
2.6.
n = Wp + b (2.2)
A função de transferência define a saída a do neurônio, que é representada pela Equa-
ção 2.3. Nota-se que quando existe uma polarização realizada pela inserção de um viés,
a = f(n) e que quando não existe polarização, a = f(Wp).
a =
f(n), se b 6= 0f(Wp), se b = 0 (2.3)
2.1.5 Funções de Transferência
Para completar o entendimento acerca do modelo de neurônio apresentado anterior-
mente resta apresentar um detalhamento sobre como agem as funções de transferência.
A função de transferência f(n), define a saída de um neurônio em termos do campo local
induzido n [7]. Dados um conjunto de entradas, uma distribuição sináptica e um viés,
a função de transferência define a saída do neurônio. A Figura 2.7 apresenta gráficos de
10
alguns tipos clássicos de funções de ativação [7].
Figura 2.7: Quatro tipos clássicos de funções de ativação: (a) threshold, (b) piecewise
linear, (c) sigmoid e (d) gaussiana. [16]
Ao analisar as funções de transferência apresentadas na Figura 2.7 é possível perceber
que todas possuem valores positivos para a saída, em verdade, a saída f(n) é denotada
pelo intervalo [0,1], onde {f(n) ∈ < | 0 ≤ f(n) ≤ 1} e, em termos teóricos (não aplicáveis
computacionalmente), a entrada n é denotada por {n ∈ < | −∞ < n < +∞}.
2.1.6 Arquiteturas
Dois ou mais dos neurônios mostrados anteriormente podem ser combinados numa
camada, e uma rede em particular pode conter um ou mais de tais camadas. Assim, a
arquitetura da rede pode ser de uma camada de neurônios ou de múltiplas camadas de
neurônios. Neste sentido podemos observar a Figura 2.8 que apresenta a taxonomia das
possíveis arquiteturas de uma rede neural artificial [7][1][10][11].
Figura 2.8: Taxonomia das arquiteturas de redes neurais artificiais [16]
11
Uma camada de neurônios
Primeiro, considerando uma única camada de neurônios (Figura 2.9), temos uma rede
de uma camada com elementos de entrada R e neurônios S. Nesta rede, cada elemento do
vector P de entrada está ligada a cada entrada de neurônios através da matriz de pesos
W (Figura 2.10)[9]. Cada neurônio reúne os valores de entrada ponderados e o viés para
formar a sua própria saída de escalar N. Os vários N em conjunto, formam um vetor de
entrada n. E finalmente, as saídas da camada de neurônio formar um vetor coluna a. A
expressão para uma saída é mostrada na parte inferior da Figura 2.9.
Figura 2.9: Rede neural com uma camada de neurônios onde R = número de elementos
no vetor de entrada e S = número de neurônios na camada [9]
É possível notar que é comum que o número de entradas para uma camada ser diferente
do número de neurônios (isto é, R não é necessariamente igual a S). Assim, os elementos
do vetor de entrada entram na rede através da matriz de peso W.
Esta mesma rede mostrada anteriormente também pode ser desenhada em notação
abreviada (Figura 2.11).
Nela, p é um vetor de entrada de comprimento R, W é uma matriz S x R, a e b são
vetores de S de comprimento. Conforme definido anteriormente, a camada de neurônio
12
Figura 2.10: Matriz de pesos W [9]
Figura 2.11: Notação abreviada de uma rede neural com uma camada de neurônios onde
R = número de elementos no vetor de entrada e S = número de neurônios na camada 1
[9]
inclui a matriz de peso, as operações de multiplicação, o vetor viés b, o somatório, e os
blocos de função de transferência.
Múltiplas camadas de neurônios
Uma rede pode ter várias camadas. Cada camada tem uma matriz de peso W, um
vetor viés b, e um vetor de saída a[9]. Assim, na rede mostrada abaixo (Figura 2.12) há
entradas R1, neurônios S1 na primeira camada, neurônios S2 na segunda camada, etc.
Ou seja, é comum para as camadas diferentes de ter diferentes números de neurônios.
Pode-se observar na que uma constante de entrada 1 é alimentada para o viés de cada
neurônio e que as saídas de cada camada intermediária são as entradas para a camada
seguinte. Assim, a camada 2 pode ser analisada como uma rede de uma camada com
entradas S1, neurônios S2 e uma matriz de peso W2 de S2 por S1. Logo, a entrada para
a camada 2 é A1 e a saída é A2.
As camadas de uma rede multicamadas têm papéis diferentes. Uma camada que pro-
13
Figura 2.12: Rede neural com múltiplas camadas de neurônios [9]
duz a saída de rede é denominada uma camada de saída. E todas as outras camadas são
chamadas de camadas ocultas.
Assim, como a rede anterior, a rede de múltiplas camadas também pode ser represen-
tada pela notação abreviada (Figura 2.13).
Figura 2.13: Notação abreviada de uma rede neural com múltiplas camadas de neurônios
[9]
14
2.1.7 Fluxo de Trabalho
Quando se deseja implementar redes neurais, o fluxo de trabalho para o processo de
desenvolvimento tem sete passos:
• Levantar dados
• Criar a rede
• Configurar a rede
• Inicializar os pesos e vieses
• Treinar a rede
• Validar a rede (análise pós-treino)
• Utilizar a rede
Os dados geralmente são coletados fora do framework da rede neural que, depois de
criada, precisa ser configurada e treinada. A configuração involve modelar a rede para que
fique compatível com o problema que se quer resolver, como definido por dados amostrais.
Depois de configurada, os parâmetros da rede chamados pesos e vieses precisam ser
ajustados, para que a performance da rede seja otimizada. Esse processo de ajuste é
referenciado como treinamento da rede.
Tanto a configuração quanto o treino requerem que a rede receba dados de exemplo.
2.1.8 Preparação de dados
Antes de iniciar o processo de design de rede, primeiro deve-se recolher e preparar
dados de amostra. Logo, uma rede só pode ser tão precisa quanto os dados que são
usadas para treinar a rede. Assim, é importante que os dados cubram a gama de entradas
para as quais será utilizada a rede.
Redes multicamadas podem ser treinadas para generalizar bem dentro da faixa de
entradas para os quais eles foram treinadas. No entanto, elas não têm a capacidade de
extrapolar com exatidão para além desta gama, por isso, é importante que os dados de
treinamento abranjam toda a gama do espaço de entrada.
Depois que os dados foram coletados, há duas etapas que precisam ser executadas antes
que os dados sejam usados para treinar a rede: os dados precisam ser pré-processados, e
eles precisam ser divididos em sub-grupos (ou subsets).
15
Funções de processamentode entrada e saída
Funções de processamento de entrada transformam os dados de entrada do usuário
numa forma que seja mais fácil ou mais eficiente para a rede neural. Isso pode acelerar a
aprendizagem para muitas redes.
Já funções de processamento de saída são usadas para transformar vetores alvos dados
pelo usuário para serem usadas na rede neural.
Divisão de dados
Ao treinar redes multicamadas, geralmente primeiro se divide os dados em três subgru-
pos para a otimização do treinamento. O primeiro subgrupo é o grupo de treinamento,
que é usado para calcular o gradiente e atualizar os pesos e vieses da rede, o segundo
subgrupo é o grupo de validação e o terceiro subgrupo é o grupo de teste.
O erro no conjunto de validação é monitorado durante o processo de treinamento.
Este erro normalmente diminui durante a fase inicial de treinamento, assim como o erro
do conjunto de treinamento. No entanto, quando a rede começa a reajustar os dados, o
erro no grupo de validação tipicamente começa a subir.
Já o erro conjunto de teste não é utilizado durante o treinamento, mas é usado para
comparar modelos diferentes. E também é útil para traçar o erro do conjunto de teste
durante o processo de treinamento. Se o erro no conjunto de teste atinge um mínimo em
um número de iteração significativamente diferente do que o erro conjunto de validação,
isso pode indicar uma má divisão do conjunto de dados.
Existem funções para fazer a divisão de dados em grupos de treinamento, validação
e teste, porém, a divisão de dados normalmente é realizado automaticamente quando
se treina a rede. A função de divisão é acessada automaticamente sempre que a rede é
treinada, e é usado para dividir os dados em subgrupos treinamento, validação e de testes.
2.2 Classificação de padrões
Um dos inúmeros possíveis usos para redes neurais é a classificação de padrões, o ato
de pegar dados brutos e realizar uma ação baseada na categoria do padrão [12]. Antes de
falar de Classificação de Padrões é interessante comentar a existência de vários tipos de
padrões, como exemplo: padrões visuais, temporais e lógicos. De forma genérica pode-se
afirmar que encontramos reconhecimento de padrões em todas atividades inteligentes.
A tarefa de reconhecer padrões utilizando redes neurais artificiais não é algo trivial
como ocorre para seres humanos. Para um computador faz-se necessário o uso de algorit-
mos e fórmulas.
16
2.2.1 Percepção de máquina
É natural que devamos procurar projetar e construir máquinas que possam reconhecer
padrões [12]. Do reconhecimento automatizado de fala, identificação de impressões di-
gitais, reconhecimento de caracteres ópticos, identificação de seqüência de DNA e muito
mais, é claro que um reconhecimento de padrão confiável e preciso por máquina seria
imensamente útil. Além disso, ao resolver a miríade de problemas necessários para cons-
truir esses sistemas, obtemos uma compreensão e apreciação mais profunda dos sistemas
de reconhecimento de padrões no mundo natural - sobretudo nos seres humanos. Para
algumas aplicações, como a fala e o reconhecimento visual, nossos esforços de design po-
dem, de fato, ser influenciados pelo conhecimento de como estes são resolvidos, tanto na
área de desenvolvimento como no próprio hardware de uso especial.
2.2.2 Matriz de confusão
Quando analisamos os erros que podem surgir na classificação de padrões podemos
utilizar, além dos gráficos, a matriz de confusão (Figura 2.14).
Figura 2.14: Matriz de confusão
No campo do machine learning, uma matriz de confusão, também conhecida como
uma matriz de erro, é um layout de tabela específico que permite a visualização do de-
sempenho de um algoritmo. O nome deriva do fato de que ela facilita ver se o sistema
está confundindo duas classes (isto é, se está classificando um como o outro). Ao analisar-
mos uma matriz, cada coluna da matriz representa as instâncias de uma classe prevista
enquanto cada linha representa as instâncias em uma classe real (ou vice-versa).
Assim, na análise preditiva, uma matriz de confusão, é uma tabela com duas linhas
e duas colunas que informa o número de falsos positivos, falsos negativos, verdadeiros
positivos e verdadeiros negativos. Isto permite uma análise mais detalhada do que a mera
17
proporção de acertos (precisão), já que a precisão não é uma métrica de confiança para o
desempenho real de um classificador, uma vez que irá produzir resultados enganosos se o
conjunto de dados é desequilibrado (isto é, quando o número de amostras em diferentes
classes variar demais).
2.3 Plataforma Intel® Galileo
2.3.1 Placa Intel® Galileo Geração 2
A placa Intel® Galileo de segunda geração (Figura 2.15) oferece um controlador de
placa única para a comunidade de criadores, estudantes e desenvolvedores profissionais.
Baseada no Intel® QuarkTM SoC X1000, um sistema de classe 32-bit Intel® Pentium
num chip (SoC), o processador Intel® genuíno e capacidades I/O nativas da placa Intel®
Galileo (Gen 2) fornece uma oferta completa para uma ampla gama de aplicações. Cer-
tificada Arduino e desenhada para ser hardware-, software- e pino-compatível com uma
ampla gama de shields Arduino Uno R3, a placa Intel® Galileo geração 2 também ofe-
rece um ambiente de desenvolvimento mais simples e mais custo-efetivo comparado com
designs baseados em processadores Intel® Atom e Intel® Core. Na Figura 2.16 temos as
especificações da placa [8] e os esquemáticos da mesma podem ser encontrados no site da
própria Intel®.
Figura 2.15: Placa Intel® Galileo Geração 2
18
Figura 2.16: Especificações da Placa Intel® Galileo Geração 2
19
Capítulo 3
Metodologia Proposta
Neste capítulo é apresentado o método proposto para a solução do problema.
3.1 Projeto
Para que fosse possível determinar o gasto energético da placa Intel® Galileo Geração
2 no treinamento de Redes Neurais foi elaborado um projeto com as seguintes etapas:
• Determinação do objetivo da rede neural
• Projeto da arquitetura do sistema
• Elaboração do código
• Realização dos testes e coleta de dados
• Análise de resultados
Foi determinado que o objetivo da rede neural seria a classificação de padrões e foi
usado o exemplo da flor Iris introduzido pelo estatístico e biólogo britânico Ronald Fisher
no seu artigo The use of multiple measurements in taxonomic problems em 1936 [5].
3.1.1 Conjunto de dados Iris
O conjunto de dados Iris consiste em 50 amostras de cada uma das três espécies
da flor Iris (Iris setosa, Iris virginica and Iris versicolor) [5]. Foram medidas quatro
características de cada amostra: o comprimento e a largura das sépalas e pétalas, em
centimetros. Com base na combinação destas quatro características, Fisher desenvolveu
um modelo discriminante linear para distinguir as espécies umas das outras. Na Tabela
I.1 do Anexo 1 temos o conjunto de dados Iris e nas Figuras 3.1a, 3.1b e 3.1c temos cada
uma das espécies.
20
(a) Iris setosa
(b) Iris virginica
(c) Iris versicolor
Figura 3.1: Espécies de Iris
21
3.2 Algoritmo de treinamento
Figura 3.2: Rede Neural com 4 entradas e 2 camadas
A rede neural utilizada no projeto foi desenhada para ter 4 entradas e 2 camadas,
sendo que o número de neurônios na camada escondida e na camada de saída variam de
acordo com o teste realizado (Figura 3.2).
O algoritmo de treinamento escolhido para a rede neural foi o backpropagation, que
consiste basicamente de duas etapas [7]:
• Propagação do sinal para frente ou Feed Forward. Nesta etapa, um vetor-coluna é
aplicado à camada de entrada da rede e seus efeitos são propagados até a saídas da
rede, produzido como resposta um número real no caso de um único neurônio na
camada de saída, ou um conjunto de números reais no caso da rede neural apresentar
um conjunto de neurônios na camada de saída. Durante a propagação, os valores
das sinapses e dos vieses são mantidos constantes.
• Retropropagação do erro para trás ou Backpropagation. Um sinal de erro é obtido
através da subtração entre a resposta real e a resposta desejada. Este sinal é então
propagado para trás,realizando o ajuste dos valores sinápticos e viés de maneira
que a resposta real da rede se aproxime da resposta desejada.
22
3.2.1 Feed Forward
Figura 3.3: Rede Neural com uma camada de entrada, uma camada escondida e uma
camada de saída [16]
Para a rede da Figura 3.3, a propagação se inicia com o cálculo do chamado campo
local induzido uj(m) para cada neurônio j da camada oculta segundo a Equação 3.1, onde
xi(m) é o elemento i do sinal de entrada na iteração m, wij(m) é o valor da sinapse que
vem do elemento i da camada de entrada para o neurônio j da camada oculta e R1 é o
número de elementos do vetor de entradas [?].
uj(m) =
R1∑
i=0
wij(m)xi(m) (3.1)
Se i=0 então x0(m)=+1 e wj0 = bj(m), onde bj(m) é o viés do neurônio j da camada
oculta, cuja saída é dada pela Equação 3.2, onde fj é a função de transferência do neurônio
j.
vj(m) = fj(uj(m)) (3.2)
De maneira similar àquela apresentada na Equação 3.1 o campo local induzido para o
neurônio k da camada de saída é dado pela Equação 3.3 onde vj(m) é a saída do neurônio
j da camada oculta na iteração m, wkj é o valor da sinapse que vem do neurônio j da
camada oculta para o neurônio k da camada de saída e R2 é o número de neurônios da
camada oculta.
uk(m) =
R2∑
j=0
wkj(m)vj(m) (3.3)
23
Se j=0 então v0(m)=+1 e wk0 = bk(m), onde bk(m) é o viés do neurônio k da camada
de saída, cuja saída é dada pela Equação 3.4 onde fk é a função de transferência do
neurônio k.
vk(m) = fk(uk(m)) (3.4)
Com o cálculo de vk(m), a primeira etapa foi concluída, que é processo de propagação
do sinal, restando agora realizar a segunda etapa, que é a retropropagação do erro e,
consequentemente, realizar ajustes das sinapses e viés.
3.2.2 BackPropagation
O erro ek(m) é calculado através da subtração do resultado esperado tk(m) pelo re-
sultado obtido pelo processo de propagação do sinal vk(m), conforme pode ser visto na
Equação 3.5 [7].
ek(m) = tk(m)− vk(m) (3.5)
Calculado o erro ek(m), agora é necessário retropropagá-lo ajustando as sinapses e
viés da rede. O primeiro passo para realizar a retropropagação dos erros é calcular os
gradientes [13] locais para cada neurônio.
Para cada neurônio da camada de saída os gradientes são dados pela Equação 3.6 e
para cada neurônio da camada escondida os gradientes são dados pela Equação 3.7, onde
R3 é a quantidade de neurônios da camada de saída.
δk(m) = f ′k(vk(m))ek(m) (3.6)
δj(m) = f ′j(vj(m))
R3∑
k=1
δk(m)wkj(m) (3.7)
Uma vez calculados os gradientes locais, estes são utilizados para calcular a atualização
das sinapses e viés. A atualização dos valores das sinapses que ligam os neurônios da
camada escondida aos neurônios da camada de saída é realizada segundo a Equação 3.8
e, similarmente, a atualização das sinapses que ligam os sinais da camada de entrada aos
neurônios da camada escondida é dada pela Equação 3.9.
wkj(m+ 1) = wkj(m) + ηvj(m)δk(m) (3.8)
wji(m+ 1) = wji(m) + ηxi(m)δj(m) (3.9)
24
Finalmente, os vieses da camada escondida e da camada oculta são atualizados, res-
pectivamente, pelas Equações 3.10 e 3.11.
bk(m+ 1) = bk(m) + ηδk(m) (3.10)
bj(m+ 1) = bj(m) + ηδj(m) (3.11)
O termo η é a taxa de aprendizagem e f ′(∗) é a diferenciação em relação ao argu-
mento. Para que a rede neural melhore sua performance é necessário que vários conjuntos
de entradas padrão sejam inseridos na camada de entrada e que a propagação e a retro-
propagação ocorram diversas vezes. Por fim, um critério de parada deve ser criado, visto
que o resultado ótimo pode não ser encontrado. Um exemplo de critério de parada é, por
exemplo, quando a taxa absoluta da variação do erro médio quadrático para um conjunto
de padrões de entrada ter alcançado um valor mínimo desejado.
3.3 Código
No Apêndice A temos o código utilizado pela placa Intel® Galileo Geração 2 para o
treinamento da rede neural classificadora do conjunto de dados Iris. O código foi inicial-
mente escrito em C e adaptado para C-Arduíno com base nas notas de aula disponibiliza-
das pelo Prof. Alexandre Zaghetto [2] e utiliza o algoritmo de Backpropagation descrito
anteriormente.
3.4 Testes
Para que fosse possível obter os dados foram realizados 4 testes individuais utilizando
uma bateria 9V em cada. Os testes consistem no treinamento de redes neurais na placa
Intel® Galileo Geração 2, todas com o objetivo de classificar o conjunto de dados Iris.
Durante os testes são obtidos os seguintes dados: voltagem inicial da bateria, corrente
inicial, corrente durante o teste, tempo de duração da bateria e quantidades de épocas
calculadas. Os testes finalizavam quando cada bateria esgotava.
25
Capítulo 4
Resultados Experimentais
Neste capítulo são apresentados os resultados experimentais observados a partir do método
proposto no capítulo anterior.
4.1 Análise de resultados
Os resultados da primeira fase de testes foram obtidos através dos testes descritos no
capítulo anterior.
Os testes ocorreram sem intercorrências. O primeiro teste foi realizado com 10 neurô-
nios e decorreu ao longo de 5 min, calculando 67 épocas. A corrente medida ao longo do
teste foi de 4,1 a 5,2 mA. O segundo teste foi realizado com 20 neurônios e decorreu ao
longo de 8 min, calculando 62 épocas. A corrente medida ao longo do teste foi de 4,3 a
5,8 mA. O terceiro teste foi realizado com 40 neurônios e decorreu ao longo de 10min,
calculando 43 épocas. A corrente medida ao longo do teste foi de 4,2 a 5,8 mA. O quarto
teste foi realizado com 80 neurônios e decorreu ao longo de 16min, calculando 29 épocas.
A corrente medida ao longo do teste foi de 4,1 a 5,7 mA.
Após essa primeira fase de testes foi percebido que o multímetro estava interferindo
nos resultados obtidos, assim foi realizada uma nova fase de testes sem o multímetro onde
foi medido apenas o tempo e a quantidades de épocas calculadas, os resultados obtidos
encontram-se na Tabela 4.1 a seguir:
10 neurônios 40 neurônios 80 neurônios 160 neurônios
Tempo (min) 19 20 23 19
Épocas 264 85 51 19
Tabela 4.1: Valores obtidos na segunda fase de testes
26
Ao longo dessa segunda fase de testes foi observado que, embora o tempo de duração
da bateria fosse praticamente o mesmo, quanto maior a quantidade de neurônios menor
era o seu poder de processamento pois a rede neural calculava menos épocas, Figura 4.1.
Figura 4.1: Gráfico Neurônios x Épocas e Neurônios x Tempo
Abaixo, temos também, as matrizes de confusão (Tabelas 4.2, 4.3, 4.4, 4.5), o valor
de acurácia (ACC) obtidos ao final de cada teste e o gráfico de acurácia (Figura 4.2).
A acurácia foi calculada somando os valores da diagonal principal da matriz e dividindo
o resultado por 75, o número de amostras utilizada na validação da rede neural. Vale
explicar que existe uma quarta classe não mostrada nas matrizes: a dos dados que foram
classificados como uma classe não existente.
27
Condição verdadeira
Iris setosa Iris versicolor Iris virginica
Condição prevista Iris setosa 25 0 0Iris versicolor 0 20 0
Iris virginica 0 4 25
Tabela 4.2: Matriz de confusão para 10 neurônios. ACC = 0,9333.
Condição verdadeira
Iris setosa Iris versicolor Iris virginica
Condição prevista Iris setosa 25 0 0Iris versicolor 0 4 0
Iris virginica 0 4 25
Tabela 4.3: Matriz de confusão para 40 neurônios. ACC = 0,7200.
Condição verdadeira
Iris setosa Iris versicolor Iris virginica
Condição prevista Iris setosa 25 0 0Iris versicolor 0 13 14
Iris virginica 0 10 10
Tabela 4.4: Matriz de confusão para 80 neurônios. ACC = 0,6400.
Condição verdadeira
Iris setosa Iris versicolor Iris virginica
Condição prevista Iris setosa 0 0 0Iris versicolor 0 25 25
Iris virginica 0 0 0
Tabela 4.5: Matriz de confusão para 160 neurônios. ACC = 0,3333.
28
Figura 4.2: Gráfico Neurônios x ACC
29
Capítulo 5
Conclusões e Trabalhos Futuros
Recentemente redes neurais se mostraram a solução para muitas aplicações computa-
cionais, porém o processamento de uma rede neural demanda num alto gasto energético
devida a sua alta complexidade computacional. Como resultado aparelhos que utilizam
bateria como fonte de alimentaçãonão podem custear redes neurais complexas devido
a seu limitado orçamento energético [14]. Com isso em mente, espera-se que conforme
aumentamos a complexidade de uma rede neural, o gasto energético da mesma aumente
pois a rede estaria demandando mais energia da fonte energética.
Porém, pode-se concluir a partir dos resultados experimentais obtidos que, quando
utilizada redes neurais para classificação de padrões na placa Intel® Galileo Geração 2
com baterias 9V, o tempo de duração da bateria foi praticamente o mesmo para todos
os teste, o que mostra que conforme aumentamos o número de neurônios, ou seja, au-
mentamos a complexidade da rede, a placa não utilizou mais energia da bateria. Apesar
disso, foi possível observar que conforme aumentamos o número de neurônios o número
de épocas calculadas reduziu e consequentemente a acurácia também reduziu. Com essa
conclusão é possível deduzir a seguinte fórmula para o custo da placa (equação 5.1):
Custo = En×N
Ep
(5.1)
Onde, En = Energia, N = Número de neurônios, Ep = Número de épocas calculadas.
Assim, observa-se que a placa Intel® Galileo Geração 2 é capaz de compensar o gasto
energético através de algum circuito interno gerenciador de energia, o que mostra que
a placa é uma boa ferramenta para aqueles que buscam utilizar redes neurais em suas
aplicações sem se preocupar com o gasto energético.
30
5.1 Trabalhos Futuros
Dentre os possíveis trabalhos futuros estão:
• A realização de mais testes com redes neurais realizando tarefas diferentes
• A elevação da regra ao limite, ou seja, aumentar o número de neurônios até que seja
possível verificar um aumento do gasto energético
• A realização de testes com placas diferentes
31
Referências
[1] Jianchang Mao Anil K. Jain e KM Mohiuddin. Artificial neural networks: A tutorial.
1996. 11
[2] L. P. Calôba. Notas de aula: Redes Neurais Artificiais. CT/DEL/UFRJ, Rio de
Janeiro, 2001. 25
[3] Leandro Nunes de Castro Silva. Análise e síntese de estratégias de aprendizado para
redes neurais artificiais, 1998. 2
[4] Marco Antonio Ferreira Finocchio. Noções de redes neurais artificiais, 2014. 1, 2
[5] R. A. Fisher. The use of multiple measurements in taxonomic problems. 1936. 20
[6] J. S. Griffith. Mathematical Neurobiology: An Introduction to the Mathematics of
the Nervous System. Academic Press, London and New York, 1971. 1
[7] Simon Haykin. Neural Networks: A Comprehensive Foundation. Prentice Hall, USA,
1999. vi, ix, 4, 5, 6, 10, 11, 22, 24
[8] Intel. Documentação da placa intel galileo. 18
[9] Martin T. Hagan Mark Hudson Beale e Howard B. Demuth. Matlab: Neural network
toolbox user’s guide, 2016. ix, 7, 8, 9, 12, 13, 14
[10] Mark H. Beale Martin T. Hagan, Howard B. Demuth e Orlando De Jesús. Neural
network design. PWS publishing company, Boston, 1996. 11
[11] Dan W. Patterson. Artificial neural networks: theory and applications. Prentice Hall
PTR, 1998. 11
[12] Peter E. Hart Richard O. Duda e David G. Stork. Pattern Classification. Wiley,
USA, 2001. 16, 17
[13] James Stewart. Calculus: early transcendentals. Cengage Learning, 2015. 24
[14] Vivienne Sze Tien-Ju Yang, Yu-Hsin Chen. Designing energy-efficient convolutional
neural networks using energy-aware pruning, 2017. 2, 30
[15] Alexandre Zaghetto. Codificação de imagens médicas usando imposição da razão
sinal/ruído local mínima, 2004. 1
32
[16] Cauê Zaghetto. Detecção do mal-posicionamento rotacional de dedos em dispositi-
vos de captura de impressões digitais multivista sem toque utilizando redes neurais
artificiais, 2016. ix, 11, 23
33
Apêndice A
Código utilizado no projeto
#include <SD.h>
#include <math.h>
#define NINPUT 4
#define NHIDDEN 10
#define NOUTPUT 3
#define ALFA 0.100000
double tgh (double);
double lin (double);
double sig (double);
double dtgh (double);
double dlin (double);
double dsig (double);
File myFile, myFile2;
int led = 13;
void setup() {
int i, j, tam, k;
int epoca = 0;
char c = ’ ’;
char str[20];
34
double aux, temp;
double *x, *y, *y_;
double *u, *v;
double *e;
double *b;
double *delta_b;
double *g;
double *d;
double alfa;
double um = 1;
int nInput;
int nHidden;
int nOutput;
pinMode(led, OUTPUT);
// Abre comunicacoes serial e espera a porta abrir:
Serial.begin(9600);
while (!Serial) {
; // espera a porta serial conectar
}
Serial.print("Initializing SD card...");
if (!SD.begin(4)) {
Serial.println("Initialization failed!");
return;
}
Serial.println("Initialization done.");
myFile = SD.open("inputTarget.txt", FILE_READ);
if (myFile) {
nInput = NINPUT;
nHidden = NHIDDEN;
nOutput = NOUTPUT;
35
//---------- inicializar alfa
alfa = ALFA;
x = (double *)calloc(nInput, sizeof(double)); //input
y = (double *)calloc(nOutput, sizeof(double)); //target
y_ = (double *)calloc(nOutput, sizeof(double));
e = (double *)calloc(nOutput, sizeof(double));
u = (double *)calloc((nHidden+nOutput), sizeof(double));
v = (double *)calloc((nHidden+nOutput), sizeof(double));
b = (double *)calloc((nHidden+nOutput), sizeof(double)); //bias
delta_b = (double *)calloc((nHidden+nOutput), sizeof(double)); //delta bias
g = (double *)calloc((nHidden+nOutput), sizeof(double)); //g
d = (double *)calloc((nHidden+nOutput), sizeof(double)); //delta
//---------- pesos hidden layer
double **wh;
wh = (double **)malloc(nInput*sizeof(double *));
for (i=0; i<nInput; i++)
wh[i] = (double *)malloc(nHidden*sizeof(double));
//---------- pesos output layer
double **wo;
wo = (double **)malloc(nHidden*sizeof(double *));
for (i=0; i<nHidden; i++)
wo[i] = (double *)malloc(nOutput*sizeof(double));
//---------- delta pesos hidden layer
double **delta_wh;
delta_wh = (double **)malloc(nInput*sizeof(double *));
for (i=0; i<nInput; i++)
delta_wh[i] = (double *)malloc(nHidden*sizeof(double));
//---------- delta pesos output layer
double **delta_wo;
delta_wo = (double **)malloc(nHidden*sizeof(double *));
for (i=0; i<nHidden; i++)
36
delta_wo[i] = (double *)malloc(nOutput*sizeof(double));
//---------- inicializar bias
for (i=0; i<nHidden+nOutput; i++) {
b[i] = ((double)(rand()%201+(-100)))/100;
while (b[i] == 0) b[i] = ((double)(rand()%201+(-100)))/100;
}
//---------- inicializar pesos
for (i=0; i<nInput; i++) {
for (j=0; j<nHidden; j++) {
wh[i][j] = ((double)(rand()%201+(-100)))/100;
while (wh[i][j] == 0) wh[i][j] = ((double)(rand()%201+(-100)))/100;
}
}
for (i=0; i<nHidden; i++) {
for (j=0; j<nOutput; j++) {
wo[i][j] = ((double)(rand()%201+(-100)))/100;
while (wo[i][j] == 0) wo[i][j] = ((double)(rand()%201+(-100)))/100;
}
}
//---------- input targets
tam = myFile.parseInt();
double **it;
it = (double **)malloc((tam)*sizeof(double *));
for (i=0; i<tam; i++)
it[i] = (double *)malloc((nInput+nOutput)*sizeof(double));
for (i=0; i<tam; i++) {
for (j=0; j<(nInput+nOutput); j++) {
temp = myFile.parseFloat();
it[i][j] = temp;
}
}
digitalWrite(led, HIGH);
delay(10);
37
while (epoca<100000) { //10000 epocas
for (k=0; k<tam; k++) {
for (j=0; j<nInput; j++) {
x[j]=it[k][j];
}
for (i=0; i<nOutput; i++) {
y[i]=it[k][i+nInput];
}
//------------------ feed forward --------------------
//------------------ hidden layer --------------------
for (i=0; i<nHidden; i++) {
u[i] = um*b[i];
}
for (j=0; j<nInput; j++) {
for (i=0; i<nHidden; i++) {
u[i] = u[i] + wh[j][i]*x[j];
}
}
for (i=0; i<nHidden; i++) {
v[i] = sig(u[i]);
}
//------------------ output layer --------------------
for (i=0; i<nOutput; i++) {
u[i+nHidden] = um*b[i+nHidden];
}
for (j=0; j<nHidden; j++) {
for (i=0; i<nOutput; i++) {
u[i+nHidden] = u[i+nHidden] + wo[j][i]*v[j];
}
}
for (i=0; i<nOutput; i++) {
v[i+nHidden] = sig(u[i+nHidden]);
38
}
//----------- saida
for (i=0; i<nOutput; i++) {
y_[i] = v[i+nHidden];
}
//----------- erro
for (i=0; i<nOutput; i++) {
e[i] = y[i]-y_[i];
}
//------------------ backpropagation ------------------
for (j=0; j<nHidden; j++) {
g[j] = dsig(v[j]);
}
for (j=0; j<nOutput; j++) {
g[j+nHidden] = dsig(v[j+nHidden]);
}//------------------ delta ----------------------------
//------------------ output layer ---------------------
for (i=0; i<nOutput; i++) {
d[i+nHidden] = e[i]*g[i+nHidden];
}
//------------------ hidden layer ---------------------
for (j=0; j<nOutput; j++) {
for (i=0; i<nHidden; i++) {
d[i] = d[i] + d[j+nHidden]*wo[i][j];
}
}
for (i=0; i<nHidden; i++) {
d[i] = d[i]*g[i];
}
//----------- atualizacao das sinapses ----------------
//---------------------- bias -------------------------
for (i=0; i<nHidden+nOutput; i++) {
39
delta_b[i] = 2*alfa*um*d[i];
b[i] = b[i]+delta_b[i];
}
//------------------ pesos hidden layer ---------------
for (i=0; i<nHidden; i++) {
for (j=0; j<nInput; j++) {
delta_wh[j][i] = 2*alfa*x[j]*d[i];
wh[j][i] = wh[j][i]+delta_wh[j][i];
}
}
//------------------ pesos output layer ---------------
for (i=0; i<nHidden; i++) {
for (j=0; j<nOutput; j++) {
delta_wo[i][j] = 2*alfa*v[i]*d[j+nHidden];
wo[i][j] = wo[i][j]+delta_wo[i][j];
}
}
//------------------ imprime bias pesos ---------------
Serial.print("\nepoca ");
Serial.print(epoca);
Serial.print("\ntest ");
Serial.print(k);
Serial.print("\nbias\n");
for (i=0; i<nHidden+nOutput; i++) {
Serial.print(b[i],6);
Serial.print("\n");
}
Serial.print("\npesos hidden\n");
for (i=0; i<nInput; i++) {
for (j=0; j<nHidden; j++) {
40
Serial.print(wh[i][j],6);
Serial.print("\n");
}
}
Serial.print("\npesos output\n");
for (i=0; i<nHidden; i++) {
for (j=0; j<nOutput; j++) {
Serial.print(wo[i][j],6);
Serial.print("\n");
}
}
}
epoca++;
}
digitalWrite(led, LOW);
delay(10);
// Fecha o arquivo:
myFile.close();
} else {
// Se o arquivo nao abrir, imprime um erro:
Serial.println("Error opening inputTarget.txt");
}
return;
}
double tgh (double x){
double y;
y = 2/(1+exp(-2*x))-1;
return y;
}
double lin (double x){
double y;
41
y = x;
return y;
}
double sig (double x){
double y;
y = 1/(1+exp(-x));
return y;
}
double dtgh (double x){
double y;
y = 1-x*x;
return y;
}
double dlin (double x){
double y;
y = 1;
return y;
}
double dsig (double x){
double y;
y = x*(1-x);
return y;
}
void loop() {
}
42
Anexo I
Tabela de valores do conjunto de
dados Iris
Sepal length Sepal width Petal length Petal width Species
4.3 3.0 1.1 0.1 I.setosa
4.4 2.9 1.4 0.2 I.setosa
4.4 3.0 1.3 0.2 I.setosa
4.4 3.2 1.3 0.2 I.setosa
4.5 2.3 1.3 0.3 I.setosa
4.6 3.1 1.5 0.2 I.setosa
4.6 3.4 1.4 0.3 I.setosa
4.6 3.6 1.0 0.2 I.setosa
4.6 3.2 1.4 0.2 I.setosa
4.7 3.2 1.3 0.2 I.setosa
4.7 3.2 1.6 0.2 I.setosa
4.8 3.4 1.6 0.2 I.setosa
4.8 3.0 1.4 0.1 I.setosa
4.8 3.4 1.9 0.2 I.setosa
4.8 3.1 1.6 0.2 I.setosa
4.8 3.0 1.4 0.3 I.setosa
4.9 3.0 1.4 0.2 I.setosa
4.9 3.1 1.5 0.1 I.setosa
4.9 3.1 1.5 0.2 I.setosa
4.9 3.6 1.4 0.1 I.setosa
4.9 2.4 3.3 1.0 I.versicolor
4.9 2.5 4.5 1.7 I.virginica
43
5.0 3.6 1.4 0.3 I.setosa
5.0 3.4 1.5 0.2 I.setosa
5.0 3.0 1.6 0.2 I.setosa
5.0 3.4 1.6 0.4 I.setosa
5.0 3.2 1.2 0.2 I.setosa
5.0 3.5 1.3 0.3 I.setosa
5.0 3.5 1.6 0.6 I.setosa
5.0 3.3 1.4 0.2 I.setosa
5.0 2.0 3.5 1.0 I.versicolor
5.0 2.3 3.3 1.0 I.versicolor
5.1 3.5 1.4 0.3 I.setosa
5.1 3.8 1.5 0.3 I.setosa
5.1 3.7 1.5 0.4 I.setosa
5.1 3.3 1.7 0.5 I.setosa
5.1 3.4 1.5 0.2 I.setosa
5.1 3.8 1.9 0.4 I.setosa
5.1 3.8 1.6 0.2 I.setosa
5.1 2.5 3.0 1.1 I.versicolor
5.2 3.5 1.4 0.2 I.setosa
5.2 3.5 1.5 0.2 I.setosa
5.2 3.4 1.4 0.2 I.setosa
5.2 4.1 1.5 0.1 I.setosa
5.2 2.7 3.9 1.4 I.versicolor
5.3 3.7 1.5 0.2 I.setosa
5.4 3.9 1.7 0.4 I.setosa
5.4 3.7 1.5 0.2 I.setosa
5.4 3.9 1.3 0.4 I.setosa
5.4 3.4 1.7 0.2 I.setosa
5.4 3.4 1.5 0.4 I.setosa
5.4 3.0 4.5 1.5 I.versicolor
5.5 4.2 1.4 0.2 I.setosa
5.5 3.5 1.3 0.2 I.setosa
5.5 2.3 4.0 1.3 I.versicolor
5.5 2.4 3.8 1.1 I.versicolor
5.5 2.4 3.7 1.0 I.versicolor
44
5.5 2.5 4.0 1.3 I.versicolor
5.5 2.6 4.4 1.2 I.versicolor
5.6 2.9 3.6 1.3 I.versicolor
5.6 3.0 4.5 1.5 I.versicolor
5.6 2.5 3.9 1.1 I.versicolor
5.6 3.0 4.1 1.3 I.versicolor
5.6 2.7 4.2 1.3 I.versicolor
5.6 2.8 4.9 2.0 I.virginica
5.7 4.4 1.5 0.4 I.setosa
5.7 3.8 1.7 0.3 I.setosa
5.7 2.8 4.5 1.3 I.versicolor
5.7 2.6 3.5 1.0 I.versicolor
5.7 3.0 4.2 1.2 I.versicolor
5.7 2.9 4.2 1.3 I.versicolor
5.7 2.8 4.1 1.3 I.versicolor
5.7 2.5 5.0 2.0 I.virginica
5.8 4.0 1.2 0.2 I.setosa
5.8 2.7 4.1 1.0 I.versicolor
5.8 2.7 3.9 1.2 I.versicolor
5.8 2.6 4.0 1.2 I.versicolor
5.8 2.7 5.1 1.9 I.virginica
5.8 2.8 5.1 2.4 I.virginica
5.8 2.7 5.1 1.9 I.virginica
5.9 3.0 4.2 1.5 I.versicolor
5.9 3.2 4.8 1.8 I.versicolor
5.9 3.0 5.1 1.8 I.virginica
6.0 2.2 4.0 1.0 I.versicolor
6.0 2.9 4.5 1.5 I.versicolor
6.0 2.7 5.1 1.6 I.versicolor
6.0 3.4 4.5 1.6 I.versicolor
6.0 2.2 5.0 1.5 I.virginica
6.0 3.0 4.8 1.8 I.virginica
6.1 2.9 4.7 1.4 I.versicolor
6.1 2.8 4.0 1.3 I.versicolor
6.1 2.8 4.7 1.2 I.versicolor
45
6.1 3.0 4.6 1.4 I.versicolor
6.1 3.0 4.9 1.8 I.virginica
6.1 2.6 5.6 1.4 I.virginica
6.2 2.2 4.5 1.5 I.versicolor
6.2 2.9 4.3 1.3 I.versicolor
6.2 2.8 4.8 1.8 I.virginica
6.2 3.4 5.4 2.3 I.virginica
6.3 3.3 4.7 1.6 I.versicolor
6.3 2.5 4.9 1.5 I.versicolor
6.3 2.3 4.4 1.3 I.versicolor
6.3 3.3 6.0 2.5 I.virginica
6.3 2.9 5.6 1.8 I.virginica
6.3 2.7 4.9 1.8 I.virginica
6.3 2.8 5.1 1.5 I.virginica
6.3 3.4 5.6 2.4 I.virginica
6.3 2.5 5.0 1.9 I.virginica
6.4 3.2 4.5 1.5 I.versicolor
6.4 2.9 4.3 1.3 I.versicolor
6.4 2.7 5.3 1.9 I.virginica
6.4 3.2 5.3 2.3 I.virginica
6.4 2.8 5.6 2.1 I.virginica
6.4 2.8 5.6 2.2 I.virginica
6.4 3.1 5.5 1.8 I.virginica
6.5 2.8 4.6 1.5 I.versicolor
6.5 3.0 5.8 2.2 I.virginica
6.5 3.2 5.1 2.0 I.virginica
6.5 3.0 5.5 1.8 I.virginica
6.5 3.0 5.2 2.0 I.virginica
6.6 2.9 4.6 1.3 I.versicolor
6.6 3.0 4.4 1.4 I.versicolor
6.7 3.1 4.4 1.4 I.versicolor
6.7 3.0 5.0 1.7 I.versicolor
6.7 3.1 4.7 1.5 I.versicolor
6.7 2.5 5.8 1.8 I.virginica
6.7 3.3 5.7 2.1 I.virginica
46
6.7 3.1 5.6 2.4 I.virginica
6.7 3.3 5.7 2.5 I.virginica
6.7 3.0 5.2 2.3 I.virginica
6.8 2.8 4.8 1.4 I.versicolor
6.8 3.0 5.5 2.1 I.virginica
6.8 3.2 5.9 2.3 I.virginica
6.9 3.1 4.9 1.5 I.versicolor
6.9 3.2 5.7 2.3 I.virginica
6.9 3.1 5.4 2.1 I.virginica
6.9 3.1 5.1 2.3 I.virginica
7.0 3.2 4.7 1.4 I.versicolor
7.1 3.0 5.9 2.1 I.virginica
7.2 3.6 6.1 2.5 I.virginica
7.2 3.2 6.0 1.8 I.virginica
7.2 3.0 5.8 1.6 I.virginica
7.3 2.9 6.3 1.8 I.virginica
7.4 2.8 6.1 1.9 I.virginica
7.6 3.0 6.6 2.1 I.virginica
7.7 3.8 6.7 2.2 I.virginica
7.7 2.6 6.9 2.3 I.virginica
7.7 2.8 6.7 2.0 I.virginica
7.9 3.8 6.4 2.0 I.virginica
Tabela I.1: Conjunto de dados Iris
47
	Dedicatória
	Agradecimentos
	Resumo
	Abstract
	Introdução
	Motivação
	Problema
	Objetivos
	Descrição dos capítulos
	Fundamentação Teórica e Trabalhos Correlatos
	Redes Neurais
	O cérebro e o neurônio biológico
	Modelo de Neurônio
	Neurônio com um vetor de entrada
	Representação Matemática
	Funções de Transferência
	Arquiteturas
	Fluxo de Trabalho
	Preparação de dados
	Classificação de padrões
	Percepção de máquina
	Matriz de confusão
	Plataforma Intel® Galileo
	Placa Intel® Galileo Geração 2
	Metodologia Proposta
	Projeto
	Conjunto de dados Iris
	Algoritmo de treinamento
	Feed Forward
	BackPropagation
	Código
	Testes
	Resultados Experimentais
	Análise de resultados
	Conclusões e Trabalhos Futuros
	Trabalhos Futuros
	Referências
	Apêndice
	Código utilizado no projeto
	Anexo
	Tabela de valores do conjunto de dados Iris