treinamento de redes neurais com arquitetura multilayer

UNIVERSIDADE FEDERAL DE SANTA CATARINACENTRO TECNOLÓGICO

DEPARTAMENTO DE ENGENHARIA ELÉTRICA E ELETRÔNICA

Treinamento de Redes Neurais comArquitetura Multilayer Perceptron em

FPGA.

Trabalho de Conclusão de Curso apresentado ao Departamento deEngenharia Elétrica e Eletrônica da Universidade Federal de Santa

Catarina como requisito parcial para obtenção do grau de bacharel noCurso de Engenharia Elétrica.

Henrique Alfredo de SouzaOrientador: Eduardo Luiz Ortiz BatistaCo-orientador: Walter Antônio Gontijo

Florianópolis, 25 de julho de 2019.

HENRIQUE ALFREDO DE SOUZA

TREINAMENTO DE REDES NEURAISCOM ARQUITETURA MULTILAYER

PERCEPTRON EM FPGA.Trabalho de Conclusão de Cursoapresentado ao Departamento deEngenharia Elétrica e Eletrônica daUniversidade Federal de Santa Ca-tarina como requisito parcial paraobtenção do grau de bacharel noCurso de Engenharia Elétrica.Orientador: Eduardo Luiz OrtizBatista.Co-Orientador: Walter AntônioGontijo

FLORIANÓPOLIS2019

Ficha de identificação da obra elaborada pelo autor, através do Programa de Geração Automática da Biblioteca Universitária da UFSC.

Souza, Henrique Alfredo de Treinamento de redes neurais com arquitetura multilayerperceptron em FPGA / Henrique Alfredo de Souza ;orientador, Eduardo Luiz Ortiz Batista, coorientador,Walter Antônio Gontijo, 2019. 105 p.

Trabalho de Conclusão de Curso (graduação) -Universidade Federal de Santa Catarina, Centro Tecnológico,Graduação em Engenharia Elétrica, Florianópolis, 2019.

Inclui referências.

1. Engenharia Elétrica. 2. Redes Neurais. 3. FPGA. 4.Multilayer perceptron. 5. Aprendizado de máquina. I.Batista, Eduardo Luiz Ortiz. II. Gontijo, Walter Antônio.III. Universidade Federal de Santa Catarina. Graduação emEngenharia Elétrica. IV. Título.

Henrique Alfredo de Souza

Treinamento de Redes Neurais com Arquitetura MultilayerPerceptron em FPGA.

Este Trabalho foi julgado adequado como parte dos requisitos paraobtenção do Título de Bacharel em Engenharia Elétrica e aprovado, em sua

forma final, pela Banca Examinadora.

Florianópolis, 22 de julho de 2019.

A meus pais

Agradecimentos

Agradeço a todos que me auxiliaram na trajetória da UFSC, emespecial minha família e amigos.

Agradeço ao pessoal do LINSE pelos anos de aprendizado propor-cionados. Agradeço ao meu orientador Prof. Eduardo Batista e meuco-orientador Prof. Walter Gontijo pelo auxílio na confecção desse tra-balho e todo o suporte prestado.

Por fim, agradeço a todos que me incentivaram a continuar quandoquis desistir.

RESUMO

Este trabalho de conclusão de curso apresenta uma implementa-ção em Field Programmable Gate Arrays (FPGA) de um sistema res-ponsável pelo treinamento on chip de redes neurais com arquiteturaMultilayer Perceptron (MLP). O treinamento utilizado é o Mini-BatchStochastic Gradient Descent (MBSGD) com aceleração de convergên-cia por momento. O estudo das redes e do treinamento foi realizadoinicialmente em Python com auxílio da biblioteca de aprendizado demáquina Scikit-learn. Posteriormente em MatLab gerou-se as rotinasresponsáveis pela implementação do treinamento com uso de aritméticade ponto fixo de modo a facilitar a tradução para uma Hardware Des-cription Language (HDL). Na sequência implementou-se o treinamentona HDL Verilog considerando uma rede com topologia fixa, função deativação Rectified Linear Unit (ReLU) e função custo Mean SquaredError (MSE). Os resultados obtidos com Python são comparados comos de MatLab verificando congruência, não podendo entretanto seremiguais devido à perda inerente da quantização dos cálculos com pontofixo. Posteriormente o sistema implementado em Verilog é simuladono software ModelSim e os resultados comparados com os de MatLabcujos valores devem ser similares, validando assim o trabalho realizado.

Palavras-chave: FPGA. Redes Neurais. Multilayer Perceptron.Treinamento on chip. Stocasthic Gradient Descent. ReLU. Python.MatLab. Verilog. Scikit-learn.

ABSTRACT

This course conclusion paper presents an implementation on anFPGA of a system responsible for the on chip training of neural networkswith MultiLayer Perceptron architecture. The adopted method for trai-ning is the Mini Batch Stochastic Gradient Descent acelerating conver-gence with momentum. The study of the networks and the trainingmethods was carried out initially in Python with the aid of the machinelearning library Scikit-learn. Subsequently in MatLab the routines res-ponsible for the training were generated with fixed-point arithmetic inorder to facilitate the translation to a Hardware Description Language(HDL). In the next stage, the training on the HDL Verilog was imple-mented considering a fixed topology, activation function Rectified Li-near Unit (ReLU) and cost function as the Mean Squared Error (MSE).The results obtained with Python are compared with those of MatLabchecking for congruence as the results can’t be equals due to inerentloss from quantization using fixed-point calculations. Afterwards thesystem implemented in Verilog is simulated in the ModelSim softwareand the results compared to those of MatLab whose values must besimilar, thus validating the work done.

Keywords: FPGA. Neural Networks. Multilayer Perceptron. Onchip training. Stocasthic Gradient Descent. ReLU. Python. MatLab.Verilog. Scikit-learn.

Lista de Figuras

2.1 Neurônio Perceptron de Rossenblat. . . . . . . . . . . . . 92.2 Estrutura geral de uma rede neural com arquitetura MLP

com uma camada de entrada, uma hidden e uma de saída. 102.3 Gráfico da função Heaviside, função de ativação original do

perceptron. . . . . . . . . . . . . . . . . . . . . . . . . . . 112.4 Gráfico da sigmóide e sua derivada. . . . . . . . . . . . . . 122.5 Gráfico da tangente hiperbólica e sua derivada. . . . . . . 122.6 Gráfico da ReLU e sua derivada. . . . . . . . . . . . . . . 132.7 Fluxograma da resolução de um determinado problema com

aprendizado supervisionado através do treinamento de umarede neural . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2.8 Curvas de níveis de uma superfície de perda tridimensionalcom dados não normalizados, comportamento elíptico. . . 17

2.9 Curvas de níveis de uma superfície de perda tridimensionalcom dados normalizados, comportamento circular. . . . . . 18

2.10 Superfície de uma função custo fictícia em função de doisparâmetros. A direção de minimização é no sentido domínimo da paraboloide. . . . . . . . . . . . . . . . . . . . 19

LISTA DE FIGURAS

2.11 Paro o ponto de mínimo local 1 o erro da rede é elevadonão apresentando bons resultados. O ponto 2 representao mínimo global, ponto ideal para a otimização. Caso aotimização pare no mínimo local representado por 3 os re-sultados serão satisfatórios pois o erro nesse ponto é reduzido. 20

2.12 Rede exemplo considerada para a explicação do algoritmobackpropagation. . . . . . . . . . . . . . . . . . . . . . . 21

2.13 Fluxograma e cálculos do algoritmo backpropagation. . . . 252.14 Fluxograma das operações do método de otimização de

parâmetros SGD. . . . . . . . . . . . . . . . . . . . . . . 272.15 Fluxograma das operações do método de otimização de

parâmetros SGD. . . . . . . . . . . . . . . . . . . . . . . 282.16 Fluxograma das operações do método de otimização de

parâmetros MBSGD. . . . . . . . . . . . . . . . . . . . . 302.17 Trajetórias da otimização dos parâmetros dos métodos SGD

(roxo), BGD (azul) e MBSGD (verde). . . . . . . . . . . . 312.18 Topologia de um Linear Feedback Shift Register de 5 bits

com taps nos bits 1 e 4. . . . . . . . . . . . . . . . . . . . 33

3.1 Estrutura do desenvolvimento do presente projeto. . . . . . 383.2 Topologia da rede implementada em Verilog com duas ca-

madas (a camada de entrada não é considerada). . . . . . 393.3 Dados do dataset para classificação binária criado pelo mé-

todo make_classification da biblioteca scikit-learn. . . 423.4 Dados do dataset para classificação multi-classe criado pelo

método make_classification da biblioteca scikit-learn. 433.5 Hiperplanos criados pela rede 2:5:1 separando as 2 classes

do primeiro dataset. . . . . . . . . . . . . . . . . . . . . . 443.6 Hiperplanos criados pela rede 2:5:1 separando as 4 classes

do segundo dataset. . . . . . . . . . . . . . . . . . . . . . 453.7 Fluxograma do treinamento em MatLab. . . . . . . . . . . 473.8 Código responsável pela inicialização dos pesos. Os pe-

sos são inicializados através da função rand que cria umadistribuição uniforme entre 0 e 1, escalonados para o in-tervalo [-lim, lim] representado no código pela variávelinit_bound e convertidos para a representação Qm.n

multiplicando por 2n. . . . . . . . . . . . . . . . . . . . . 48

LISTA DE FIGURAS

3.9 Código responsável pelo cálculo da função custo a cadaépoca. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

3.10 Código que realiza o processamento da sub-função perceptron 49

3.11 Processo de embaralhamento da entrada. O valor do seedtorna-se o valor final do vetor e o primeiro valor após seedse torna o primeiro. . . . . . . . . . . . . . . . . . . . . . 50

3.12 Código do algoritmo backpropagation realizado em MatLab. 52

3.13 Código utilizado para atualizar os pesos em MatLab con-vertendo os hiper parâmetros para ponto fixo utilizando 2NB . 52

3.14 Organização da word utilizada para representar os dados eas operações internas. . . . . . . . . . . . . . . . . . . . . 54

3.15 Diagrama de blocos do treinador de redes MLP implemen-tado em FPGA. . . . . . . . . . . . . . . . . . . . . . . . 55

3.16 Organização dos dados dentro da memória do conjunto dedados, como a resposta esperada é apenas 1 ou 0 ela écolocada como MSB das words. . . . . . . . . . . . . . . 56

3.17 Diagrama de blocos do treinador. . . . . . . . . . . . . . . 57

3.18 FSM do sistema treinador. . . . . . . . . . . . . . . . . . 58

3.19 Parte do código de Verilog que implementa o LFSR. . . . 59

3.20 Finite State Machine with Data responsável pelo controledo módulo feedforward embutida nos blocos Calcula perdae Calcula gradiente. . . . . . . . . . . . . . . . . . . . . 61

3.21 Código responsável pela execução do neurônio perceptroncom função de ativação ReLU. . . . . . . . . . . . . . . . 62

3.22 Datapath do sub-módulo Perceptron responsável pelo pro-cessamento do módulo Feedforward. . . . . . . . . . . . . 63

3.23 Diagrama do datapath do módulo MSE do bloco Calculaperda. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

3.24 FSMD do bloco Calcula Gradiente que realiza o algoritmobackpropagation para gerar o gradiente da função custo emrelação aos parâmetros da rede. . . . . . . . . . . . . . . . 64

3.25 Circuito responsável pela atualização de parâmetros se-guindo a equação apresentada em 2.22 . . . . . . . . . . . 66

LISTA DE FIGURAS

3.26 FSM que controla o circuito responsável pela atualizaçãode parâmetros. Os sinais omegaDone e bDone representamflags dos contadores indicando que o contador de pesos(no caso de omegaDone) e o contador de bias (no caso debDone) atingiram os valores máximos. . . . . . . . . . . . 66

4.1 Curva da função custo por épocas gerado em Python paraa rede 2:5:1 com arquitetura MLP e hiper parâmetros η =0.05 e α = 0.9 com cada batch com 256 amostras. . . . . 68

4.2 Hiperplanos criados para separar as duas classes do dataset.Rede 2:5:1 com arquitetura MLP e hiper parâmetros η =0.05 e α = 0.9 com cada batch com 256 amostras. . . . . 69

4.3 Curva da função custo por épocas gerado em Python para arede 2:5:1 com arquitetura MLP e hiper parâmetros η = 0.5e α = 0.1 com cada batch com 1024 amostras. . . . . . . 70

4.4 Hiperplanos criados para separar as duas classes do dataset.Rede 2:5:1 com arquitetura MLP e hiper parâmetros η =0.5 e α = 0.1 com cada batch com 1024 amostras. . . . . 72

4.5 Curva da função custo produzida no programa em MatLabcom aritmética de ponto fixo para a configuração de hiperparâmetros η = 0.05 e α = 0.9 com tamanho de batch de256 amostras. . . . . . . . . . . . . . . . . . . . . . . . . 72

4.6 Curva da função custo produzida no programa em MatLabcom aritmética de ponto fixo para a configuração de hiperparâmetros η = 0.5 e α = 0.1 com tamanho de batch de1024 amostras. . . . . . . . . . . . . . . . . . . . . . . . 73

4.7 Comparação das funções custo de Python e MatLab comdiferentes precisões. O erro da resolução Q7.16 apesar deser o maior apresentado ainda assim é um valor pequeno eque não terá um consumo de hardware tão massivo quantoas outras representações. . . . . . . . . . . . . . . . . . . 73

4.8 Gráfico das funções custo produzidas no MatLab e no Mo-delSim para os hiper parâmetros η = 0.5 e α = 0.1 comcada batch com 1024 amostras. . . . . . . . . . . . . . . 74

Lista de Tabelas

2.1 Representação dos números 0,65, 1,27 e 3,42 como pontofixo nos formatos Q1.4, Q2.6 e Q3.8. . . . . . . . . . . . . 32

2.2 Tabela de resultados do LFSR de 5 bits com um seed inicialde valor unitário. . . . . . . . . . . . . . . . . . . . . . . . 34

4.1 Consumo de hardware gerado pelo simulation report doQuartus para o sistema treinador. . . . . . . . . . . . . . 71

4.2 Comparação entre as acurácias obtidas para os conjuntosde treinamento, teste e validação para as etapas do desen-volvimento. . . . . . . . . . . . . . . . . . . . . . . . . . 71

Sumário

