UNIVERSIDADE TECNOLÓGICA FEDERAL DO PARANÁ COORDENAÇÃO DE ENGENHARIA ELETRÔNICA (COELE) ENGENHARIA ELETRÔNICA
JEU TONETE ROGÉRIO LUIS FONTANÁRIO
IMPLEMENTAÇÃO DE REDE NEURAL PERCEPTRON EM FPGA USANDO VHDL VHDL
TOLEDO - PR 2016
JEU TONETE ROGÉRIO LUIS FONTANÁRIO
IMPLEMENTAÇÃO DE REDE NEURAL PERCEPTRON EM FPGA USANDO VHDL VHDL
Trabalho
apresentado
como
parte
integrante das atividades avaliativas da disciplina Lógica Reconfigurável. Reconfigurável. Professor: Felipe Pfirmer.
TOLEDO - PR 2016
LISTA DE ILUSTRAÇÕES
Figura 1 - Diagrama de blocos da rede Perceptron.....................................................9 Figura 2 - Entrada em forma matricial. ......................................................................10 Figura 3 - Entrada em forma linear............................................................................10 Figura 4 - Saída alvo, código ASCII. .........................................................................11 Figura 5 – Matriz de pesos sinápticos para a rede neural Perceptron. .....................11 Figura 6 – BIAS para os neurônios da rede neural. .................................................. 11 Figura 7 – Kit de FPGA DE0 Terasic.........................................................................12 Figura 8 – RTL Viewer do componente TopLayer. ....................................................13 Figura 9 - RTL Viewer de um componente Neuronio. ...............................................15 Figura 11 - RTL Viewer do componente Perceptron.vhd .......................................... 17 Figura 10 - RTL Viewer de um componente ParallelTransfer....................................18
SUMÁRIO
1 INTRODUÇÃO .....................................................................................................4 2 REDES NEURAIS PERCEPTRON ......................................................................5 3 DESENVOLVIMENTO DE UMA REDE PARA RECONHECIMENTO DE CARACTERES .......................................................................................................8
3.1 PARÂMENTROS DA REDE NEURAL ..............................................................8 3.2 TREINAMENTO DA REDE ...............................................................................9 3.2.1 Entradas .........................................................................................................9 3.2.2 Alvo .................................................................................................................10 3.2.3 Resultados ......................................................................................................11 4 IMPLEMENTAÇÃO DA REDE NEURAL NA FPGA ............................................12
4.1 COMPONENTES CRIADOS .............................................................................13 5 CONCLUSÃO .......................................................................................................20 REFERÊNCIAS .......................................................................................................21
4
1 INTRODUÇÃO
O campo de estudo de Redes neurais artificiais é uma importante área de pesquisa para o setor da engenharia eletrônica, pois as mesmas podem ser aplicadas na resolução de diversos problemas de engenharia, como identificação de padrões, analise de resultados, etc. Um dos maiores problemas na utilização de redes neurais é a quantidade de cálculos que ela precisa executar para se obter os resultados desejados. Considerando que ela consuma um grande valor de processamento, é proposto nesse trabalho a utilização de FPGAs para essa tarefa. As FPGAs sendo um chip com hardware programado nos permite a criação de CIs para aplicações especificas, resultando numa maior otimização de sua estrutura e também em uma grande velocidade de execução de suas tarefas. Com o intuito de otimizar a execução de uma rede neural, decidiu criar uma utilizando FPGA. Este trabalho tem como objetivo a implementação de uma rede neural artificial sem realimentação (‘feedforward’) que realize o reconhecimento de caracteres
alfabéticos (somente vogais) e faça a codificação desse mesmo caractere em seu respectivo valor da tabela ASCII. Para isso será montada uma rede Perceptron e utilizando a ferramenta NNTools do MatLab será feito o treinamento da mesma. Após a obtenção do valor dos pesos, será montada uma essa rede em uma FPGA e testada com os valores de treinamento e com alguns poucos erros.
5
2 REDES NEURAIS PERCEPTRON
Redes Neurais Artificiais são técnicas computacionais que apresentam um modelo matemático inspirado na estrutura neural de organismos inteligentes e que adquirem conhecimento através da experiência. Uma grande rede neural artificial pode ter centenas ou milhares de unidades de processamento; já o cérebro de um mamífero pode ter muitos bilhões de neurônios. O sistema nervoso é formado por um conjunto extremamente complexo de células, os neurônios. Eles têm um papel essencial na determinação do funcionamento e comportamento do corpo humano e do raciocínio. Os neurônios são formados pelos dendritos, que são um conjunto de terminais de entrada, pelo corpo central, e pelos axônios que são longos terminais de saída.
Figura 1 - Consti tuint es da célula neuronal - esquema.
Os neurônios se comunicam através de sinapses. Sinapse é a região onde dois neurônios entram em contato e através da qual os impulsos nervosos são transmitidos entre eles. Os impulsos recebidos por um neurônio A, em um determinado momento, são processados, e atingindo um dado limiar de ação, o neurônio A dispara, produzindo uma substância neurotransmissora que flui do corpo celular para o axônio, que pode estar conectado a um dendrito de um outro neurônio B. O neurotransmissor pode diminuir ou aumentar a polaridade da membrana póssináptica, inibindo ou excitando a geração dos pulsos no neurônio B. Este processo depende de vários fatores, como a geometria da sinapse e o tipo de neurotransmissor. Uma rede neural artificial é composta por várias unidades de processamento, cujo funcionamento é bastante simples. Essas unidades, geralmente são conectadas
6
por canais de comunicação que estão associados a determinado peso. As unidades fazem operações apenas sobre seus dados locais, que são entradas recebidas pelas suas conexões. O comportamento inteligente de uma Rede Neural Artificial vem das interações entre as unidades de processamento da rede. A operação de uma unidade de processamento, proposta por McCullock e Pitts em 1943, pode ser resumida da seguinte maneira:
Sinais são apresentados à entrada;
Cada sinal é multiplicado por um número, ou peso, que indica a sua influência na saída da unidade;
É feita a soma ponderada dos sinais que produz um nível de atividade;
Se este nível de atividade exceder um certo limite (threshold) a unidade produz uma determinada resposta de saída.
Figura 2 -Esquema de uni dade McCullock - Pitts.
A propriedade mais importante das redes neurais é a habilidade de aprender de seu ambiente e com isso melhorar seu desempenho. Isso é feito através de um processo iterativo de ajustes aplicado a seus pesos, o treinamento. O aprendizado ocorre quando a rede neural atinge uma solução generalizada para uma classe de problemas. Denomina-se algoritmo de aprendizado a um conjunto de regras bem definidas para a solução de um problema de aprendizado. Existem muitos tipos de algoritmos de aprendizado específicos para determinados modelos de redes neurais,
7
estes algoritmos diferem entre si principalmente pelo modo como os pesos são modificados. Outro fator importante é a maneira pela qual uma rede neural se relaciona com o ambiente. Nesse contexto existem os seguintes paradigmas de aprendizado:
Aprendizado Supervisionado, quando é utilizado um agente externo que indica à rede a resposta desejada para o padrão de entrada;
Aprendizado Não Supervisionado (auto-organização), quando não existe um agente externo indicando a resposta desejada para os padrões de entrada;
Reforço, quando um crítico externo avalia a resposta fornecida pela rede.
8
3 DESENVOLVIMENTO DE UMA
REDE PARA
RECONHECIMENTO DE
CARACTERES
O reconhecimento visual de caracteres vem sendo um dos grandes problemas da atualidade, uma vez que cada vez mais se torna necessário que um sistema digital consiga entender o que as lentes de suas câmeras captam apenas no formato de imagem. Esse desafio vem sendo enfrentado de diversas formas diferentes por todo mundo (dependendo de cada pesquisador, cientista, e etc.) e um dos métodos comumente encontrado é o de dividir a imagem captura em milhares de pixels e tratalos em grupo individuais para conseguir ter um reconhecimento da imagem em sua totalidade. Tendo o conhecimento desse método de análise e da teoria de redes neurais foi decido criar um programa que conseguisse identificar caracteres no formato 4x5 pixels e os codificasse no valor binário que os representa na tabela ASCII. A problemática principal é receber uma matriz de 1 e 0 que representa uma das 5 vogais do alfabeto e devolver um código em ASCII que representa aquela mesma vogal. Decidiu-se utilizar somente vogais em função do tempo escasso e da complexidade necessária para construir e testar uma rede neural que conseguisse identificar todo o alfabeto. 3.1 PARÂMENTROS DA REDE NEURAL Como citado acima, foi utilizado a rede neural do tipo Perceptron por sua adaptação ao problema e sua convergência. A escolha desse tipo de rede foi feita comparando o desempenho desta com a do tipo Múltiplas Camadas (nomeada como FeedForward BackPropagtion no MatLab), que não ofereceu desempenho satisfatório com relação aos erros independentemente do número de neurônios usados na primeira camada. Foi utilizado a ferramenta “NNTOOL” presente no Matlab, ferramenta esta que
auxiliou a criação e o treinamento da nossa rede neural.
9
Os parâmetros para qual a nossa rede foi configurada são:
Tipo da rede: Perceptron;
Função de transferência: HARDLIM;
Função de aprendizado: LEARNP;
Número de entradas: 20;
Número de saídas: 8;
Número de neurônios: 8;
Figura 3 - Diagrama de blocos d a rede Perceptron.
3.2 TREINAMENTO DA REDE 3.2.1 Entradas Como entrada do nosso treinamento representamos cada caractere como uma matriz binária 4x5, nela tentou-se imitar a construção gráfica de letras pixels a pixels, simulando como ocorre realmente nas telas e displays em geral. Para adaptar essa entrada na nossa rede dispomos a entrada, que era matricial, em forma de uma única linha de vinte bits.
10
Figura 4 - Entrada em fo rma matrici al.
Figura 5 - Entrada em for ma linear.
3.2.2 Alvo A saída do nosso sistema é o código binário ASCII para os caracteres vogais maiúsculos e está representado na figura abaixo, contendo sete bits.
11
Figur a 6 - Saída alvo, cód igo ASCII.
3.2.3 Resultados
Ao convergir para um erro nulo, para as entradas e saídas desejadas, é obtido como resultado do treinamento uma matriz contendo os pesos sinápticos para a rede neural e também uma matriz de bias. Esses dados serão posteriormente agregados ao código VHDL para implementação da rede na FPGA.
Figura 7 – Matriz de pesos sináptico s para a rede neural Perceptron.
Figura 8 – BIAS para os n eurônios da rede neural.
12
4 IMPLEMENTAÇÃO DA REDE NEURAL NA FPGA
Para o projeto foi utilizado o kit DE0 da Terasic que contém a FPGA Cyclone 3 da Altera com 6 mil elementos lógicos e o software de programação foi o Quartus 2 v13.
Figura 9 – Kit de FPGA DE0 Terasic.
Basicamente foi desenvolvido dois componentes referentes a rede neural: neuronio.vhd e perceptron.vdh. Para a aplicação dos dados optou-se usar as chaves da placa de desenvolvimento, por isso foi criado o componente parallelTransfer.vhd que faz a leituras dos bits de cada entrada e joga em um buffer de entradas que será aplicada a rede Perceptron. Fora esses componentes foi criado o componente toplayer chamado circuit.vhd que faz a instanciação da rede neural e do sistema de transferência de dados. No kit DE0 a rede teve o seguinte mapeamento de pinos: DE0 switches
FPGA Pins
Input
sw3
G4
ce
sw2
H6
clk
sw0
J6
dataInput
13
DE0 switches
FPGA Pins
Output
LEDG7
C2
dataOutput(7)
LEDG6
C1
dataOutput(6)
LEDG5
E1
dataOutput(5)
LEDG4
F2
dataOutput(4)
LEDG3
H1
dataOutput(3)
LEDG2
J3
dataOutput(2)
LEDG1
J2
dataOutput(1)
LEDG0
J1
dataOutput(0)
4.1 COMPONENTES CRIADOS
“circuit.vhd”
O componente toplayer circuit.vhd instancia além da rede neural, um componente que direciona uma entrada de dados para um vetor de dados que é aplicado a rede e um debounce para o botão de clock.
Figura 10 – RTL Viewer do compon ente TopLayer.
“neurônio_def.vhd”
O arquivo neurônio_def contém as principais definições para a criação de um neurônio, como a quantidade de entradas, o número de bits que cada entrada contém, número de bit que cada dado de peso e o tipo que é a entrada e saída. Possui também definições para os tipos de dados usados no projeto. A utilização de novos tipos com tamanhos genéricos é muito útil para a reutilização do código para outras redes de diferentes tamanhos.
14
“Neur o nio.vhd”
Este componente contém a implementação de um neurônio artificial com função de ativação HARDLIM. Ele recebe um vetor de entrada de dados que será multiplicado pelos pesos sinápticos, o resultado disso é somado juntamente com o BIAS.
A representação do componente depende muito dos paramentos genéricos entregues a ele, mas se assemelha a figura a baixo.
15
Figura 11 - RTL Viewer de um compo nente Neuron io.
“ P erceptron.vhd ”
O componente perceptron instancia todos os componentes neurônios da rede. Nele é definido os pesos sinápticos aplicados a cada neurônio tanto quanto o BIAS do mesmo. Tem com entrada um array de dados com tamanho igual à quantidade de entradas da rede e um array de dados de saídas com a quantidade de neurônios.
16
17
Figura 12 - RTL Viewer do compo nente Perceptron .vhd
18
“ParallelTransfer.vhd”
O arquivo “parallelTransfer.vhd” é usado para a transferência de dados para
a rede neural. Ele utiliza um pino para Chip Enable (CE), um pino para Clock (CLK), e N pinos para o dado. Após colocar o CE para nível baixo, ele zera o indexador referente a quantos dados serão lidos, e assim começa uma nova leitura. Ele então espera uma subida de CLK para então ler os dados e assim armazenar esse dado de N bits na primeira posição de um vetor. Após isso, mantem se o CE em nível baixo até o final de toda a transferência de dados e a cada subida de CLK um novo dado é adicionado ao vetor. A saída desse arquivo é um vetor de dados que será usado no TopLayer para ser a entrada da rede neural.
Figura 13 - RTL Viewer de um componente ParallelTransfer.
19
20
5 CONCLUSÃO
Com o projeto podemos concluir que é viável desenvolver uma rede neural em uma FPGA. Aplicamos uma rede consideravelmente simples, mas com bastante entradas, e analisamos o seu comportamento para as entradas de maior interesse. A rede na FPGA se comportou de modo esperado, acertando a resposta para os dados treinados e inclusive para alguns com introdução de pequenos erros. Assim percebemos que é uma boa solução para certos problemas, utilizar uma rede neural não supervisionada treinada em algum outro software para a obtenção dos pesos sinápticos combinada com a FPGA para executar a rede no modo a frente. Assim a rede consegue executar os seus vários cálculos com um processamento consideravelmente rápido, pois o mesmo está aplicado em um hardware especifico. Todo o projeto foi um bom estudo inicial sobre esse assunto que pode ser estudado mais a fundo em outros projetos, como a aplicação de outros problemas e outros tipos de redes, como a Multicamadas.
21
REFERÊNCIAS
BERG, Alexandre Cruz; MULLER, Daniel Nehme. Reconhecimento de Caracteres
Usando Redes Neurais . Porto Alegre, julho de 1993.
RIPLEY, B. D. Pattern Recognit ion and Neural Networ ks . University of Oxford, 1996.
A obtenção de texturas na síntese de imagens realísticas num ambiente limitado. Disponível em: http://www.lume.ufrgs.br/handle/10183/24181. Acesso em: 05/07/16.
HAYKIN, Simon S. Redes neurais: Princípios e prática . Trad. Paulo Martins Engel. 2ed. Porto Alegre. Bookman, 2001.
KOVÁCS, Zsolt L. Redes neurais artificiais: Fundamentos e Aplicações . 4ed. São Paulo, Editora Livraria da Física, 2002.