1 Introdução 11.1 Objetivo principal . . . . . . . . . . . . . . . . . . . . . . 2

1.1.1 Objetivos específicos . . . . . . . . . . . . . . . . 21.2 Estrutura do trabalho . . . . . . . . . . . . . . . . . . . . 3

2 Fundamentação Teórica 52.1 Redes Neurais Artificiais . . . . . . . . . . . . . . . . . . . 5

2.1.1 História . . . . . . . . . . . . . . . . . . . . . . . 62.1.2 Perceptron . . . . . . . . . . . . . . . . . . . . . . 72.1.3 Multilayer Perceptron . . . . . . . . . . . . . . . . 82.1.4 Funções de ativação . . . . . . . . . . . . . . . . . 9

2.2 Treinamento de redes neurais . . . . . . . . . . . . . . . . 142.2.1 Aprendizado supervisionado . . . . . . . . . . . . . 142.2.2 Função custo . . . . . . . . . . . . . . . . . . . . 142.2.3 Datasets . . . . . . . . . . . . . . . . . . . . . . . 162.2.4 Treinamento com gradiente . . . . . . . . . . . . . 172.2.5 Algoritmo Backpropagation . . . . . . . . . . . . . 192.2.6 Gradiente Descendente Estocástico . . . . . . . . . 252.2.7 Gradiente Descendente . . . . . . . . . . . . . . . 262.2.8 Gradiente Descendente Estocástico em mini lotes . 272.2.9 Momento . . . . . . . . . . . . . . . . . . . . . . 29

SUMÁRIO

2.3 Redes neurais em Hardware . . . . . . . . . . . . . . . . . 292.3.1 FPGA . . . . . . . . . . . . . . . . . . . . . . . . 312.3.2 Ponto fixo . . . . . . . . . . . . . . . . . . . . . . 312.3.3 Linear Feedback Shift Register . . . . . . . . . . . 33

2.4 Ferramentas utilizadas . . . . . . . . . . . . . . . . . . . . 342.4.1 Python . . . . . . . . . . . . . . . . . . . . . . . . 342.4.2 MatLab . . . . . . . . . . . . . . . . . . . . . . . 342.4.3 Verilog . . . . . . . . . . . . . . . . . . . . . . . . 35

3 Desenvolvimento 373.1 Visão Geral . . . . . . . . . . . . . . . . . . . . . . . . . 383.2 Desenvolvimento em Python . . . . . . . . . . . . . . . . 40

3.2.1 Biblioteca Scikit-learn . . . . . . . . . . . . . . . . 403.2.2 Datasets . . . . . . . . . . . . . . . . . . . . . . . 413.2.3 Criação e treinamento das redes . . . . . . . . . . 42

3.3 Desenvolvimento em MatLab . . . . . . . . . . . . . . . . 433.3.1 Gerador de pesos aleatórios . . . . . . . . . . . . . 463.3.2 Calcula perda . . . . . . . . . . . . . . . . . . . . 463.3.3 Embaralha entrada . . . . . . . . . . . . . . . . . 493.3.4 Separação em batches . . . . . . . . . . . . . . . 503.3.5 Feedforward batch . . . . . . . . . . . . . . . . . . 513.3.6 Backpropagation . . . . . . . . . . . . . . . . . . 513.3.7 Otimização dos pesos . . . . . . . . . . . . . . . . 513.3.8 Cálculo da acurácia . . . . . . . . . . . . . . . . . 513.3.9 Validação do desenvolvimento em MatLab . . . . . 53

3.4 Implementação em FPGA utilizando Verilog . . . . . . . . 533.4.1 Escolha da resolução . . . . . . . . . . . . . . . . 533.4.2 Implementação do sistema treinador . . . . . . . . 533.4.3 Treinador . . . . . . . . . . . . . . . . . . . . . . 553.4.4 Bloco de controle do Treinador . . . . . . . . . . . 563.4.5 Gerador de pesos aleatórios . . . . . . . . . . . . . 573.4.6 Embaralha entrada . . . . . . . . . . . . . . . . . 593.4.7 Calcula perda . . . . . . . . . . . . . . . . . . . . 593.4.8 Separa em Batch . . . . . . . . . . . . . . . . . . 613.4.9 Calcula gradiente . . . . . . . . . . . . . . . . . . 623.4.10 Otimiza pesos . . . . . . . . . . . . . . . . . . . . 65

SUMÁRIO

4 Resultados 674.1 Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . 684.2 MatLab . . . . . . . . . . . . . . . . . . . . . . . . . . . 684.3 Verilog . . . . . . . . . . . . . . . . . . . . . . . . . . . . 694.4 Conclusões acerca dos resultados . . . . . . . . . . . . . . 70

5 Conclusão 75

Referências bibliográficas 77

CAPÍTULO 1

Introdução

Desde a última década, aplicações com redes neurais e aprendizadode máquina despertaram grande interesse nos meios acadêmico e in-dustrial. Grande parte desse interesse deve-se ao desempenho elevadoobtido pelas redes neurais com aprendizado supervisionado nas tarefasde classificação e regressão [1], tais como na classificação de imagenspara carros autônomos [2], reconhecimento de fala para assistentes vir-tuais [3], predição de preço de ações [4] e detecção de falhas em linhasde produção [5].

Uma das tarefas primordiais no desenvolvimento de aplicações comredes neurais é a etapa de treinamento na qual a rede é adaptada paraum problema específico através de dados já disponíveis. Devido aoelevado custo computacional requerido nessa etapa, é frequente o usode GPUs (Graphics Processing Unit) em virtude do massivo proces-samento paralelo possibilitado por tais unidades, o qual leva a umaaceleração significativa no processo de treinamento [6]. Em particular,no caso de aplicações que utilizam redes neurais diretamente no hard-ware (HNNs - Hardware Neural Networks), como as encontradas emmuitos sistemas embarcados, o treinamento costuma ser realizado offchip em estações remotas que contam com o auxílio de GPUs.

1

2 CAPÍTULO 1. INTRODUÇÃO

Para sistemas embarcados que necessitam periodicamente de umaatualização dos pesos da rede, realizar o treinamento remotamente oulocalmente usando GPUs torna-se um processo difícil e extenuante emtermos de consumo de potência e/ou tempo. Nesse contexto, o uso deFPGAs (Field Programmable Gate Arrays) para realizar o treinamentoon chip de tais sistemas traz inúmeras vantagens como o menor gastoenergético e velocidade na adaptação da rede. Assim, o foco do presentetrabalho é a criação de um sistema capaz de realizar o treinamentode uma rede neural no FPGA. Tal sistema deverá receber os dados detreinamento (conjunto de treinamento e respostas esperadas) e adaptaros pesos de uma rede com arquitetura MLP (Multilayer Perceptron).

1.1 Objetivo principal

Desenvolvimento de um sistema que, a partir das especificações,realize o treinamento supervisionado da rede MLP utilizando FPGA.

1.1.1 Objetivos específicos

• Analisar algoritmos para treinamento de redes neurais.

• Sintetizar e treinar ANNs (Artificial Neural Networks) com ar-quitetura MLP em uma linguagem de programação de alto nível(Python).

• Definir datasets para validar e treinar as redes.

• Implementar as redes e as rotinas de treinamento realizadas emPython utilizando aritmética de ponto fixo em MatLab.

• Comparar os resultados obtidos em ponto fixo com os obtidos emPython.

• Implementar, baseado nas redes e treinamento com ponto fixo emMatLab, o sistema que realiza a síntese e treinamento de HNNscom linguagem de descrição de hardware Verilog.

• Comparar os resultados obtidos com as HNNs em Verilog com osdas ANNs em MatLab.

1.2. ESTRUTURA DO TRABALHO 3

1.2 Estrutura do trabalho

O presente trabalho é organizado como descrito a seguir. O Capí-tulo 2 aborda a fundamentação teórica necessária para o desenvolvi-mento do trabalho. O Capítulo 3 discorre sobre o desenvolvimento dotrabalho destacando as implementações e técnicas utilizadas. No Capí-tulo 4 apresenta-se os experimentos realizados e os resultados obtidos.Finalmente, no Capítulo 5 são apresentadas as considerações finais.

CAPÍTULO 2

Fundamentação Teórica

A fundamentação teórica necessária para o desenvolvimento do pre-sente trabalho é abordada neste capítulo. A primeira parte discorre so-bre conceitos gerais de redes neurais artificiais apresentando um breveretrospecto histórico, discorrendo sobre o neurônio perceptron, redesMLP e funções de ativação. Em seguida, são abordados alguns temas nocontexto do treinamento de redes neurais, tais como aprendizado super-visionado, função custo, datasets, algoritmo backpropagation e métodosde atualização baseados no gradiente. Na sequência, comenta-se sobreredes neurais em hardware falando sobre uso de FPGAs, aritméticade ponto fixo e Linear Feedback Shift Registers (LFSR). Finalmente,são apresentadas as ferramentas utilizadas para o desenvolvimento evalidação deste trabalho.

2.1 Redes Neurais Artificiais

Em 1950, Alan Turing propôs em [7] um jogo de imitação para res-ponder o questionamento “Máquinas podem pensar?”. No jogo original,3 pessoas (um homem, uma mulher e um interrogador) ficam separadosem salas distintas e, através de questionamentos levantados pelo inter-

5

6 CAPÍTULO 2. FUNDAMENTAÇÃO TEÓRICA

rogador, este deverá descobrir quem é o homem e quem é a mulher.Um dos jogadores (no original o homem) tem o objetivo de fazer o in-terrogador errar enquanto o outro jogador tem o objetivo de auxiliá-lo.A comunicação entre os participantes é feita através de papel datilogra-fado ou impresso, de modo que o tom de voz não possa influenciar naresposta, e o interrogador tem liberdade para fazer qualquer pergunta.

Turing propôs que uma máquina, limitada a um computador digi-tal, fizesse o papel do homem ou da mulher no jogo. Essa máquina,sujeita as regras do jogo, poderia ser considerada inteligente quando ointerrogador assumisse que era humana. Para algum leigo pode pareceróbvia a ideia da máquina que pode ganhar esse jogo: basta programaras respostas para todas as questões de modo que sejam similares a deum homem/mulher jogando. Essa estratégia, apesar de estar correta,é incapaz de ser implementada. O conjunto de questões que o interro-gador poderia fazer é infinito, sem levar em consideração o tempo paraprogramar, a memória necessária para o armazenamento seria demasi-ada grande. Uma melhor estratégia para a máquina em questão seria ade tentar reproduzir as respostas de um homem/mulher jogando. Nessecontexto entram as redes neurais.

Uma definição de redes neurais artificiais é fornecida em [8] por Wi-drow e Lehr: modelos computacionais e/ou matemáticos baseados nasconexões sinápticas biológicas cujo formato possibilita a adaptação dospesos entre neurônios ajustando o modelo para resolução de tarefas.Essas tarefas em geral, são realizadas arduamente por máquinas de-vido à necessidade de processamento cognitivo e perceptivo. Visandomelhorar o desempenho nessas situações, as redes neurais, em contrastecom as máquinas sequenciais de Von Neumann, são implementadas deforma a processar diversas entradas simultaneamente. Para tal diver-sos elementos computacionais interconectados com pesos variáveis sãoconectados em paralelo [9].

2.1.1 História

Em 1958, Rosenblatt, baseado no modelo computacional apresen-tado por McCulloch e Pitts [10] e na aprendizagem proposta por Hebb[11], criou o perceptron, um modelo matemático que reproduzia o com-portamento de neurônios biológicos [12]. Este modelo foi implementadocomo algoritmo pela primeira vez no IBM 704 [13] e com hardware dedi-

2.1. REDES NEURAIS ARTIFICIAIS 7

cado (HNN) no Mark I Perceptron, onde se conseguia classificar formassimples usando como entrada imagens de tamanho 20x20 [14].

O trabalho de Rosenblatt alavancou a “época dourada” para ocampo das redes neurais e inteligência artificial, inspirando vários tra-balhos dentre eles o de Widrow [15] que criou o neurônio ADALINE(Adaptative Linear Neuron) , o qual possui significativa semelhança es-trutural com o perceptron de Rosenblatt, mas envolve um processo detreinamento mais efetivo e robusto [15].

Em 1969, Minsky e Papert publicaram uma rigorosa análise sobre aslimitações que o Perceptron apresentava [16], como o fato de não con-seguir implementar a simples função booleana XOR, o que ocasionouuma queda nas publicações e financiamentos no campo.

Apenas na década de 80 que o interesse pela área voltou a crescer,em particular com o trabalho de Werbos em 1982 [17] (escrito em 1974mas publicado apenas em 1982 devido ao baixo incentivo no campo naépoca), o qual detalha o algoritmo Backpropagation, e de Rumelhart etal. em 1986 [18], no qual são detalhadas redes com mais de uma camadae seu treinamento com o algoritmo de Werbos. Nesse mesmo artigo éapresentado a solução das limitações citadas por Minky e Papert parao uso de Multilayer Perceptrons. Essas publicações voltaram a atençãonovamente para o campo das redes neurais.

Entre a publicação desses artigos e os dias atuais, o campo de redesneurais cresceu drasticamente com o surgimento de redes neurais pro-fundas (Deep Neural Networks), redes com mais de uma camada oculta,e das técnicas de aprendizado profundo (Deep Learning), baseadas emnovos tipos de redes como as convolucionais (CNN - Convolutional Neu-ral Networks) e recorrentes (RNN - Convolutional Neural Networks).Outro fator importante para o crescimento do campo das redes neuraise inteligencia artificial tem sido a evolução do poder de computação,tanto dos computadores de propósito geral, quanto dos hardwares de-dicados como os FPGAs. As aplicações em hardware dedicado têmcrescido paralelamente, sendo uma análise das ultimas décadas de re-des neurais em hardware apresentada em [19].

2.1.2 Perceptron

Em 1958 o psicólogo americano Frank Rosenblatt foi o responsávelpela criação do Perceptron: uma aproximação de um neurônio biológico


a partir da reavaliação de algumas restrições do modelo neuronal deMcCulloch e Pitts. As restrições removidas envolviam os valores dospesos sinápticos (posteriormente restritos ao valor unitário) que agorapoderiam assumir valores entre -1 e 1 possibilitando alterar a influênciadas entradas [12].

A Equação (2.1) exibe a saída produzida pelo modelo de McCulloche Pitts [10] é válido ressaltar que o valor do peso sináptico que multiplicaa entrada xk é sempre unitário. A partir da habilitação i o neurônio iráativar (saída = 1) caso a soma das entradas seja maior que um limiarde ativação Θ.

a(x) =

1 :N∑k=1

xk > Θ ∧ i = 1

0 : caso contrário(2.1)

Com as modificações propostas por Rossenblatt a equação da saídaproduzida comporta-se como definido em (2.2) [12], os pesos são agoradefinidos no vetor ~ω e o inverso do valor que antes representava o li-miar necessário para ativação do neurônio é utilizado como peso con-siderando uma entrada unitária. Esse valor é comumente denominadode bias na literatura. A habilitação i do neurônio também foi removidano perceptron de Rossenblatt.

a(x) =

1 :N∑k=1

ωk · xk + b > 0

0 : caso contrário(2.2)

A Figura 2.1 ilustra a estrutura do neurônio perceptron. O modeloé composto por N+1 entradas onde o vetor de entrada ~x tem tamanhoN , porém existe uma entrada extra com valor unitário e o valor do biasno lugar do peso. O somatório acumula as multiplicações entre pesos eentradas gerando na saída zk, o peso ponderado do neurônio. O blocoseguinte corresponde a função de ativação, responsável por produzir asaída do neurônio.

2.1.3 Multilayer Perceptron

A organização de vários neurônios perceptron em camadas distintasficou conhecida na literatura como a arquitetura de redes Multilayer


Figura 2.1: Neurônio Perceptron de Rossenblat.

Fonte: Do Autor.

Perceptron (MLP) [18]. O uso de redes de neurônios com mais de umacamada visava resolver os problemas encontrados na classificação dedados não linearmente separáveis como a emulação de uma porta ouexclusiva (XOR) apresentado em [16].

A figura 2.2 ilustra a estrutura de uma rede MLP. Redes com essaarquitetura aliada ao treinamento com o algoritmo backpropagation sãocapazes de classificar corretamente dados não linearmente separáveis[18].

A equação das ativações e pesos ponderados de uma rede MLP é aseguinte [20].

zlj =N∑k=1

(ωljk · al−1

k

)+ blj

alj = ϕ(zlj) (2.3)

onde N é o número de entradas do neurônio, ωljk representa o pesovindo do neurônio k da camada l − 1 para o neurônio j da camadal, e alk, blj e zlk correspondem respectivamente a ativação, bias e pesoponderado do neurônio k da camada l.

2.1.4 Funções de ativação

A função de ativação original do perceptron era a função de Hea-viside [12] cujo comportamento é ilustrado na Figura 2.3. A derivadadessa função tem valor nulo para todo x 6= 0 e não é definida para


Figura 2.2: Estrutura geral de uma rede neural com arquitetura MLP comuma camada de entrada, uma hidden e uma de saída.

Fonte: Do Autor.

x = 0 o que cria dificuldades para o processo de treinamento [18]. Como advento do algoritmo de treinamento backpropagation e métodos deatualizações de pesos através do gradiente, surgia a necessidade da uti-lização de funções de ativação com derivadas não nulas em todos ospontos [18]. Nesse contexto novas funções de ativação não lineares fo-ram surgindo como a sigmoide, tangente hiperbólica e a Rectified LinearUnit (ReLU). Essas funções de ativação são descritas a seguir.

2.1.4.1 Sigmóide

A equação que rege a função sigmóide é a seguinte [20]:

σ(x) = 11 + e−x

(2.4)

Essa função foi por muito tempo uma das principais ativações uti-lizadas em redes neurais. Em relação a função original (Heaviside), asigmóide traz trazia vantagens, como a derivada não nula em todo seu


Figura 2.3: Gráfico da função Heaviside, função de ativação original do per-ceptron.

Fonte: Do Autor.

domínio, o que possibilita o aprendizado com o algoritmo backpropaga-tion [21].

A Figura 2.4 ilustra a função sigmóide e sua derivada. Uma dasgrandes desvantagens dessa função, além do custo computacional, estáno fato que, caso a magnitude da entrada da sigmóide seja muitogrande, a derivada se aproxima cada vez mais de zero. Isso leva aoproblema do vanishing gradient [20] no contexto do algoritmo backpro-pagation, o que dificulta o treinamento das camadas da rede neural. otreinamento para as demais camadas da rede.

2.1.4.2 Tangente hiperbólica

Uma outra desvantagem que a função sigmóide acarreta é o fatode não estar centrada em zero. Essa característica não é desejávelpois pode introduzir dinâmicas indesejáveis na busca do mínimo dogradiente [22]. A função de ativação tangente hiperbólica visa eliminaressa desvantagem mantendo as demais características da sigmóide.

A equação que rege essa função é apresentada em (2.5). A figura2.5 ilustra o gráfico da tangente hiperbólica e sua derivada.

σ(x) = tanh x = ex − e−x

ex + e−x(2.5)


Figura 2.4: Gráfico da sigmóide e sua derivada.

Fonte: Do Autor.

Figura 2.5: Gráfico da tangente hiperbólica e sua derivada.

Fonte: Do Autor.

2.1.4.3 Rectified Linear Unit - ReLu

A função de ativação ReLU resolve o problema do vanishing gradientnão estabelecendo um limite para a saída positiva. A equação quedescreve a função é a seguinte:

A ReLU tornou-se muito popular devido ao pouco esforço compu-


tacional necessário para sua implementação.

σ(x) = max(0, x) (2.6)

Outras vantagens da função ReLU são a possibilidade de utilizaro algoritmo backpropagation e a aceleração do treinamento com o mé-todo do gradiente descendente estocástico [23]. A Figura 2.6 ilustra ocomportamento do gráfico da função de ativação ReLU e sua derivada.

Figura 2.6: Gráfico da ReLU e sua derivada.

Fonte: Do Autor.

A função de ativação ReLU resolve o problema do vanishing gradientmas cria outro: dying ReLU. Esse problema ocorre numa atualizaçãodos pesos ou bias que "trave"a saída do neurônio em zero, como aatualização utiliza o valor do gradiente da saída, cujo valor agora é nulo,os pesos e bias permanecem nessa configuração e o neurônio não irá maisativar [22]. A seleção de uma taxa de aprendizagem apropriada podeeventualmente solucionar esse problema. Rotinas de inicialização deparâmetros e variações da ReLU (como a Leaky ou Parametric ReLU)também são utilizadas no intuito de mitigar o problema de dying ReLU[24].


2.2 Treinamento de redes neurais

2.2.1 Aprendizado supervisionado

O aprendizado supervisionado é um modelo de aprendizado de má-quina que adapta um sistema para a resolução de tarefas de classificaçãoou regressão através de dados rotulados [25].

Para uma rede neural, dado um conjunto de dados ( ~xk, ~yk) onde~xk é um vetor do espaço vetorial X contendo os dados de entrada daamostra k e ~yk é o vetor de saída do espaço vetorial Y da amostra krepresentando uma classe (em problemas de classificação) ou um valorcontínuo (em problemas de regressão), a função do aprendizado super-visionado é a adaptação dos parâmetros da rede (pesos e bias) de modoa mapear uma função g : X → Y tal que para novos dados ~x a saídaproduzida ~y corresponda a uma classificação ou predição correta.

Um fluxograma das etapas do aprendizado supervisionado é apre-sentado na figura 2.7. O bloco condicional ao final do treinamentoverifica se os resultados são adequados utilizando diversas métricas deavaliação, uma delas e a utilizada nesse trabalho é a função custo.

2.2.2 Função custo

A função custo é uma medida do erro do modelo em estimar acorreta relação entre os dados de entrada e saída [20]. Uma das funçõescusto mais comuns, e a utilizada nesse trabalho, é a Mean SquaredError (MSE) cuja equação é apresentada em (2.7) [20]. Para calcularessa função, o vetor de valores da saída desejada (ground truth) paraa camada de saída é subtraído do vetor de valores da saída estimadapela rede para um dado vetor de entrada.

Essa diferença é então elevada ao quadrado e somada com o mesmoprocesso sendo aplicado a N vetores de entrada. Ao final do somatórioo erro é dividido pelo número de entradas (N).

fcusto(y, y) = 1N

N∑i=1

(yi − yi)2 (2.7)

onde yi e yi representam respectivamente o vetor de saídas reais eestimadas para a entrada i e N é o número de entradas.

Para uma rede ideal, o valor da função custo é nulo pois não há

2.2. TREINAMENTO DE REDES NEURAIS 15

Figura 2.7: Fluxograma da resolução de um determinado problema comaprendizado supervisionado através do treinamento de uma rede neural

Fonte: Adaptado de [25].

discrepâncias entre o valor esperado e o valor obtido. No intuito dese buscar uma rede com o menor erro possível na saída, técnicas deaprendizagem visam minimizar a função custo.

Os parâmetros passíveis de alteração durante o treinamento na redesão os pesos e bias. Expandindo-se (2.7) é possível verificar a relação


entre a função custo e os pesos e bias da camada de saída. Comoresultado tem-se

1N

N∑i=1

(yi −

(∑k

ωL−1ik · aL−1

k + bL−1i

))2

Da mesma maneira expande-se o valor de aL−1k para relacionar a

função custo com os parâmetros de uma camada anterior, o que resultaem

1N

N∑i=1

(yi −

(∑k

ωL−1ik ·

(∑k

ωL−2ik · aL−2

k + bL−2i

)+ bL−1

i

))2

E assim sucessivamente até atingir a camada inicial (índice 0).

2.2.3 Datasets

O conjunto de dados contendo as amostras ( ~xk, ~yk) do problema édenominado na literatura como database. Após o pré processamento erefinamento dos dados o conjunto necessário para a aprendizagem darede recebe o nome de dataset. Como definido em [26], esse conjuntoé tradicionalmente separado em três partes: conjunto de treinamento,conjunto de teste e conjunto de validação. O de treinamento é uti-lizado para atualizar os pesos e bias da rede durante o processo detreinamento. O conjunto de teste é usado para verificar se o modelonão sofre overfitting, no qual a rede se adequa perfeitamente aos dadosdo conjunto de treinamento mas com um erro grotesco para dados no-vos. O conjunto de validação é utilizado após a geração do modelo darede neural para validar e adaptar os hiper parâmetros. Cada processa-mento do conjunto de treinamento inteiro do método de aprendizagemutilizado corresponde a uma época.

Uma técnica utilizada para auxiliar no treinamento de redes neu-rais é a normalização de dataset [26]. Essas técnicas visam suavizar asuperfície da função custo. Suponha uma superfície de perda tridimen-sional com as curvas de níveis ilustradas na Figura 2.8. Como podeser visto em tal figura, essas curvas seguem uma ordem elíptica comexcentricidade alta. Após aplicada a normalização as curvas de nível


tomam formatos circulares como se observa ena Figura 2.9 o que auxiliana busca do mínimo global da função custo [27].

Figura 2.8: Curvas de níveis de uma superfície de perda tridimensional comdados não normalizados, comportamento elíptico.

Fonte: Do Autor.

2.2.4 Treinamento com gradiente

O gradiente é uma ferramenta matemática que permite visualizara direção de maior crescimento de uma função em relação ao sentidode acréscimo de suas variáveis. Na otimização de funções não-lineares,utilizam-se técnicas baseadas no gradiente para minimizá-las de modoa encontrar as raízes e/ou mínimos globais. Para o campo de treina-mento de redes neurais pode-se utilizar a função custo como a funçãoanalisada e as variáveis como os pesos e bias. As técnicas de apren-dizagem com gradiente utilizam a direção negativa do gradiente paraadaptar os pesos e bias da rede minimizando o erro da saída [28]. Ge-ometricamente a função custo envolvida no treinamento de uma redeneural com múltiplas camadas não é convexa, possuindo vários mínimos


Figura 2.9: Curvas de níveis de uma superfície de perda tridimensional comdados normalizados, comportamento circular.

Fonte: Do Autor.

locais [28]. A otimização na direção contrária a do gradiente percorre asuperfície da perda no sentido do mínimo global como ilustra a Figura2.10 que representa uma superfície de perda fictícia para uma rede deúnica camada com dois parâmetros.

Diversos fatores influenciam a busca pelo mínimo global como ataxa de aprendizagem, o método de treinamento utilizado e o formatodo dataset. A função custo pode ainda conter pontos de mínimo locais,influenciando o método de treinamento a convergir para esse valoresao invés do mínimo global, esse processo é ilustrado na Figura 2.11.A necessidade de obtenção do gradiente de cada parâmetro é resolvidapelo algoritmo backpropagation.

A fórmula para atualização dos parâmetros da rede é apresentadaem (2.8). O valor do gradiente, fornecido pelo algoritmo backpropaga-tion, é multiplicado por um fator η denominado taxa de aprendizageme subtraído do valor antigo do parâmetro.


Figura 2.10: Superfície de uma função custo fictícia em função de dois parâ-metros. A direção de minimização é no sentido do mínimo da paraboloide.

Fonte: Do Autor.

ωlijk+1 = ωlij

k − η · ∂E

∂ωlijk

blik+1 = bli

k − η · ∂E∂bli

k

(2.8)

2.2.5 Algoritmo Backpropagation

O algoritmo backpropagation tem como objetivo a obtenção das de-rivadas da função custo em relação aos diferentes pesos e bias das dife-rentes camadas da rede. É uma maneira rápida e eficaz de realizar essecálculo possibilitando o treinamento de redes neurais de mais de umacamada. Rumelhart et al. em [18] exibiu que o backpropagation excediaa velocidade de treinamento em relação as aproximações passadas.

O algoritmo pode ser dividido em duas partes: a etapa forward ea backward. Na primeira etapa as entradas são processadas pela redeobtendo-se as saídas estimadas para essas entradas. Na sequência o


Figura 2.11: Paro o ponto de mínimo local 1 o erro da rede é elevado nãoapresentando bons resultados. O ponto 2 representa o mínimo global, pontoideal para a otimização. Caso a otimização pare no mínimo local representadopor 3 os resultados serão satisfatórios pois o erro nesse ponto é reduzido.

Fonte: Do Autor.

erro da saída é retro-propagado obtendo-se através dele e da regra daderivação em cadeia os gradientes de cada peso e bias.

Para ilustrar o funcionamento do backpropagation e da matemáticapor trás consideremos uma rede 1:3:2 com uma camada oculta comtrês neurônios como na Figura 2.12 utilizando a função custo MSE. Oobjetivo aqui é definir como através do valor do erro total da saída, oalgoritmo externa o valor dos gradientes dos pesos e bias da rede, ouseja, deseja-se encontrar ∂E

∂ω111, ∂E∂ω1

12, ..., ∂E

∂ω223

e ∂E∂b1

0, ∂E∂b1

1, ..., ∂E

∂b21onde

E representa o erro total da rede, ωlij é o peso vindo do neurônio j dacamada l − 1 para o neurônio i da camada l e bli representa o bias doneurônio i da camada l.

No início da segunda etapa do algoritmo são calculados os gradientesdos pesos referentes a última camada (para a rede exemplo, os quepossuem sobrescrito 2). Deseja-se estimar o valor de ∂E

∂ω211, utilizando

a regra da cadeia, decompõe-se tal derivada em três componentes, daseguinte forma:


Figura 2.12: Rede exemplo considerada para a explicação do algoritmo back-propagation.

Fonte: Do Autor.

∂E

∂ω211

= ∂E

∂a20· ∂a

20

∂z20· ∂z

20

∂ω211

(2.9)

onde E corresponde ao erro MSE, ω211 é o peso vindo do primeiro neurô-

nio da camada oculta para o primeiro da camada final, e a20 e z2

0 repre-sentam a ativação e o peso ponderado do primeiro neurônio da camadade saída vide a rede ilustrada na figura 2.12.

Os valores do erro total da rede em função de a20 e a derivada parcial

são dados por

E(y, a2) = 12 ·[(y0 − a2

0)2 + (y1 − a21)2]

∂E(y, a2)∂a2

0= 1

2 · (−2) · (y0 − a20) = a2

0 − y0

(2.10)


O segundo componente traz a tona a necessidade da derivada dafunção de ativação ser diferente de zero, bem como o problema dadying ReLU. A relação entre a ativação a2

0 e o peso ponderado z20 é a

própria função de ativação. Consequentemente a derivada parcial seráa derivada da função de ativação. A Equação (2.11) ilustra a relaçãoentre esses dois valores e exibe a derivada parcial para as três funçõesde ativação previamente apresentadas.

a20 = σ(z2

0)∂a2

0∂z2

0= e−x

(1 + e−x)2 , caso sigmóide

∂a20

∂z20

=( 2ex + e−x

)2= sech2(z2

0) , caso tangente hiperbólica

∂a20

∂z20

={

1 if z20 > 0

0 if z20 ≤ 0

, caso ReLU

(2.11)

Caso a derivada do sinal seja nula em todo intervalo, como é ocaso utilizando a função de Heaviside, o valor do gradiente tambémserá, mantendo os mesmos valores de pesos para qualquer entrada (semtreinamento).

Para ocorrer o dying ReLU, uma configuração de um treinamentopassado configura os pesos e bias do neurônio de modo que o pesoponderado do neurônio i da camada l (zli) assuma um valor nulo ounegativo, zerando o segundo componente e consequentemente o gradi-ente dos pesos e bias do neurônio. Como o gradiente é nulo, os pesos ebias das redes não são alterados, permanecendo nessa configuração atéo final do treinamento, “matando” o neurônio.

O valor do peso ponderado z20 em relação ao peso ω2

11 e sua derivadaparcial são dados por

z20 = ω2

11 · a10 + ω2

12 · a11 + ω2

13 · a12 + b2

0

∂z20

∂ω211

= a10

(2.12)

A junção dos três componentes forma a derivada parcial da funçãocusto em relação ao peso ω2

11 como ilustra a seguinte equação


∂E

∂ω211

= ∂E

∂a20· ∂a

20

∂z20· ∂z

20

∂ω211

= (a20 − y0) · σ′(z2

0) · a10 (2.13)

Definindo δ2i = ∂E

∂z2ie estendendo o mesmo cálculo para os demais

pesos obtém-se:

∂E

∂ω212

= δ20 · a1

1

∂E

∂ω213

= δ20 · a1

2

∂E

∂ω221

= δ21 · a1

0

∂E

∂ω222

= δ21 · a1

1

∂E

∂ω223

= δ21 · a1

2

Para os pesos da camada oculta, a aproximação é similar: a derivadaparcial do erro em relação ao peso ω1

11 é dividida em três componentes,na seguinte forma

∂E

∂ω111

= ∂E

∂a10· ∂a

10

∂z10· ∂z

10

∂ω111

(2.14)

Com exceção do primeiro termo, o formato permanece o mesmodo apresentado em (2.13) alterando-se apenas os índices. O primeirotermo possui um formato diferente em relação aos gradientes calculadosna camada de saída. Esse fato ocorre pois a saída do neurônio dacamada oculta influência na saída de cada neurônio da ultima camada,de modo que o valor da derivada parcial ∂E

∂a10pode ser descrito como a

composição de:

∂E

∂a10

= ∂E0

∂a10

+ ∂E1

∂a10

onde E0 e E1 são as componentes do erro total formado por cada neurô-nio da camada de saída.

Cada componente pode ser decomposto em função do peso ponde-rado como ilustra a seguinte equação


∂E0

∂a10

= ∂E0

∂z20· ∂z

20

∂a10

∂E1

∂a10

= ∂E1

∂z21· ∂z

21

∂a10

(2.15)

Apesar de tomar apenas um termo do erro total, o valor dos ter-mos ∂E0

∂z20

e ∂E1∂z2

1correspondem aos valores já previamente calculados

representados por δ20 e δ2

1 respectivamente. Os termos restantes corres-pondem ao peso que multiplica a ativação pela qual o termo está sendoderivado, na seguinte forma

z20 = a1

0 · ω211 + a1

1 · ω212 + a1

2 · ω213 + b2

0

∂z20

∂a10

= ω211

z21 = a1

0 · ω221 + a1

1 · ω222 + a1

2 · ω223 + b2

0

∂z21

∂a10

= ω221

(2.16)

Portanto a derivada parcial da função custo em relação ao peso ω111

toma o seguinte valor

∂E

∂ω111

=(δ2

0 · ω211 + δ2

1 · ω221)· σ′(z1

0) · a00 (2.17)

Estendendo esses cálculos para os demais pesos obtém-se:

∂E

∂ω121

=(δ2

0 · ω212 + δ2

1 · ω222)· σ′(z1

1) · a00

∂E

∂ω131

=(δ2

0 · ω213 + δ2

1 · ω223)· σ′(z1

2) · a00

Para os gradientes dos bias, as mesmas aproximações e divisõesexibidas em (2.9) para camada de saída e (2.14) para camada ocultasão utilizadas, modificando apenas o último termo que será sempreunitário como mostra a seguinte equação


∂E

∂bli= ∂E

∂ali· ∂a

li

∂zli· ∂z

li

∂bli

zli =N∑j=1

ωlij · al−1j−1 + bli

∂zli∂bli

= 1

(2.18)

Analisando os valores obtidos para os gradientes, monta-se o algo-ritmo backpropagation com fluxograma definido na Figura 2.13.

Figura 2.13: Fluxograma e cálculos do algoritmo backpropagation.

Fonte: Do Autor.

2.2.6 Gradiente Descendente Estocástico

Esse método de treinamento é conhecido na literatura como sto-casthic gradient descent (SGD). A cada iteração, uma amostra do con-junto de treinamento é processada atualizando os pesos e bias da redeno final. O número de iterações do método depende do número deamostras do conjunto de treinamento. Considerando os parâmetros θda rede a equação de atualização genérica é dada por


θk+1 = θk − η · ∇θE(θ, ~x(i), ~y(i)) (2.19)

Como exemplificado na Figura 2.17 a trajetória para o mínimo dafunção custo não sofre muitas variações seguindo uma ordem quase li-near. Em teoria, a convergência para o mínimo global é garantida. Asdesvantagens do método vem do tempo e custo computacional do pro-cessamento, os quais crescem linearmente com o dataset utilizado. Acada amostra do dataset, que pode chegar a conter milhões de dados,é necessário o processamento de toda a etapa do algoritmo de back-propagation e a etapa de atualização dos pesos o que acarreta em umconsumo computacional grande.

Devido às diversas atualizações de parâmetros da rede realizadas, afunção custo tende a ter um formato ruidoso em contraste com as per-das dos outros métodos. Um fluxograma para execução do StochasticGradient Descent é apresentado em 2.14.

2.2.7 Gradiente Descendente

Conhecido na literatura como batch gradient descent (BGD), essavariação do SGD visa resolver os problemas de esforço computacional.Nesse método os pesos são atualizados apenas após o processamento detodo o dataset pelo algoritmo de backpropagation gerando um gradienteatravés da média dos gradientes calculados de cada entrada.

A função de atualização pode ser reescrita como (2.20) para consi-derar a atualização após o processamento de todo o conjunto de dados.A trajetória para o mínimo da função custo é ruidosa como ilustra aFigura 2.17. Caso a função custo tenha um perfil mais convexo, o mé-todo garante a convergência para o mínimo global, caso contrário podeparar em um mínimo local. Cada passo do aprendizado ocorre apenasapós a utilização de todos os dados, o que pode levar ao uso de dadosredundantes que não contribuem significativamente.

θk+1 = θk − η · ∇θE(θ) (2.20)

O tempo de processamento depende do tamanho do conjunto dedados podendo levar um tempo grande para convergir. O fluxogramaexibido na Figura 2.15 exibe o processamento do método BGD.


Figura 2.14: Fluxograma das operações do método de otimização de parâ-metros SGD.

Fonte: Do Autor.

2.2.8 Gradiente Descendente Estocástico em mini lotes

O gradiente descendente estocástico em mini lotes reúne o melhordos métodos anteriores, atualizando os parâmetros a cada lote do con-junto de treinamento. Na literatura esse método tem o nome Mini-Batch Stocastic Gradient Descent (MBSGD). Esse método opera em-baralhando o conjunto de treinamento a cada época e separando oconjunto em divisões menores denominadas batch. Cada divisão é en-tão processada pelo algoritmo backpropagation, produzindo um gradi-ente através da média e os pesos são então atualizados. Reescrevendo aequação de atualização de parâmetros para considerar os lotes ela tomaa forma apresentada em 2.21.


Figura 2.15: Fluxograma das operações do método de otimização de parâ-metros SGD.

Fonte: Do Autor.

θk+1 = θk − η · ∇θE(θ, ~x(i : i+ k), ~y(i : i+ k)) (2.21)

onde k representa o número de amostras do batch.A trajetória para o mínimo global é menos ruidosa que o método

BGD devido à otimização parcial dos parâmetros como ilustra a Figura2.17. É um método mais rápido que o BGD devido a não processartodo o dataset em uma época. O embaralhamento da entrada ajuda a

2.3. REDES NEURAIS EM HARDWARE 29

evitar valores redundantes que não contribuem para o aprendizado. Oprocessamento em mini batch adiciona um pouco de ruído a curva deaprendizado o que pode auxiliar na saída de mínimos globais.

Esse método, no entanto, não converge para o mínimo global devidoao ruído que altera o passo de aprendizagem a cada iteração. A funçãocusto portanto permanece numa região de mínimo mas não no mínimoglobal. Na prática, essa não convergência não tem muita importân-cia pois a região na qual a função custo converge já garante um erropequeno.

A Figura 2.16 exibe o fluxograma para o método de aprendizagemMini-Batch SGD.

2.2.9 Momento

O momento é uma técnica que utiliza valores passados dos gradien-tes para atualização dos valores no intuito de melhorar o desempenhodos métodos de otimização. Em particular o momento auxilia na oti-mização próxima a áreas onde as curvas de nível são mais íngremes emuma direção do que na outra. A equação de otimização é modificadapelo momento e toma a seguinte forma

θk+1 = θk − η · ∇θE(θ) + α ·∆θ∆θ = θk − θk−1 (2.22)

A nomenclatura momento vem da física pela similaridade que aatualização dos parâmetros apresenta com o momento de um objeto.O termo multiplicado pelo momento incrementa para regiões em queo gradiente se mantém na mesma direção e reduz quando a direçãoé alterada, similar a uma bola descendo uma colina. Caso aplicadocorretamente, o momento propicia convergência mais rápida e oscilaçãoreduzida.

2.3 Redes neurais em Hardware

As realizações das redes neurais e os algoritmos associados em hard-ware recebe o nome de Hardware Neural Networks. As HNNs oferecemvantagens em termo de custo e de velocidade de processamento emrelação as redes realizadas puramente em software, uma vez que este


Figura 2.16: Fluxograma das operações do método de otimização de parâ-metros MBSGD.

Fonte: Do Autor.

último roda sobre um hardware de propósito geral [19]. O uso de FP-GAs para o design de HNNs torna-se atrativo devido à sua habilidadede processamento em paralelo, permitindo por exemplo o cálculo dasaída de vários neurônios de uma camada simultaneamente.


Figura 2.17: Trajetórias da otimização dos parâmetros dos métodos SGD(roxo), BGD (azul) e MBSGD (verde).

Fonte: Adaptado de [29].

2.3.1 FPGA

O FPGA é um dispositivo semicondutor reprogramável compostopor milhares de blocos lógicos configuráveis interconectados. Utilizandouma HDL como Verilog ou VHDL (Very High Speed HDL), tais blo-cos e suas conexões são reconfigurados para realização de uma funçãoimplementada na forma de um circuito digital.

Em comparação com outros dispositivos reprogramáveis como mi-croprocessadores, digital signal processors (DSP) ou até mesmo comblocos aceleradores como uma GPU, as FPGAs apresentam um bai-xíssimo consumo energético para um elevado tempo de processamento[30].

2.3.2 Ponto fixo

A representação em ponto fixo é uma das formas principais de arma-zenamento e processamento de números reais em hardware [30]. Essarepresentação é realizada com números inteiros obtidos após a multi-plicação por um fator de conversão e uma quantização posterior. Paraaplicações diretamente em hardware opta-se, em geral, por um fatorde conversão que é potência de dois, facilitando as operações com esse


Tabela 2.1: Representação dos números 0,65, 1,27 e 3,42 como ponto fixo nosformatos Q1.4, Q2.6 e Q3.8.

Número realoriginal

0,65 1,27 3,42

ConversãoQ1.4

01010 10100 10110

Número realreconvertido

0,625 1,25 1,375

ConversãoQ2.6

00101001 01010001 11011010


0,640625 1,265625 3,40625

ConversãoQ3.8

00010100110 00101000101 01101101011


0,6484375 1,26953125 3,41796875

Fonte: Do Autor.

tipo de representação.

Para representar um número em ponto fixo dois fatores precisam serdefinidos: o tamanho (número de bits) da word e a posição do pontodecimal. O formato Q é uma forma de representar esses fatores em sis-temas que tenham resolução constante [30]. Esse formato é organizadocomo Qm.n onde m é a quantidade de bits destinada a parte inteira en a parte fracionária. A conversão para ponto fixo é realizado multipli-cando o número original por 2n e restringindo a m bits considerandom− n bits antes do ponto decimal. A Tabela 2.1 ilustra alguns núme-ros reais representados nos formatos Q1.4, Q2.6 e Q3.8 e a reconversãopara números reais.

De modo a conservar recursos de hardware e acelerar o processa-mento, implementa-se no FPGA os cálculos com números representadosem ponto fixo, uma vez que isso resulta em circuitos digitais de menorcomplexidade [31].


2.3.3 Linear Feedback Shift Register

A inicialização dos pesos de uma rede neural pode influenciar naconvergência dos métodos de aprendizagem [32]. Um dos métodos uti-lizados (inicialização de Glorot) consiste na inicialização com númerosrandômicos dentro de um limite definido pela arquitetura da rede [32].A geração de um número randômico, ou pseudo-randômico diretamenteem hardware pode ser alcançado por um Linear Feedback Shift Register(LFSR).

Um LFSR fornece uma maneira simples e eficaz de gerar númerosnão sequenciais a partir de um shift register, portas XOR e um seedinicial. O funcionamento de um LFSR é descrito com auxílio da Figura2.18. A cada ciclo de clock, o shift register desloca os valores dos bitsmenores para os maiores esquecendo do valor no MSB (Most SignificantBit) e com a entrada no LSB (Least Significant Bit) fornecida por umaXOR entre saídas do registrador.

Na Figura 2.18 as saídas, denominadas na literatura como taps, uti-lizadas na XOR são oriundas dos bits 4 e 1. Através de um valor inicial(seed) o LSFR irá atualizar e produzir uma saída pseudo-randômicacomo mostra a Tabela 2.2. O estado 0 com todas as saídas zeradas éum estado proibido para o LSFR implementado com XOR pois a saídafica travada não produzindo novos números.

Como o número de possíveis estados é finito após um tempo a saídase repete, porém com uma boa escolha do feedback via XOR o LSFRconsegue produzir uma sequência que parece randômica.

Figura 2.18: Topologia de um Linear Feedback Shift Register de 5 bits comtaps nos bits 1 e 4.

Fonte: Do Autor.


Tabela 2.2: Tabela de resultados do LFSR de 5 bits com um seed inicial devalor unitário.

iteração bits valorseed 00001 11 00010 22 00101 53 01010 104 10101 215 01011 116 10111 237 01110 148 11101 29

Fonte: Do Autor.

2.4 Ferramentas utilizadas

2.4.1 Python

Python é uma linguagem de programação interpretada de alto ní-vel muito utilizada para aprendizado de máquina e análises de dados.Foi criada por Guido van Rossum por meados de 1990 no StichtingMathematisch Centrum. Possui uma arquitetura eficiente voltada paraa programação orientada a objetos com diversas bibliotecas nas maisdiversas áreas de engenharia, especialmente na área de redes neuraiscomo o Scikit-learn, Tensorflow, Keras e PyTorch.

2.4.2 MatLab

O MatLab é a linguagem do software homônimo criado no final dosanos 70 por Clever Moler. Trata-se de um software de alta performancemantido pelo MathWorks voltado para o cálculo numérico integrandoferramentas de processamento digital de sinais, análise numérica, cál-culo matricial e ferramentas gráficas. O MatLab é utilizado em váriasáreas de engenharia desde controle até processamento visual.

2.4. FERRAMENTAS UTILIZADAS 35

2.4.3 Verilog

A linguagem de descrição de hardware (HDL) Verilog foi criada en-tre 1983 e 1984 por Prabhu Goel et al. Os principais usos da linguagemsão a criação e a validação de circuitos digitais para ASICs (AplicationSpecific Integrated Circuit) e FPGAs. Com uma estrutura similar ada linguagem C, a linguagem Verilog permite a criação de algoritmosatravés de unidades lógicas e registradores podendo se beneficiar doparalelismo e pipeline em sistemas. Diferentemente de uma linguagemde alto nível como Python, as HDLs permitem uma modelagem no ní-vel RTL (Register Transfer Level) sendo capazes de modelar todo equalquer aspecto de um circuito digital.

CAPÍTULO 3

Desenvolvimento

Neste capítulo é apresentado o desenvolvimento do presente traba-lho. Inicialmente a visão geral do projeto proposto é descrita, comen-tando sobre as etapas realizadas em Python, em MatLab com aritméticade ponto fixo e em Verilog para sintetização em FPGA. Na sequência,é detalhada a etapa do desenvolvimento em Python que consiste no usoda biblioteca especializada em aprendizado de máquina scikit-learn, naseleção dos datasets utilizados e na criação e treinamento das redesMLP. Na etapa seguinte, os algoritmos para treinamento são realizadoscom ponto fixo em MatLab visando resultados similares aos obtidoscom Python. Os algoritmos criados realizam a geração de pesos inici-ais, o embaralhamento da entrada, a separação em batchs, a geraçãodos gradientes da função custo em relação aos parâmetros com o al-goritmo backpropagation, atualização dos pesos pelo método MBSGDcom momento, o cálculo da função custo MSE, o cálculo da acurácia eo controle do treinamento. Finalmente, é apresentada a tradução dosalgoritmos para Verilog visando a implementação em FPGA.

37

38 CAPÍTULO 3. DESENVOLVIMENTO

3.1 Visão Geral

O presente trabalho é voltado para a implementação do treinamentode uma rede neural MLP em FPGA. Para tal três etapas são considera-das: geração da ANN base e seu treinamento com gradiente descendenteestocástico com mini lotes em Python, reprodução da rede e do treina-mento utilizando aritmética de ponto fixo em MatLab e implementaçãocom Verilog da ANN e do treinamento em hardware (HNN). A Figura3.1 ilustra as divisões das etapas necessárias para o desenvolvimentodo trabalho. As duas primeiras etapas são apresentadas sobre o campoSoftware, a última sobre o campo Hardware.

Figura 3.1: Estrutura do desenvolvimento do presente projeto.

Fonte: Do Autor.

Na primeira etapa, utilizando os recursos da biblioteca scikit-learn,é criada uma topologia de rede com arquitetura MLP e efetua-se otreinamento dessa rede utilizando algumas combinações de hiper pa-râmetros. Como o foco principal é a análise do treinamento, não sãoutilizadas funções de escolha ideais de parâmetros visto que uma dasformas de validação com o código em MatLab é treinar a rede para omesmo dataset mas diferentes valores de parâmetros comparando os re-sultados ao final. O treinamento escolhido foi o gradiente descendente

3.1. VISÃO GERAL 39

estocástico em mini lotes com aceleração por momento. Os datasetsutilizados nas próximas e nesta etapa são criados a partir de funçõesda biblioteca especializada.

Para a etapa seguinte, todas as funções utilizadas da bibliotecascikit-learn foram analisadas e convertidas para linguagem do MatLabcom aritmética de ponto fixo. O uso dessa aritmética facilita a traduçãoposterior para a HDL Verilog. Em MatLab, de modo a facilitar asintetização em FPGA, restringiu-se a função de ativação da rede àReLU.

Finalmente na etapa de hardware, o código em MatLab foi conver-tido para linguagem de descrição de hardware utilizando os diversos IPsfornecidos pela família Cyclone para sintetizar as operações do treina-mento. Nessa etapa, para simplificar o desenvolvimento, restringiu-sea topologia da rede a uma 2:5:1 como apresentado na figura 3.2.

Figura 3.2: Topologia da rede implementada em Verilog com duas camadas(a camada de entrada não é considerada).

Fonte: Do Autor.


3.2 Desenvolvimento em Python

A etapa de desenvolvimento em Python é responsável pela criaçãoda rede e realização do treinamento no qual o restante projeto se baseia.Discorre-se neste capitulo sobre a biblioteca scikit-learn, o desenvolvi-mento dos datasets e a criação e treinamento da rede MLP.

3.2.1 Biblioteca Scikit-learn

A biblioteca open source scikit-learn [33] fornece ferramentas e APIs(Application Programming Interfaces) para análise de dados e aprendi-zado de máquina utilizando a linguagem Python. Seu desenvolvimentocomeçou em 2007 no evento Google Summer of Code sendo disponi-bilizado para o público apenas em 2010. Algumas das empresas queutilizam a biblioteca são o Spotify, Evernote, Boooking.com, dentre ou-tras [34].

Dentre os diversos APIs disponíveis, o foco do projeto recai sobredois: a classe MLPClassifier do API Neural_networks, utilizadapara criar e treinar redes MLP para resolução de tarefas de classificaçãobinária ou multi-classe, e o método make_classification do APIDatasets cujo objetivo é a geração dos conjuntos de treinamento, testee validação para os problemas de aprendizado de máquina.

3.2.1.1 API Neural_networks

Esse API disponibiliza ferramentas de aprendizado de máquina comaprendizado supervisionado ou não supervisionado. Para supervisi-onado, fornece classes que sintetizam redes neurais com arquiteturaMLP para tarefas de classificação e regressão possibilitando o treina-mento com SGD, Adam ou L-BFGS e mudanças nos hiper parâmetrosde treinamento como o valor da taxa de aprendizagem e momento. Jápara não supervisionado fornece uma classe que realiza máquinas deboltzmann restritas (RBM) otimizando os pesos através de StochasticMaximum Likelihood (SML). A documentação desse API está disponí-vel em [35] para supervisionado e em [36] para não supervisionado.

3.2. DESENVOLVIMENTO EM PYTHON 41

3.2.1.2 API Datasets

Este API fornece métodos que carregam, criam ou baixam datasetspara uso em tarefas de aprendizado de máquina. Os conjuntos de dadoscarregados são em geral conjuntos pequenos que não necessitam dedownload externo salvos diretamente na biblioteca, alguns dos exemplossão os conjuntos Iris plant [37] e Boston House Pricing [38].

Os conjuntos de dados que necessitam de download externo são,em grande parte, bem conceituados na literatura de aprendizado demáquina e de tamanho demasiado grande para serem registrados na bi-blioteca, alguns dos exemplos incluem o Labeled Faces in the Wild [39]e o RCV1 dataset [40]. Os conjuntos criados pela biblioteca são pro-duzidos através de métodos internos do API controlando fatores comoo tamanho e propriedades estatísticas durante a criação. A documen-tação desse API está disponível em [41].

3.2.2 Datasets

Para o treinamento e validação de redes o API Datasets da bi-blioteca scikit-learn possui o método make_classifications que criadados pseudo randômicos para serem utilizados em problemas de classi-ficação de n-classes. Cada classe é composta por um número de clustersgaussianos localizados sobre os vértices de um hipercubo de dimensãon dada por um argumento. Os argumentos passados para o métodosão o número de amostras geradas, número de dimensões das amostras,número de classes, dimensão do hipercubo, número de amostra redun-tantes, número de clusters por classe, o espaçamento entre os vérticesdo hipercubo n-dimensional, dentre outros apresentados na documen-tação do método em [42].

3.2.2.1 2 classes

Através do método make_classifications criou-se um datasetcom 2 classes contendo 11000 amostras para capacitar a rede criadaa realizar uma classificação binária. Foi considerada apenas 1 clusterpor cada classe e o gráfico dos dados criados é exibido na Figura 3.3.Esses dados são utilizados como conjunto de treinamento das etapasposteriores utilizando MatLab e Verilog.


Figura 3.3: Dados do dataset para classificação binária criado pelo métodomake_classification da biblioteca scikit-learn.

Fonte: Do Autor.

3.2.2.2 4 classes

De modo a avaliar o desempenho da topologia da rede MLP conside-rada em problemas de classificação multi-classe criou-se um conjuntode dados com o mesmo número de amostras mas com 4 classes. AFigura 3.4 ilustra o gráfico dos dados com as 4 classes.

3.2.3 Criação e treinamento das redes

Para criar e treinar as redes MLP utiliza-se a classe MLPClassi-fier do API Neural_networks da biblioteca scikit-learn. A classecria um classificador com uma rede multilayer perceptron de tamanhovariável, setado por um argumento, utilizando a função de custo log-loss, a função de ativação selecionada entre as funções identidade, lo-gística (sigmóide), tangente hiperbólica ou ReLU e o treinamento comgradiente descendente estocástico, Adam ou L-BFGS. Para facilitara utilização em hardware optou-se por utilizar a função de ativação

3.3. DESENVOLVIMENTO EM MATLAB 43

Figura 3.4: Dados do dataset para classificação multi-classe criado pelo mé-todo make_classification da biblioteca scikit-learn.

Fonte: Do Autor.

ReLU e MSE como função custo. De modo a utilizar esta função custoderivou-se uma classe mantendo como herança a MLPClassifier al-terando a inicialização da função custo de log_loss para squared_loss.

3.2.3.1 Topologia 2:5:1

Utilizando a classe derivada com função custo MSE, função de ati-vação ReLU e treinamento com SGD criou-se a rede com topologia 2:5:1como ilustrada na figura 3.2. Os resultados são exibidos mais detalha-damente na 4.1 mas de modo a demonstrar a habilidade de classificaçãoda rede, as Figuras 3.5 e 3.6 exibem os hiperplanos criados separandoos dados dos conjuntos de teste do primeiro e segundo dataset.

3.3 Desenvolvimento em MatLab

O desenvolvimento dos algoritmos de treinamento em MatLab pos-sui 2 objetivos: a implementação das funções que em Python são con-


Figura 3.5: Hiperplanos criados pela rede 2:5:1 separando as 2 classes doprimeiro dataset.

Fonte: Do Autor.

sideradas “black boxes” da biblioteca scikit-learn e permitir a avaliaçãodo desempenho do treinamento com diferentes precisões da represen-tação em ponto fixo para os dados principais da rede (pesos, bias eativações) e para os cálculos internos.

A Figura 3.7 ilustra o fluxograma do treinamento implementadoem MatLab com aritmética de ponto fixo. Os argumentos passadospara o programa estão sumarizados nos sinais em cinza. O argumentoconfigurações da rede contém a resolução da rotina de treinamento ea topologia da rede. A resolução configura a precisão dos dados e doscálculos internos da rede utilizando o formato Q, ou seja, configurao número de bits para representar a parte inteira e a fracionária. Atopologia é passada em um vetor com cada elemento representando onúmero de neurônios por camada, ou seja, a topologia que aparece nafigura 3.2 é passada para o programa como [2, 5, 1]. Os hiper parâ-metros são a taxa de aprendizagem inicial e o valor do momento. Ascondições de treinamento representam o tamanho do batch, o número


Figura 3.6: Hiperplanos criados pela rede 2:5:1 separando as 4 classes dosegundo dataset.

Fonte: Do Autor.

de batchs e o número máximo de épocas. As condições de parada sereferem a tolerância e ao número de épocas sem alteração.

Os sinais em vermelho representam as variáveis que operam so-bre os desvios condicionais que no programa correspondem a um loopwhile (desvio condicional Cond_1) e um loop for (desvio condicionalCond_2). O número de épocas (n_epochs) e o número de batchs(n_batch) incrementam ao final dos seus respectivos loops. O con-tador de mudanças da função custo (ctr_chgLoss) incrementa casoa diferença entre as funções custo atual e anterior for menor que atolerância, caso contrário o contador zera.

Através da avaliação do desempenho com diferentes precisões, selecionou-se a representação dos dados para gerar os resultados em MatLab e paraimplementação fixa em Verilog. Comparando a evolução das curvas deaprendizado (função custo x épocas) avalia-se o erro de quantizaçãopara as representações Q7.16, Q7.32 e Q7.48. Esses testes são apresen-tados em 4 onde se optou pela utilização da representação no formato


Q7.16 devido ao baixo erro e menor consumo de hardware em relaçãoa Q7.32 e Q7.64. As explicações sobre o desenvolvimento em Ma-tLab consideram uma resolução genérica representada por Qm.n. Nasequência, discorre-se sobre cada etapa do fluxograma explicando seufuncionamento.

3.3.1 Gerador de pesos aleatórios

Duas etapas do processamento em MatLab utilizam funções de arit-mética de ponto flutuante para depois serem convertidas para pontofixo. A primeira que faz essa utilização é a etapa Gerador de pesosaleatórios. Essa rotina realiza a inicialização dos pesos e bias da redeutilizando a função definida por Glorot [32] que é descrita por

ωLij = U(−lim, lim)bLi = U(−lim, lim)

lim =√

6fan_in+ fan_out

(3.1)

onde ωLij corresponde ao peso indo do neurônio j da camada L−1 parao neurônio i da camada L, bLi representa o bias do neurônio i da ca-mada L, U(a, b) é uma distribuição uniforme no intervalo [a, b], fan_incorresponde ao número de neurônios da camada L − 1 e fan_out aonúmero de neurônios da camada L.

A Figura 3.8 mostra a parte do código responsável pela geração dospesos e bias iniciais.

A função de aritmética de ponto flutuante é a função rand(.) quecria uma distribuição uniforme entre 0 e 1. Esse valor é então convertidopara os limites definidos pela equação de Glorot que para a rede definidana figura 3.2 possui os valores 1 para os parâmetros da camada de saídacom fan_in = 5 e fan_out = 1 e 0.92582 para os da camada ocultacom fan_in = 2 e fan_out = 5.

3.3.2 Calcula perda

Esta etapa é responsável por calcular a função custo MSE a partirdas saídas estimadas da rede (y) e das saídas esperadas (y). A Equação(2.7) ilustra o processamento realizado pelo bloco. A figura 3.9 mostrao código utilizado para calcular a função custo a cada época. A saída


Figura 3.7: Fluxograma do treinamento em MatLab.

Fonte: Do Autor.


Figura 3.8: Código responsável pela inicialização dos pesos. Os pesos sãoinicializados através da função rand que cria uma distribuição uniforme entre0 e 1, escalonados para o intervalo [-lim, lim] representado no código pelavariável init_bound e convertidos para a representação Qm.n multiplicandopor 2n.

Fonte: Do Autor.

estimada corresponde a ativação do último neurônio da camada de saídae é calculada em uma função denominada Feedforward que realiza a(2.3) produzindo todas as ativações da rede.

Figura 3.9: Código responsável pelo cálculo da função custo a cada época.

Fonte: Do Autor.

Como o número de amostras é uma potência de dois (213 = 8192amostras) utiliza-se o deslocamento de bits para realizar a divisão, avariável length_actual contém o valor de log2(Número de amostrasdo treinamento).

3.3.2.1 Calcula perda: função Feedforward

Essa função é responsável por produzir as saídas estimadas da redepara a época correspondente. Ela é também utilizada na etapa Separa


em batch, porém adaptada para produzir as saídas da rede apenasreferente ao batch e na etapa Calcula acurácia.

Cada ativação é gerada por um sub-função denominada Percep-tron que realiza o cálculo da saída de um neurônio registrado a ati-vação e o peso ponderado. A Figura 3.10 exibe parte do código querealiza o processamento da sub-função. A saída externada correspondeao somatório da multiplicação entre entradas e pesos somados ao biase processado pela função de ativação como mostra (2.3). A função deativação ϕ(.) calcula a função ReLU como apresentada na Seção 2.1.4.3,Equação (2.6).

Figura 3.10: Código que realiza o processamento da sub-função perceptron

.Fonte: Do Autor.

3.3.3 Embaralha entrada

A etapa Embaralha entrada é a segunda e última que não possuitodo processamento em ponto fixo. O objetivo dessa etapa é embaralharo sinal de entrada em uma ordem randômica a cada nova época. Essaprática auxilia na convergência do método MBSGD removendo algunsdados redundantes para a aprendizagem.

Inicialmente o conjunto de treinamento é registrado em um vetorapós conversão para ponto fixo através da quantização após multipli-cação pelo fator 2n. Na etapa de embaralhamento, um seed randômicoé gerado através da função rand e escalonado para um valor entre 1 (oMatLab considera a primeira amostra como 1 e não 0) e o valor máximo


das amostras do conjunto de treinamento (8192). O sinal é então des-locado de modo que o endereço do vetor que seed representa assuma aúltima posição e a primeira amostra após seed assuma a posição inicialcomo representado na figura 3.11.

Figura 3.11: Processo de embaralhamento da entrada. O valor do seed torna-se o valor final do vetor e o primeiro valor após seed se torna o primeiro.

Fonte: Do Autor.

3.3.4 Separação em batches

Como mencionado na Seção 2.2.8, o algoritmo backpropgation pro-duz o valor do gradiente utilizado na atualização dos parâmetros atravésda média dos gradientes de cada amostra de um batch. A separação daentrada em batchs ocorre nessa etapa.

O número de batchs é uma relação entre tamanho de cada batch ea quantidade total de amostras. Escolhendo o tamanho do batch comopotência de 2 para facilitar a geração da média do backpropagation, o


número de batch se torna um valor fixo. O número de batchs é passadocomo um argumento para a rotina de treinamento.

3.3.5 Feedforward batch

A etapa Feedforward batch realiza a primeira parte do algoritmobackpropagation produzindo as ativações e pesos ponderados da rede.Como já mencionado essa etapa utiliza a mesma função feedforward daetapa Calcula perda porém produzindo todas as saídas de um batche não de todo o conjunto de treinamento.

3.3.6 Backpropagation

Essa etapa realiza a segunda etapa do algoritmo backpropagation,calculando os gradientes da função custo em relação a cada peso e biasda rede. Para produzir os gradientes utiliza-se as equações apresentadasna figura 2.13 gerando primeiramente os δs das camadas de saída eoculta e posteriormente os gradientes dos pesos e bias.

A figura 3.12 mostra o código utilizado para realizar a etapa Back-propagation.

3.3.7 Otimização dos pesos

A partir do valor do gradiente da etapa passada os pesos e bias sãoatualizados com (2.22) e o código apresentado na Figura 3.13. Os valo-res da taxa de aprendizagem e momento são passados como argumentosno início do programa e convertidos pelo fator 2NB .

3.3.8 Cálculo da acurácia

Essa etapa utiliza a mesma função feedforward que a etapa Calculaperda para produzir as saídas da rede. Passando como entrada paraa rotina os últimos pesos e bias obtidos e o conjunto de treinamentooriginal (sem embaralhamento), as saídas da rotina são comparadascom as saídas esperadas. A acurácia é calculada somando o número depredições corretas e dividindo pelo número total de saídas. O processoé repetido para os conjuntos de teste e validação.


Figura 3.12: Código do algoritmo backpropagation realizado em MatLab.

Fonte: Do Autor.

Figura 3.13: Código utilizado para atualizar os pesos emMatLab convertendoos hiper parâmetros para ponto fixo utilizando 2NB .

Fonte: Do Autor.

3.4. IMPLEMENTAÇÃO EM FPGA UTILIZANDO VERILOG 53

3.3.9 Validação do desenvolvimento em MatLab

Os resultados obtidos com o programa em MatLab que realiza otreinamento são discorridos na Seção 4.2 exibindo as curvas de funçãocusto por épocas. Uma comparação é feita com a função de custo obtidacom Python mostrando a similaridade entre os resultados e validandoo código desenvolvido em MatLab.

3.4 Implementação em FPGA utilizando Verilog

Para realizar a tradução entre uma HDL como Verilog e uma lingua-gem de programação como MatLab vários fatores devem ser levados emconsideração. Enquanto os comandos de uma linguagem de programa-ção irão executar rotinas da CPU (ou de uma máquina virtual como éo caso da linguagem Java), as HDLs descrevem um hardware definindoseu comportamento diretamente.

Processos como criação de variáveis em uma HDL são limitados aquantidade de memória dentro do FPGA considerado. Rotinas prontascomo loops for ou while necessitam ser implementadas através de umaFSM (Finite State Machine - Máquina de Estados Finito). Operaçõesde multiplicações e somas são criadas através de circuitos combinacio-nais sintetizados no FPGA com LUTs (Look Up Tables) ou através deIPs (Intellectual Property) fornecidos pela fabricante do FPGA.

3.4.1 Escolha da resolução

A precisão do treinamento está diretamente relacionada com a re-solução da representação em ponto fixo utilizada pois influi nos errosde quantização das operações como mencionado na Seção 2.3.2.

Após os testes realizados em MatLab, comparando os resultadospara diferentes resoluções, optou-se pelo uso da representação Q7.16com uma word de 24 bits sendo 1 bit de sinal, 7 para a parte inteira e16 para a fracionária como ilustrado na figura 3.14.

3.4.2 Implementação do sistema treinador

A figura 3.15 ilustra o diagrama de blocos do sistema de treinamentode redes neurais com arquitetura MLP proposto. As entradas/saídas


Figura 3.14: Organização da word utilizada para representar os dados e asoperações internas.

Fonte: Do Autor.

em vermelho indicam sinais de controle: a entrada train inicia o pro-cesso de treinamento e a saída done sinaliza o final do treinamentoapós alcançar umas das condições de parada impostas.

As entradas em cinza indicam as configurações do bloco treinador.As entradas learn_rate e momt passam para o bloco os valores doshiper parâmetros taxa de aprendizagem e momento respectivamente.BatchSize é o tamanho de amostras de cada batch, NEpochs indicao número máximo de épocas a serem treinadas e as entradas tol eNEpochs_tol controlam um dos critérios de parada do treinamento.

A saída MSE exibe o valor da função custo atualizada a cada época.As duas memórias presentes na figura ilustram as memórias que contémo conjunto de treinamento e os pesos e bias. Para o dataset utilizado eapresentado na figura 3.5 são separadas 8192 amostras para construiro conjunto de treinamento. Cada amostra é composta por dois valores(x0

0(i) e x01(i), as duas entradas da rede) logo existem 16384 dados

para serem registrados em uma memória para constituir o conjunto detreinamento. As saídas esperadas (classificando os dados entre a classe0 ou classe 1) também necessitam ser registradas para efetuar a rotinade aprendizagem da rede. De modo a facilitar o design é criada umamemória com 8192 endereços com words de 49 bits, os dois dados decada amostra são registrados nos bits de 0 a 23 para x0

0(i) e 24 a 47 parax0

1(i). O MSB de cada word contém a saída esperada (0 para classe0, 1 para classe 1) de modo que os endereços dessa memória estejamconfigurados como exibidos na figura 3.16.

O número de parâmetros da rede apresentada na Figura 3.2 é 21, 15pesos e 6 bias, por conveniência os pesos e bias também são registradosna mesma memória com os pesos ocupando as 15 primeiras posições(de 0x00 a 0x0E) e os bias ocupando as demais (de 0x0F a 0x14). No


endereço 0x00 está registrado o peso ω111, no 0x01 ω1

12, no 0x02 ω113 e

assim sucessivamente.

Figura 3.15: Diagrama de blocos do treinador de redes MLP implementadoem FPGA.

Fonte: Do Autor.

3.4.3 Treinador

O bloco principal do sistema é o responsável pelo loop de controleda atualização dos pesos. Como pode ser visto na Figura 3.17, seudatapath é composto por 6 blocos:

• Gerador de pesos aleatórios - Bloco responsável por produziros pesos e bias iniciais através de um PRNG (Pseudo RandomNumber Generator).

• Embaralha Entrada - A partir de um seed produzido por umPRNG, esse bloco embaralha os endereços da memória que con-tém os dados do conjunto de treinamento.

• Calcula e verifica perda - Neste bloco a partir dos pesos atuaise da entrada embaralhada calcula-se a saída estimada. Os resul-tados são utilizados no cálculo do MSE (Mean Square Error)gerando o valor da função custo atual. Com o valor da funçãocusto o bloco verifica se é necessário interromper o treinamentoindicando para o bloco de controle.


Figura 3.16: Organização dos dados dentro da memória do conjunto de dados,como a resposta esperada é apenas 1 ou 0 ela é colocada como MSB das words.

Fonte: Do Autor.

• Separa batch - Fazendo a leitura das posições da memória doconjunto de treinamento esse bloco cria um buffer, do tamanhode BatchSize, contendo cada batch (um por vez) da rotina detreino.

• Calcula gradiente - Esse bloco é o responsável pelo processa-mento do algoritmo backpropagation, responsável pela produçãodos gradientes da função custo em relação aos parâmetros da rede.

• Otimiza pesos - Utilizando os gradientes calculados no blocoanterior os pesos e bias são atualizados através do treinamentode gradiente descendente estocástico com momento.

As entradas/saídas indicadas em vermelho representam as conexõesdo datapath com o bloco de controle. Já os sinais em cinza representamas entradas de configuração dos blocos.

3.4.4 Bloco de controle do Treinador

O bloco de controle em um sistema digital é o responsável pela ope-ração do datapath do respectivo sistema através de uma Finite StateMachine. A figura 3.18 ilustra a máquina de estados do sistema trei-nador. As mudanças entre estados dependem tanto do estado atualquanto das entradas do bloco de controle (saídas do datapath), carac-terizando uma máquina de Meally.


Figura 3.17: Diagrama de blocos do treinador.

Fonte: Do Autor.

3.4.5 Gerador de pesos aleatórios

Este bloco é o responsável pela inicialização dos pesos e bias iniciaisda rede segundo a mesma inicialização utilizada em MatLab (definidana Seção 3.3.1). Os cálculos necessários para a inicialização foram


Figura 3.18: FSM do sistema treinador.

Fonte: Do Autor.

previamente apresentados na em (3.1).

Como pode-se notar na equação é necessário um valor aleatório emuma distribuição uniforme entre os dois limites criados pelo formatoda rede. Em MatLab a aproximação utilizada consistia no uso de umafunção interna que produzia um valor pseudo-randômico de uma distri-buição uniforme entre 0 e 1, sendo esse valor posteriormente escalonadopara o intervalo requerido. Em hardware uma das formas de produ-zir um número pseudo-randômico é a utilização de um Linear-feedbackShift Register (LFSR) cuja forma de operação é apresentada na Seção2.3.3.

O LSFR implementado possui uma arquitetura de 16 bits com tapsnos bits 16, 15, 13 e 4. O número de diferentes valores capaz de geraré 216 − 1. A figura 3.19 mostra um trecho do código em Verilog queimplementa o LFSR.


Figura 3.19: Parte do código de Verilog que implementa o LFSR.

Fonte: Do Autor.

3.4.6 Embaralha entrada

Como mencionado na fundamentação teórica o embaralhamento daentrada faz parte do método MBSGD, prevenindo a aparição de valoresredundantes que não contribuem para o aprendizado no mesmo batch.Para embaralhar a entrada, um seed é produzido por um bloco LFSRinterno ao bloco Embaralha entrada. A entrada está salva na memó-ria RAM conjunto de treinamento e a partir do seed, que é escalonadopara um endereço da memória, os endereços são deslocados de modoque o endereço ao qual o seed corresponde torna-se o ultimo endereçocomo já ilustrado na figura 3.11.

3.4.7 Calcula perda

O bloco Calcula perda é formado pela junção de um módulo res-ponsável pelo cálculo da perda denominado MSE e um bloco que produzas entradas necessárias (saída da rede) para esse módulo. As saídas darede são calculadas através do bloco feedforward que externa as ativa-ções da rede utilizando a equação 2.3.


A cada entrada processada e externada pelo módulo feedforward omódulo MSE registra o valor correspondente a perda daquela ativação,produzindo a saída apenas no processamento do último endereço damemória do conjunto de treinamento.

3.4.7.1 Feedforward

Nesse módulo o calculo das ativações e pesos ponderados da redeé realizado e esse valores são então salvos em um buffer para uso pos-terior. No caso do bloco Calcula perda, apenas a ultima ativação énecessária, mas como esse mesmo módulo é utilizado em outros blocos,o Calcula gradiente, essa configuração de registro em um buffer émantida.

O controle do módulo é feito por uma FSM contida na FSMD re-presentada na figura 3.20. As variáveis N_ctr e ω_ctr representamrespectivamente os contadores dos neurônios processados e dos pesosjá utilizados. MAX_N representa o número de neurônios máximo aser processado no bloco e MAX_ω o número máximo de pesos a seremutilizados no cálculo de um neurônio.

O processamento dos dados é realizado em um sub-módulo que exe-cuta a função do neurônio perceptron de uma rede neural. Em virtudedisso, tal sub módulo recebe o nome Perceptron.

3.4.7.2 Perceptron

A execução desse sub módulo produz a saída de um neurônio rece-bendo na entrada os respectivos parâmetros de peso, bias e a ativaçãodas camadas antigas. O processamento é realizado pelo circuito digitalapresentado na figura 3.22 e o código responsável pela geração dessesub-módulo é exibido na figura 3.21.

3.4.7.3 MSE

Recebendo como entrada a saída do módulo Feedforward e o valordo MSB da leitura da memória do conjunto de treinamento estendidopara 16 bits, o módulo calcula e registra o valor da função custo para aconfiguração de parâmetros atual, externando o valor da função custoao final da leitura da memória e do cálculo do erro do último valor. AFigura 3.23 ilustra o circuito responsável pelo cálculo da função custo.


Figura 3.20: Finite State Machine with Data responsável pelo controle domódulo feedforward embutida nos blocos Calcula perda e Calcula gradi-ente.

Fonte: Do Autor.

3.4.8 Separa em Batch

A separação em batchs é uma parte primordial do algoritmo MBSGDonde repartições do conjunto de treinamento são tomadas e utilizadaspara produzir o gradiente através do backpropagation e então atualizaros parâmetros da rede.

Para o bloco Separa em Batch um parâmetro contendo o ende-reço máximo da RAM conjunto de treinamento e um com o valor dotamanho do batch são utilizados como entrada. Dentro do bloco doiscontadores iniciam a partir da habilitação, um que estava zerado e ou-tro que continha o ultimo endereço processado da memória conjuntode treinamento. Quando o contador que estava zerado atinge o númeromáximo de amostra do batch o bloco entra no modo de espera e nãorealiza mais nenhum processo até uma nova habilitação. Os contadoresfornecem o valor dos endereços da memória usados como leitura (me-mória de conjunto de treinamento) e a utilizada como escrita (memóriabuffer). Cada incremento dos contadores respeita o tempo necessáriode leitura e escrita das memórias.


Figura 3.21: Código responsável pela execução do neurônio perceptron comfunção de ativação ReLU.

Fonte: Do Autor.

3.4.9 Calcula gradiente

Esse bloco realiza o cálculo do gradiente da função custo em relaçãoaos parâmetros (pesos e bias) da rede realizando o algoritmo backpro-pagation. É constituído por dois módulos: o já apresentado feedforwardque realiza a primeira etapa (forward pass) do algoritmo e o módulobackpropagation que executa a segunda etapa (backward pass). O con-trole do bloco é realizado pela FSM contida na FSMD representada nafigura 3.24 onde o gradiente é calculado e registrado para cada conjuntode entradas lidas da memória de conjunto de treinamento. O controleespera até valor do ultimo endereço da memória buffer ser processadopara externar o valor do gradiente.


Figura 3.22: Datapath do sub-módulo Perceptron responsável pelo processa-mento do módulo Feedforward.

Fonte: Do Autor.

3.4.9.1 Backpropagation

O módulo backpropgation realiza a segunda etapa do algoritmohomônimo, a sequência denominada backward pass responsável pelaretro-propagação do erro e cálculo do gradientes da função custo emrelação aos parâmetros. As equações necessárias são apresentadas nafigura 2.13. Baseadas nessas equações e na matemática do algoritmoapresentada na fundamentação teórica as equações necessárias de seremimplementadas para a rede considerada são as seguintes


Figura 3.23: Diagrama do datapath do módulo MSE do bloco Calculaperda.

Fonte: Do Autor.

Figura 3.24: FSMD do bloco Calcula Gradiente que realiza o algoritmobackpropagation para gerar o gradiente da função custo em relação aos parâ-metros da rede.

Fonte: Do Autor.


δ20 =

{y − y , caso z2

0 > 00 , caso contrário

δ1i =

{ω2

1i · δ20 , caso z1

i−1 > 00 , caso contrário∂E

∂ω2ik

= δ20 · a1

k−1

∂E

∂ω1ik

= δ1i−1 · a0

k−1

∂E

∂bli= δli

(3.2)

3.4.10 Otimiza pesos

Como mencionado, a otimização dos pesos segue o método MBSGDonde a atualização ocorre após a geração do gradiente de um batch com-pleto. Tomando como entrada o gradiente do blocoCalcula gradientee os parâmetros da taxa de aprendizagem e momento, a equação 2.22é implementada.

As figuras 3.25 e 3.26 ilustram o circuito responsável pela atualiza-ção dos parâmetros e a FSM de controle. Primeiramente atualiza-se ospesos e após os bias. O valor anterior de cada parâmetro e a variaçãoentre parâmetros é então lido e em seguida o bloco realiza a atualizaçãoregistrando os novos valores de parâmetro e variação.


Figura 3.25: Circuito responsável pela atualização de parâmetros seguindo aequação apresentada em 2.22

Fonte: Do Autor.

Figura 3.26: FSM que controla o circuito responsável pela atualização deparâmetros. Os sinais omegaDone e bDone representam flags dos contadoresindicando que o contador de pesos (no caso de omegaDone) e o contador debias (no caso de bDone) atingiram os valores máximos.

Fonte: Do Autor.

CAPÍTULO 4

Resultados

Neste capítulo os resultados obtidos nas três etapas são apresenta-dos e os valores são comparados e discutidos. Para a etapa em Python,duas configurações de hiper parâmetros são utilizadas e exibe-se os grá-ficos da evolução da funções custo por época e o gráfico de separaçãodas classes do conjunto de teste. Na etapa em MatLab, as mesmasconfigurações de hiper parâmetros são utilizadas, gerando e exibindoo gráfico das funções custo. Os valores devem ser proporcionais aosobtidos com Python mas não iguais devido ao erro de quantização ine-rente do processamento com aritmética de ponto fixo. Para MatLab,apresenta-se ainda a comparação entre as diferentes resoluções que re-sulta na escolha da representação com Q7.16. Na etapa de Verilogexibe-se o consumo de hardware para o sistema treinador e o gráficoda função custo por épocas para a segunda configuração de hiper pa-râmetros gerado pelo simulador ModelSim e salvo em um arquivo paraser lido pelo MatLab, de modo a comparar as curvas produzidas noMatLab e no ModelSim para atestar a igualdade entre os dois. Ao finalé exibido as acurácias das classificações, para as duas configurações dehiper parâmetros, do conjunto de treinamento, teste e validação emPython, MatLab e Verilog.

67

68 CAPÍTULO 4. RESULTADOS

4.1 Python

Para geração dos gráficos utilizou-se a biblioteca Matplotlib, espe-cializada na geração de gráficos bidimensionais. As figuras 4.1 e 4.2exibem a função custo por épocas e os hiperplanos de separação cria-dos respectivamente para a primeira configuração de hiper parâmetros.A taxa de aprendizagem utilizada tem valor 0.05, o momento 0.9 e onúmero de amostras de cada batch é 256.

Figura 4.1: Curva da função custo por épocas gerado em Python para a rede2:5:1 com arquitetura MLP e hiper parâmetros η = 0.05 e α = 0.9 com cadabatch com 256 amostras.

Fonte: Do Autor.

As figuras 4.3 e 4.4 exibem a função custo por épocas e os hiperpla-nos de separação criados respectivamente para a segunda configuraçãode hiper parâmetros. A taxa de aprendizagem utilizada tem valor 0.5,o momento 0.1 e o número de amostras de cada batch é 1024.

4.2 MatLab

O MatLab possui uma série de funções internas para gerar gráficos.Utilizando as mesmas configurações de hiper parâmetros e tamanho debatch são geradas as curvas da função custo. A figura 4.5 exibe o gráfico

4.3. VERILOG 69

Figura 4.2: Hiperplanos criados para separar as duas classes do dataset. Rede2:5:1 com arquitetura MLP e hiper parâmetros η = 0.05 e α = 0.9 com cadabatch com 256 amostras.

Fonte: Do Autor.

da função perda produzida com o programa treinador em MatLab paraa primeira configuração utilizada como η = 0.05 e α = 0.9 com tamanhodos batchs de 256 amostras. A figura 4.6 também exibe a função customas para a segunda configuração utilizada com η = 0.5, α = 0.1 etamanho dos batchs de 1024 amostras.

A comparação entre as resoluções é apresentada na figura 4.7. Nela,exibe-se as funções custo por época geradas pelo programa em MatLabpara as resoluções Q7.16, Q7.32 e Q7.48 e gerada pela rede em Pythoncom ponto flutuante.

4.3 Verilog

A síntese do sistema treinador é realizado na ferramenta Quartus[43] e as simulações no ModelSim [44]. A tabela 4.1 exibe o consumode hardware do sistema treinador. A figura 4.8 exibe a função custo dasegunda configuração de hiper parâmetros produzida no ModelSim eregistrada como arquivo e gerado pelo programa treinador no MatLab.


Figura 4.3: Curva da função custo por épocas gerado em Python para a rede2:5:1 com arquitetura MLP e hiper parâmetros η = 0.5 e α = 0.1 com cadabatch com 1024 amostras.

Fonte: Do Autor.

4.4 Conclusões acerca dos resultados

A Tabela 4.2 exibe as acurácias das classificações dos conjuntos detreinamento, teste e validação para o dataset previamente apresentadona Figura 3.3 para as etapas de Python, MatLab e Verilog. As acuráciasexibidas correspondem as configurações de hiper parâmetros utilizadosem cada etapa, ou seja, para Python são exibidas as acurácias das duasconfigurações, para MatLab da primeira e para Verilog da segunda.

Como pode ser observado, as acurácias obtidas com os pesos treina-dos com aritmética de ponto fixo (MatLab e Verilog) ficam um poucoabaixo da acurácia obtida com ponto flutuante, esse fato é consequênciado erro de quantização. As diferenças entre as acurácias são pequenas,o que valida o treinamento da rede realizado em MatLab e Verilog.

4.4. CONCLUSÕES ACERCA DOS RESULTADOS 71

Tabela 4.1: Consumo de hardware gerado pelo simulation report do Quartuspara o sistema treinador.

Família Cyclone V EDispositivo 5CSEMA5F31C6ElementosLógicos

(em ALMs)3014/32070 (9%)

No total deregistradores

2570

No total de bitsde memória

911.577/4.065.280 (22%)

Fonte: Do Autor.

Tabela 4.2: Comparação entre as acurácias obtidas para os conjuntos detreinamento, teste e validação para as etapas do desenvolvimento.

ConjuntosTreinamento Teste Validação

Python 98,23% 97,91% 97,87%Config. 1MatLab 97,75% 97,72% 98,68%Python 98,22% 97,87% 98,19%Config. 2Verilog 97,73% 97,54% 98,79%

Fonte: Do Autor.


Figura 4.4: Hiperplanos criados para separar as duas classes do dataset. Rede2:5:1 com arquitetura MLP e hiper parâmetros η = 0.5 e α = 0.1 com cadabatch com 1024 amostras.

Fonte: Do Autor.

Figura 4.5: Curva da função custo produzida no programa em MatLab comaritmética de ponto fixo para a configuração de hiper parâmetros η = 0.05 eα = 0.9 com tamanho de batch de 256 amostras.

Fonte: Do Autor.

4.4. CONCLUSÕES ACERCA DOS RESULTADOS 73

Figura 4.6: Curva da função custo produzida no programa em MatLab comaritmética de ponto fixo para a configuração de hiper parâmetros η = 0.5 eα = 0.1 com tamanho de batch de 1024 amostras.

Fonte: Do Autor.

Figura 4.7: Comparação das funções custo de Python e MatLab com diferen-tes precisões. O erro da resolução Q7.16 apesar de ser o maior apresentadoainda assim é um valor pequeno e que não terá um consumo de hardware tãomassivo quanto as outras representações.

(a) Curvas de aprendizado. (b) Zoom da figura 4.7a.

Fonte: Do Autor.


Figura 4.8: Gráfico das funções custo produzidas no MatLab e no ModelSimpara os hiper parâmetros η = 0.5 e α = 0.1 com cada batch com 1024amostras.

Fonte: Do Autor.

CAPÍTULO 5

Conclusão

O mercado de aplicações com redes neurais tem tido uma vastaevolução na ultima década e espera-se um crescimento ainda maior nospróximos anos [45]. O treinamento das redes é uma etapa lenta e quedemanda um processamento computacional elevado dependendo do ta-manho da rede, em geral realizado em estações remotas por GPUs. Parao caso de redes implementadas diretamente em hardware, as HNNs, otreinamento on chip das redes traz vantagens em termos de velocidade,pois não necessita da etapa de comunicação com a estação remota.Para sistemas que necessitem se adaptar a novos dados após um certoperíodo de tempo, como um sistema de predição de ações [46], os pa-râmetros da rede demandam atualização constante para elevar a acu-rácia dos resultados. Nesse contexto, a utilização de um FPGA pararealizar o treinamento traz vantagens no quesito consumo de potênciavisto que, quando comparados a outros dispositivos como micropro-cessadores, GPUs e Digital Signal Processors, apresenta um baixíssimoconsumo energético [30]. Com essas considerações em mente propôs-seum projeto capaz de treinar on chip utilizando FPGA.

Este trabalho apresentou o desenvolvimento de um sistema capazde realizar o treinamento de redes neurais com arquitetura MLP utili-

75

76 CAPÍTULO 5. CONCLUSÃO

zando o algoritmo Mini-Batch Stocasthic Gradient Descent em FPGAcom Verilog. Inicialmente, desenvolveu-se as redes e o treinamento emPython através da biblioteca especializa em aprendizada de máquinaSickit-learn. Em seguida, utilizando representação em ponto-fixo paraarmazenar e processar dados, o treinamento foi realizado em MatLabcriando todas as funções utilizadas na etapa de Python. Finalmente,implementou-se na HDL Verilog o sistema treinador com resolução fixasigned Q7.16, traduzindo as implementações de MatLab para descriçãode hardware.

Como se comprova através da evolução da função custo através dasépocas nas Figuras 4.3 e 4.6, o treinamento em MatLab é similar, masnão igual, ao realizado em Python com o mesmo conjunto de treina-mento e hiper parâmetros. O fato de não ser igual vem do erro dequantização inerente da representação em ponto fixo. Outro fator desimilaridade entre os treinamentos é a Tabela 4.2 que ilustra a proximi-dade entre as acurácias obtidas nas etapas de Python e MatLab paraa primeira configuração de hiper parâmetros. Esses fatos comprovamo funcionamento do treinamento realizado em MatLab com aritméticade ponto fixo.

Já a Figura 4.8, que ilustra as evoluções das funções custo de Ma-tLab e Verilog sobrepostas, comprova a igualdade entre os treinamentospara a mesma resolução de dados e hiper parâmetros. Novamente a Ta-bela 4.2 mostra um erro pequeno entre as acurácias obtidas com Pythone Verilog. Esses fatos validam o funcionamento do sistema treinadorimplementado em Verilog.

Referências bibliográficas

[1] R. Hasan, T. M. Taha, and C. Yakopcic. On-chip training ofmemristor based deep neural networks. In 2017 International JointConference on Neural Networks (IJCNN), pages 3527–3534, May2017.

[2] Mariusz Bojarski, Davide Del Testa, Daniel Dworakowski, Ber-nhard Firner, Beat Flepp, Prasoon Goyal, Lawrence D. Jackel,Mathew Monfort, Urs Muller, Jiakai Zhang, Xin Zhang, JakeZhao, and Karol Zieba. End to end learning for self-driving cars.CoRR, abs/1604.07316, 2016.

[3] S. Ravuri and A. Stoicke. A comparative study of neural networkmodels for lexical intent classification. In 2015 IEEE Workshop onAutomatic Speech Recognition and Understanding (ASRU), pages368–374, Dec 2015.

[4] T. Gao, Y. Chai, and Y. Liu. Applying long short term momoryneural networks for predicting stock closing price. In 2017 8thIEEE International Conference on Software Engineering and Ser-vice Science (ICSESS), pages 575–578, Nov 2017.

[5] J. Liu, J. Guo, P. Orlik, M. Shibata, D. Nakahara, S. Mii, andM. Takáč. Anomaly detection in manufacturing systems using

77

78 REFERÊNCIAS BIBLIOGRÁFICAS

structured neural networks. In 2018 13th World Congress on In-telligent Control and Automation (WCICA), pages 175–180, July2018.

[6] D. Strigl, K. Kofler, and S. Podlipnig. Performance and scala-bility of gpu-based convolutional neural networks. In 2010 18thEuromicro Conference on Parallel, Distributed and Network-basedProcessing, pages 317–324, Feb 2010.

[7] A. M. Turing. Computing machinery and intelligence. Mind,59(236):433–460, 1950.

[8] B. Widrow and M. A. Lehr. 30 years of adaptive neural networks:perceptron, madaline, and backpropagation. Proceedings of theIEEE, 78(9):1415–1442, Sep. 1990.

[9] R. Lippmann. An introduction to computing with neural nets.IEEE ASSP Magazine, 4(2):4–22, Apr 1987.

[10] Warren S. McCulloch and Walter Pitts. A logical calculus of theideas immanent in nervous activity. The bulletin of mathematicalbiophysics, 5(4):115–133, Dec 1943.

[11] D.O. Hebb. The Organization of Behavior: A NeuropsychologicalTheory. A Wiley book in clinical psychology. Wiley, 1949.

[12] F. Rosenblatt. Perceptron simulation experiments. Proceedings ofthe IRE, 48(3):301–309, March 1960.

[13] IBM. 704 data processing system. IBM Archives.

[14] John C. Hay, Ben E. Lynch, and David R. Smith. Mark i per-ceptron operators’ manual (project para). Report from CornellAeronautical Laboratory.

[15] Bernard Widrow. An adaptive "adaline"neuron using chemical"memistors". Report from Stanford Electronics Laboratories.

[16] Marvin Minsky and Seymour Papert. Perceptrons: An Introduc-tion to Computational Geometry. MIT Press, Cambridge, MA,USA, 1969.

REFERÊNCIAS BIBLIOGRÁFICAS 79

[17] P. J. Werbos. Beyond Regression: New Tools for Prediction andAnalysis in the Behavioral Sciences. PhD thesis, Harvard Univer-sity, 1974.

[18] David E. Rumelhart, Geoffrey E. Hinton, and Ronald J. Willi-ams. Learning representations by back-propagating errors. Nature,323:533–, October 1986.

[19] Janardan Misra and Indranil Saha. Artificial neural networks inhardware: A survey of two decades of progress. Neurocomputing,74:239–255, 12 2010.

[20] Ian Goodfellow, Yoshua Bengio, and Aaron Courville. Deep Lear-ning. The MIT Press, 2016.

[21] Forest Agostinelli, Matthew Hoffman, Peter Sadowski, and Pi-erre Baldi. Learning activation functions to improve deep neuralnetworks. 12 2014.

[22] Fei-Fei Li, Andrej Karpathy, and Justin Johnson. Cs231n: Con-volutional neural networks for visual recognition 2016.

[23] Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Ima-genet classification with deep convolutional neural networks. InF. Pereira, C. J. C. Burges, L. Bottou, and K. Q. Weinberger,editors, Advances in Neural Information Processing Systems 25,pages 1097–1105. Curran Associates, Inc., 2012.

[24] Lu Lu, Yeonjong Shin, Yanhui Su, and George Karniadakis. Dyingrelu and initialization: Theory and numerical examples, 03 2019.

[25] S. B. Kotsiantis. Supervised machine learning: A review of classifi-cation techniques. In Proceedings of the 2007 Conference on Emer-ging Artificial Intelligence Applications in Computer Engineering:Real Word AI Systems with Applications in eHealth, HCI, Infor-mation Retrieval and Pervasive Technologies, pages 3–24, Amster-dam, The Netherlands, The Netherlands, 2007. IOS Press.

[26] Brian D. Ripley and N. L. Hjort. Pattern Recognition and NeuralNetworks. Cambridge University Press, New York, NY, USA, 1stedition, 1995.

80 REFERÊNCIAS BIBLIOGRÁFICAS

[27] Ines Domingues, Erika Sales, and Wagner Pereira. Investigati-ons on impact of feature normalization techniques on classifier’sperformance in breast tumor classification. 01 2012.

[28] Thomas M. Mitchell. Machine Learning. McGraw-Hill, Inc., NewYork, NY, USA, 1 edition, 1997.

[29] Imad Dabbura. Gradient descent algorithm and its variants.https://imaddabbura.github.io/post/gradient_descent_algorithms/. Accessado em: 15 de julho de 2019.

[30] Justin Rajewski. Learning FPGAs: Digital Design for Beginnerswith Mojo and Lucid HDL. O’Reilly Media, Inc., 1st edition, 2017.

[31] Clive Maxfield. The Design Warrior’s Guide to FPGAs: Devices,Tools and Flows. Newnes, Newton, MA, USA, 1st edition, 2004.

[32] Xavier Glorot and Yoshua Bengio. Understanding the difficulty oftraining deep feedforward neural networks. In In Proceedings of theInternational Conference on Artificial Intelligence and Statistics(AISTATS’10). Society for Artificial Intelligence and Statistics,2010.

[33] F. Pedregosa, G. Varoquaux, A. Gramfort, V. Michel, B. Thirion,O. Grisel, M. Blondel, P. Prettenhofer, R. Weiss, V. Dubourg,J. Vanderplas, A. Passos, D. Cournapeau, M. Brucher, M. Per-rot, and E. Duchesnay. Scikit-learn: Machine learning in Python.Journal of Machine Learning Research, 12:2825–2830, 2011.

[34] Scikit-learn. Who is using scikit-learn? https://scikit-learn.org/stable/testimonials/testimonials.html. Accessado em:06 de julho de 2019.

[35] Scikit-learn. Neural network models (supervised). https://scikit-learn.org/stable/modules/neural_networks_supervised.html#neural-networks-supervised. Accessadoem: 06 de julho de 2019.

[36] Scikit-learn. Neural network models (unsupervised). https://scikit-learn.org/stable/modules/neural_networks_unsupervised.html#neural-networks-unsupervised. Acces-sado em: 06 de julho de 2019.

https://imaddabbura.github.io/post/gradient_descent_algorithms/

https://imaddabbura.github.io/post/gradient_descent_algorithms/

https://scikit-learn.org/stable/testimonials/testimonials.html

https://scikit-learn.org/stable/testimonials/testimonials.html

https://scikit-learn.org/stable/modules/neural_networks_supervised.html#neural-networks-supervised



https://scikit-learn.org/stable/modules/neural_networks_unsupervised.html#neural-networks-unsupervised



REFERÊNCIAS BIBLIOGRÁFICAS 81

[37] R. A. Fisher. The use of multiple measurements in taxonomicproblems. Annals of Eugenics, 7(7):179–188, 1936.

[38] David A. Belsley, Edwin Kuh, and Roy E Welsch. Regression di-agnostics : identifying influential data and sources of collinearity.Wiley New York, 1980.

[39] Gary B. Huang, Manu Ramesh, Tamara Berg, and Erik Learned-miller. Labeled faces in the wild: A database for studying facerecognition in unconstrained environments.

[40] D. D. Lewis, Y. Yang, T. G. Rose, and F. Li. Rcv1: A newbenchmark collection for text categorization research. Journal ofMachine Learning Research, 5(Apr):361–397, 2004.

[41] Scikit-learn. Dataset loading utilities. https://scikit-learn.org/stable/datasets/index.html#datasets. Accessado em: 06de julho de 2019.

[42] Scikit-learn. sklearn.datasets.make_classification. https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_classification.html#sklearn.datasets.make_classification. Accessado em: 06 de julho de 2019.

[43] Intel. Intel quartus prime standard edition user guide.https://www.intel.com/content/dam/www/programmable/us/en/pdfs/literature/ug/ug-qps-getting-started.pdf.Accessado em: 15 de julho de 2019.

[44] Mentor. Intel quartus prime standard edition userguide. https://www.mentor.com/company/higher_ed/modelsim-student-edition. Accessado em: 15 de julho de2019.

[45] Michael Spencer. Artificial intelligence hype is real. CognitiveWorld - Forbes.

[46] Daniel Gomes Soares and Rodrigo de Moraes. Previsão do Ín-dice sp 500 da bolsa de valores através de redes neurais artificiaismulticamadas. 05 2018.

https://scikit-learn.org/stable/datasets/index.html#datasets

https://scikit-learn.org/stable/datasets/index.html#datasets

https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_classification.html#sklearn.datasets.make_classification




https://www.intel.com/content/dam/www/programmable/us/en/pdfs/literature/ug/ug-qps-getting-started.pdf

https://www.intel.com/content/dam/www/programmable/us/en/pdfs/literature/ug/ug-qps-getting-started.pdf

https://www.mentor.com/company/higher_ed/modelsim-student-edition

https://www.mentor.com/company/higher_ed/modelsim-student-edition

treinamento de redes neurais com arquitetura multilayer

Documents