Classificador LVQ configurável em FPGA

Transcrição

Centro Universitário Positivo - UnicenP
Núcleo de Ciências Exatas e Tecnológicas – NCET
Engenharia da Computação
Valéria Arcie Polli
Curitiba
2005
Centro Universitário Positivo - UnicenP
Núcleo de Ciências Exatas e Tecnológicas – NCET
Engenharia da Computação
Monografia apresentada à disciplina de
Projeto Final, como requisito parcial à
conclusão do Curso de Engenharia da
Computação. Orientador: Prof. Valfredo
Pilla Jr.
Curitiba
2005
ii
Termo de Aprovação
Monografia aprovada como requisito parcial à conclusão do curso de
Engenharia da Computação do Centro Universitário Positivo, pela seguinte banca
examinadora:
Prof. Valfredo Pilla Jr. (orientador)
Prof. Edson Pedro Ferlin
Prof. Maurício Perretto
Curitiba, 12 de dezembro de 2005
iii
Agradecimentos
Primeiramente, agradeço a Deus que me proporcionou a oportunidade de
chegar até aqui, realizar este projeto e concluir mais uma etapa na minha vida.
Aos meus pais, José Wierzba Polli e Irene Maria Arcie Polli, pelo esforço que
fizeram para que hoje eu pudesse estar concluindo este curso de graduação e
principalmente pelo amor, valores e o apoio em todos os momentos dessa
caminhada.
Aos meus avós, Alécio Arcie e Rosária Arcie, que em todos os momentos de
dificuldade me mostraram que sem luta não há conquista.
Às minhas irmãs Marilise, Bruna e Josirene que sempre acreditaram no meu
trabalho e as agradeço por terem agüentado meu mau humor e stress durante todo
o curso.
Ao meu namorado Rodrigo Villaverde Cendon, que nunca me deixou desistir,
pelo seu apoio, carinho e paciência.
Ao meu orientador professor e amigo Valfredo Pilla Jr, pela idéia do projeto, por
acreditar e sempre estar disposto a ajudar, não apenas nesse projeto, mas em
outras pesquisas acadêmicas. Agradeço também ao professor José Carlos da
Cunha que sempre me incentivou.
E aos professores do curso de Engenharia da Computação da UnicenP,
responsáveis diretos pela minha formação profissional.
iv
Sumário
Lista de Figuras ..................................................................................................... viii
Lista de Tabelas....................................................................................................... xi
Lista de Siglas ........................................................................................................ xii
Lista de Símbolos.................................................................................................. xiii
Resumo .................................................................................................................. xiv
Abstract ................................................................................................................... xv
1
INTRODUÇÃO ..................................................................................................... 1
2
REVISÃO BIBLIOGRÁFICA ................................................................................. 3
2.1
FPGA ............................................................................................................. 3
2.1.1
Arquitetura da família Cyclone.................................................................. 4
2.1.2
Placa de desenvolvimento Nios.............................................................. 11
2.2
REDES NEURAIS............................................................................................. 15
2.2.1
Histórico.................................................................................................. 15
2.2.2
Neurônio Biológico.................................................................................. 16
2.2.3
Neurônio Modelado ................................................................................ 18
2.2.4
Arquiteturas de RNAs ............................................................................. 18
2.2.5
Aprendizado ........................................................................................... 20
2.2.5.1
Aprendizado Supervisionado ............................................................ 20
2.2.5.2
Aprendizado Não-supervisionado..................................................... 21
2.2.6
Algoritmo de treinamento para Retropropagação (Back-propagation).... 21
2.2.7
SOM (Self-Organizing Maps).................................................................. 22
2.3
CLASSIFICADOR LVQ ..................................................................................... 23
2.3.1
A Classificação LVQ ............................................................................... 24
2.3.2
LVQ1 ...................................................................................................... 24
2.3.3
LVQ2 ...................................................................................................... 25
2.3.4
LVQ3 ...................................................................................................... 26
2.3.5
Diferenças entre LVQ1, LVQ2 e LVQ3 ................................................... 26
2.3.6
Classificador LVQ ................................................................................... 26
2.3.7
Porque usar LVQ .................................................................................... 27
2.4
INTERFACE USB ............................................................................................ 27
v
3
ESPECIFICAÇÃO TÉCNICA.............................................................................. 31
3.1
ESPECIFICAÇÃO DE HARDWARE ....................................................................... 32
3.1.1
3.1.1.1
Configuração via interface JTAG ...................................................... 32
3.1.1.2
Configuração via interface USB........................................................ 32
3.1.2
3.2
ESPECIFICAÇÃO DE SOFTWARE ....................................................................... 35
Treinamento da RNA no MatLab ............................................................ 35
3.2.2
Software de configuração da rede LVQ.................................................. 36
3.2.3
Firmware................................................................................................. 36
ESPECIFICAÇÃO DE VALIDAÇÃO ....................................................................... 37
3.3.1
Validação de Hardware .......................................................................... 37
3.3.2
Validação de Software............................................................................ 37
3.4
INFRA-ESTRUTURA.......................................................................................... 37
3.5
ESTUDO DE VIABILIDADE TÉCNICO-ECONÔMICA ................................................ 38
3.6
CRONOGRAMA ............................................................................................... 38
PROJETO........................................................................................................... 41
4.1
REQUISITOS MÍNIMOS PARA FUNCIONAMENTO ................................................... 41
4.2
PROJETO DE HARDWARE ................................................................................ 41
4.3
PROJETO DE SOFTWARE ................................................................................. 44
4.3.1
Software de Comunicação...................................................................... 44
4.3.2
Treinamento do Classificador LVQ no MatLab ....................................... 45
4.3.3
Firmware................................................................................................. 46
4.4
5
Módulo de comunicação......................................................................... 33
3.2.1
3.3
4
Módulo FPGA ......................................................................................... 32
PROCEDIMENTOS DE TESTES E VALIDAÇÃO DO PROJETO .................................... 51
4.4.1
Procedimentos de teste do módulo de comunicação ............................. 51
4.4.2
Procedimentos de teste da comunicação entre PC e FPGA .................. 51
4.4.3
Procedimentos de teste para validação da rede LVQ na FPGA............. 52
RESULTADOS ................................................................................................... 53
5.1
COMUNICAÇÃO USB → µC............................................................................. 53
5.2
COMUNICAÇÃO PC → FPGA .......................................................................... 53
5.3
TREINO NO MATLAB ....................................................................................... 54
5.4
SOFTWARE .................................................................................................... 57
5.5
CLASSIFICADOR LVQ EM HARDWARE ............................................................... 57
vi
6
CONCLUSÃO..................................................................................................... 64
7
REFERÊNCIAS .................................................................................................. 65
Anexo 1 – Diagramas esquemáticos ........................................................... 67
Anexo 2 – Layout das placas ....................................................................... 71
Anexo 3 – Diagramas de software ............................................................... 73
Anexo 4 – Telas do software ....................................................................... 77
Anexo 5 – Artigo .......................................................................................... 81
Anexo 6 – Manual Técnico .......................................................................... 82
Anexo 7 – Manual do Usuário...................................................................... 83
vii
LISTA DE FIGURAS
Figura 1 - Diagrama em blocos da família Cyclone. ................................................... 4
Figura 2 - Estrutura do LABs do Cyclone. .................................................................. 5
Figura 3 - Sinais de controle dos LABs. ..................................................................... 5
Figura 4 - LE do Cyclone. ........................................................................................... 6
Figura 5 - LE em modo normal. .................................................................................. 7
Figura 6 - LE em modo aritmético dinâmico. .............................................................. 8
Figura 7 - Conexões de Interconnect. ........................................................................ 8
Figura 8 - Sinais de controle do bloco M4K RAM. ...................................................... 9
Figura 9 - Relação de linhas do LAB com bloco de M4K RAM................................... 9
Figura 10 - Geração do clock global......................................................................... 10
Figura 11 - Diagrama em blocos da placa de desenvolvimento Nios. ...................... 11
Figura 12 - Conector de expansão 1. ....................................................................... 12
Figura 13 - Conector de expansão 2. ....................................................................... 12
Figura 14 – Disposição dos componentes da placa de desenvolvimento Nios
[ALTERA, 2004].................................................................................................. 13
Figura 15 - Display 7 segmentos da placa de desenvolvimento do Nios.................. 14
Figura 16 - Disposição dos push-buttons e LEDs na placa. ..................................... 14
Figura 17 - Representação gráfica do XOR.............................................................. 16
Figura 18 - Componentes do neurônio biológico. ..................................................... 17
Figura 19 - Potencial de ação em um neurônio. ....................................................... 17
Figura 20 - Neurônio de McCulloch e Pitts. .............................................................. 18
Figura 21 - Exemplos de arquiteturas de RNAs. ...................................................... 19
Figura 22 - Aprendizagem Supervisionado............................................................... 20
Figura 23 - Aprendizado Não-supervisionado. ......................................................... 21
Figura 24 - Perceptron de múltiplas camadas. ......................................................... 21
Figura 25 - Exemplo de mapeamento usando SOM................................................. 22
Figura 26 - Arquitetura da Rede LVQ. ...................................................................... 23
Figura 27 - Conectores utilizados pela USB. ............................................................ 28
Figura 28 - Formatos dos pacotes do protocolo USB............................................... 30
Figura 29 - Diagrama em Blocos do sistema............................................................ 31
Figura 30 – Algoritmo de classificação da rede LVQ................................................ 33
Figura 31 - Módulo de comunicação. ....................................................................... 33
viii
Figura 32 - Fluxograma do firmware do µC. ............................................................. 34
Figura 33 - Diagrama em blocos da utilização do TUSB. ......................................... 34
Figura 34 - Fluxograma do treinamento da rede LVQ no MatLab. ........................... 35
Figura 35 - Fluxograma da execução do μC. ........................................................... 36
Figura 36 - Cronograma do Projeto (parte I)............................................................. 39
Figura 37 - Cronograma do Projeto (parte II)............................................................ 40
Figura 38 - Divisão dos módulos de hardware. ........................................................ 41
Figura 39 - Algoritmo de treino do classificador LVQ. .............................................. 46
Figura 40 - Fluxograma de processamento do µC. .................................................. 47
Figura 41 - Diagrama de estados da rede neural LVQ. ............................................ 47
Figura 42 - Diagrama em blocos da rede no FPGA.................................................. 48
Figura 43 - Diagrama de estados da leitura dos resultados da classificação. .......... 49
Figura 44 - Diagrama de estados de recepção e controle da execução................... 50
Figura 45 - Teste de envio de dado para a FPGA. .................................................. 52
Figura 46 - Sinal gerado pelo µC para a FPGA. ....................................................... 53
Figura 47 - Dado transmitido para a FPGA. ............................................................. 54
Figura 48 - Dado de teste da FPGA. ........................................................................ 54
Figura 49 - Resultado do treino com coeficiente de aprendizagem igual a 0,01. ..... 55
Figura 50 - Resultado do treino com coeficiente de aprendizagem igual a 0,1. ....... 55
Figura 51 - Resultado do treino com coeficiente de aprendizagem igual a 0,5. ....... 56
Figura 52 - Resultado do treino com coeficiente de aprendizagem igual a 1. .......... 56
Figura 53 - Dados enviados para a FPGA................................................................ 57
Figura 54 - Processo de recepção dos dados. ......................................................... 59
Figura 55 - Fases do processo de classificação....................................................... 60
Figura 56 - Total do chip utilizado............................................................................. 61
Figura 57 - Uso de memória (número de dimensões x número de classes – 3D). ... 62
Figura 58 – Uso de memória (número de dimensões x número de classes)............ 62
Figura 59 - Número máximo de dados para análise (3D). ........................................ 63
Figura 60 - Número máximo de dados para análise................................................. 63
Figura 61 - Diagrama esquemático do µC................................................................ 68
Figura 62 - Diagrama esquemático do conversor USB / Serial. ............................... 69
Figura 63 - Diagrama esquemático do módulo da FPGA. ........................................ 70
Figura 64 - Layout da placa do µC. .......................................................................... 72
Figura 65 - Layout da placa do TUSB. ..................................................................... 72
Figura 66 - Diagrama de caso de uso. ..................................................................... 74
ix
Figura 67 - Diagrama de seqüência cadastrar dados de entrada............................. 74
Figura 68 - Diagrama de seqüência configurar parâmetros da rede. ....................... 74
Figura 69 - Diagrama de seqüência comunicar com FPGA. .................................... 75
Figura 70 - Modelo Relacional.................................................................................. 75
Figura 71 - Diagrama de classes.............................................................................. 76
Figura 72 - Tela de cadastro de dados de entrada da rede...................................... 78
Figura 73 - Tela de cadastro de dados de configuração da rede LVQ. .................... 78
Figura 74 - Tela principal do software. ..................................................................... 79
Figura 75 - Tela de dados de envio para a FPGA. ................................................... 80
x
LISTA DE TABELAS
Tabela 1 - Recursos do dispositivo (adaptado de Cyclone Device Handbook). ......... 3
Tabela 2 - Padrões de E/S do Cyclone. ................................................................... 11
Tabela 3 - Pinagem dos push-buttons da placa de desenvolvimento Nios. ............. 14
Tabela 4 - Pinagem dos LEDs da placa de desenvolvimento Nios. ......................... 14
Tabela 5 - Pinos da interface USB ........................................................................... 28
Tabela 6 - Ambientes e ferramentas de desenvolvimento........................................ 37
Tabela 7 - Linguagem de programação.................................................................... 37
Tabela 8 - Tabela de custos. .................................................................................... 38
Tabela 9 – Eventos do Projeto Final......................................................................... 38
Tabela 10 - Sinais da comunicação com porta USB. ............................................... 42
Tabela 11 - Pinos utilizados do µC. .......................................................................... 42
Tabela 12 - Sinais da comunicação com µC. ........................................................... 42
Tabela 13 - Sinais da comunicação µC e FPGA. ..................................................... 43
Tabela 14 - Pinos utilizados no FPGA...................................................................... 43
Tabela 15 - Componentes utilizados. ....................................................................... 44
Tabela 16 – Seqüência de dados esperado pelo teste da comunicação.................. 51
Tabela 17 - Resultado esperado no teste da rede em hardware.............................. 52
xi
LISTA DE SIGLAS
CISC
-
Complex Instruction Set Computers
CMOS
-
Complementary Metal Oxide Semi-Conductor
EAB
-
Embedded Array Block
E/S
-
Entrada/Saída
FPGA
-
Field-Programmable Gate Array
FIFO
-
First-In First-Out
ICMC
-
Instituto de Ciências Matemáticas e de Computação
JTAG
-
Joint Test Action Group
LAB
-
Logic Array Block
LE
-
Logic Element
LUT
-
Look-up-table
LVDS
-
Low Voltage Differential Signal
LVTTL
-
Low Voltage Transistor Transistor Level
LVQ
-
Learning Vector Quantization
MLP
-
Multilayer Perceptron
NCET
-
Núcleo de Ciências Exatas e Tecnológicas
NRZI
-
Non Return to Zero Invert
PC
-
Personal Computer
PCI
-
Peripheral Component Interconnect
RAM
-
Randomic Acess Memory
RN
-
Redes Neurais
RNA
-
Redes Neurais Artificiais
ROM
-
Read-only Memory
SRAM
-
Static Randomic Acess Memory
TTL
-
Transistor-transistor Logic
USB
-
Universal Serial Bus
USP
-
Universidade de São Paulo
VHDL
-
Very
high
speed
integrated
Language
xii
circuits
Hardware
Descripton
LISTA DE SÍMBOLOS
µ
-
micro
µC
-
microcontrolador
Hz
-
Hertz
MHz
-
Mega Hertz
V
-
Volts
xiii
RESUMO
Com o avanço tecnológico dos dispositivos reconfiguráveis, principalmente as
FPGAs, a realização de updates em hardware foi extremamente facilitada. Desta
maneira não há a necessidade de intervenção física facilitando, principalmente, o
trabalho de projetistas.
Como a computação reconfigurável se mostra bastante dinâmica em projetos,
surgiu a idéia de criar uma arquitetura em hardware capaz de executar uma rede
neural configurável. Para isso a rede LVQ foi selecionada. É uma rede que exige
cálculos matemáticos simples (arquitetura baseada em cálculo de distância
euclidiana), facilitando o desenvolvimento da arquitetura.
Com essas características de reconfigurabilidade do hardware, desenvolveu-se
uma rede neural e a arquitetura permite sua configuração de acordo com os dados a
serem classificados para cada problema especifico.
O objetivo deste projeto é a implementação da rede, comprovando seu
funcionamento, para que futuramente possa ser aplicada a varias áreas, tais como
automação, biomédica, processamento de imagens, processamento de voz, entre
outros.
Os resultados encontrados neste projeto mostram que é eficiente a aplicação
de reconhecimento de padrões em dispositivos como as FPGAs. Foi possível
comprovar o funcionamento e buscar aplicações com maior complexidade.
Palavras-chave:
FPGA,
Lógica
Reconhecimento de Padrões.
xiv
Programável,
Rede
Neural
LVQ,
ABSTRACT
With the technological advance of reconfigurable devices, especially FPGAs,
the accomplishment of hardware updates was extremely facilitated. This way isn't
necessary physical intervention facilitating the work of designers.
With the dynamism of reconfigurable computing, the idea was develop an
architecture in hardware capable to execute a neural net. For this pourpose the LVQ
training method was selected. This net demands simple mathematical calculations
(Euclidean distance based architecture), facilitating the development of the
architecture.
With these reconfigurable characteristics of the hardware, a neural net in
programmable logic was developed enabling its configuration for the data that need
to be classified.
The objective of this project is the implementation of the net, proving
itsfunctioning, so that in future can be applied in different areas, such as automation,
biomedical, image processing, voice recognition, and others.
The results found in this project shows that the application of standards
recognition in FPGAs is very efficient. It was possible to prove the functioning and to
search applications with bigger complexity.
Keywords:
Recognition.
FPGA,
Programmable
xv
Logic,
LVQ
neural
network,
Pattern
1
1 INTRODUÇÃO
A computação reconfigurável vem sendo utilizada em larga escala para projetos
de hardware que necessitem de um grande poder de processamento. Neste campo um
dispositivo muito utilizado é a FPGA (Field-Programmable Gate Array).
As FPGAs são circuitos de hardware que podem ser modificados praticamente
em qualquer momento durante o uso. As FPGAs consistem em array de blocos lógicos
configuráveis, que implementam funções lógicas AND, NAND, OR, NOR e XOR [USP,
2005].
Existem processadores de uso geral, que executam várias funções. Em alguns
casos, este excesso de funções torna o processamento muito lento. Para isso, existem
hardwares que podem ser desenvolvidos para aplicações especificas, que executam
poucas funções e tem um processamento bastante rápido devido ao processamento
ser totalmente paralelo.
Muitas vantagens podem ser vistas no uso de FPGA como a possibilidade de
desenvolver unidades funcionais dedicadas a resolver problemas especiais e
mudanças rápidas no hardware. Em microprocessadores de uso geral, se tem um
hardware que não pode ser modificado, fixo, mas no FPGA essa mudança é bastante
simples e rápida, feita via software.
O projeto tem como objetivo a implementação de uma rede neural em um
hardware reconfigurável.
Dentro da computação uma área de grande interesse aos pesquisadores é
Inteligência Artificial (IA) ou Inteligência Computacional (IC) no estudo de Redes
Neurais Artificiais (RNA). Segundo [BRAGA, 2000] as redes neurais artificiais são
sistemas paralelos distribuídos compostos por unidades de processamento simples
(neurônios) que calculam determinadas funções matemáticas (normalmente nãolineares), capazes de armazenar conhecimento tornando-o acessível para uso. Essa
estrutura se assemelha ao cérebro humano.
Geralmente, o conhecimento é adquirido a partir de um processo de
aprendizagem. Esse processo se dá pela força de conexões entre os nodos
(neurônios), que são utilizados para armazenar o conhecimento adquirido.
As redes neurais artificiais têm uma enorme gama de aplicações, podendo ser
utilizadas nas mais diversas áreas, como: automação, biomédica, processamento de
imagens, processamento de voz, etc.
2
A Rede Neural (RN) selecionada para implementação neste projeto é LVQ
(Learning Vector Quantization) [KOHONEN, 1997], sendo bastante interessante para
implementação em hardware visto que utiliza cálculos de distância euclidiana entre
amostras de vetores de referência, o que elimina o uso de multiplicadores, que ocupam
grande quantidade de lógica dos componentes programáveis [KUGLER, 2003].
A rede LVQ é um método de treinamento de RNA para classificação de padrões
no qual cada saída da RN representa uma classe. Cada classe é referenciada a um
vetor de pesos (vetores de referência), os quais representam os centros de clusters
que definem as superfícies de decisão das classes. Este tipo de rede assume que um
conjunto de padrões de treinamento é conhecido, junto com uma distribuição inicial dos
vetores de referência.
Este projeto busca uma solução para sistemas que exigem grande poder
computacional, adotando como solução um dispositivo de baixo custo e com recursos
suficientes para este tipo de processamento. Para tanto, este documento foi redigido
em 6 seções distintas, considerando esta como seção introdutória.
Na segunda seção encontra-se a revisão da literatura. Nela é apresentada a base
teórico-conceitual, oferecendo um panorama da tecnologia utilizada e uma visão geral
dos estudos nessa área.
Na terceira seção é apresentada a especificação técnica de software e hardware,
objetivos de cada módulo do projeto e funcionamento de cada um deles.
Na quarta seção encontra-se o projeto de desenvolvimento do sistema, software
(aplicativo desenvolvido e treino da rede no MatLab) e hardware (módulo de
comunicação e módulo da FPGA).
Na quinta seção são apresentados os resultados obtidos, mostrando o
funcionamento de cada módulo, como resultados obtidos nos teste de cada um e
resultado do sistema completo em funcionamento.
Finalmente, na sexta seção, são apresentadas as conclusões obtidas com o
desenvolvimento deste projeto, bem como as limitações e direcionamento para futuras
implementações.
3
2 REVISÃO BIBLIOGRÁFICA
2.1
FPGA
As FPGAs são circuitos de hardware que podem ser modificados praticamente
em qualquer momento durante o uso. As FPGAs consistem em arrays de blocos
lógicos configuráveis, que implementam funções lógicas, tais como AND, NAND, OR,
NOR e XOR [USP, 2005].
A FPGA utilizada neste projeto é EP1C20F400C7 da família Cyclone, disponível
na placa de desenvolvimento Nios II – Edição Cyclone [ALTERA, 2004].
Os dispositivos da família Cyclone contêm uma arquitetura bidimensional de
linhas e colunas. Esta arquitetura é composta por LABs (Logic Array Blocks), onde
cada LAB contém 10 LEs (Logic Elements). As linhas e colunas são interconectadas
com velocidades que variam provendo interconexão eficiente entre LABs e LEs
[ALTERA, 2004].
Na figura 1, os blocos de memórias M4K RAM são agrupados nas colunas entre os
LAB’s. Na parte externa, é possível ver os IOEs (elementos de entrada / saída) da
FPGA, que suportam diferentes padrões de E/S (entrada / saída). O número de blocos
M4K RAM, PLLs, linhas e colunas variam para cada dispositivo da família Cyclone,
como mostra na tabela 1 [ALTERA, 2004].
Tabela 1 - Recursos do dispositivo (adaptado de Cyclone Device Handbook).
4
Figura 1 - Diagrama em blocos da família Cyclone.
2.1.1 Arquitetura da família Cyclone
Cada LAB (Logic Array Blocks), consistem em agrupamentos de 10 LEs (logic
elements), sinais de controle dos LABs, interconexões locais, uma tabela de LUT (lookup table), possuem interconexões por linhas e colunas, apresentado na figura 2
(estrutura do LAB).
As conexões locais de link direto (Direct Link Connection), minimizam o uso das
linhas e colunas, provendo maior performance e flexibilidade. Existe uma ligação direta
de cada LE que o conecta a outros 30 LEs através de uma conexão de link direto.
Cada LAB possui uma lógica para dirigir sinais de controle a seus LEs. Os LABs
contém os seguintes sinais de controle: dois clocks, dois sinais de habilitação de clock,
dois asynchronous clears, synchronous clear, asynchronous preset/load, synchronous
load e sinais de controle de soma / subtração, mostrados na figura 3.
5
Figura 2 - Estrutura do LABs do Cyclone.
Figura 3 - Sinais de controle dos LABs.
O LE é a menor unidade da lógica na arquitetura do Cyclone. O LE é compacto e
fornece características avançadas para utilização eficiente da lógica. Cada LE contém
uma LUT de 4 entradas, para que possa executar qualquer função de quatro variáveis.
Além disso, cada LE contém um registrador programável e carry (selecionado).
6
O LE possui os seguintes tipos de interconexão: local, linha, coluna, registrador
programável e link direto. Duas saídas da LE são direcionadas para roteamento de
coluna ou linha, uma para link direto e uma para interconexão local. Isso permite que a
LUT e o registrador programável trabalhem paralelamente.
Essas características são chamadas de Register Packing, que melhoram a
utilização do dispositivo, pois este dispositivo pode utilizar a LUT e o registrador em
funções não relacionadas. A estrutura do LE do Cyclone é apresentada na figura 4.
Figura 4 - LE do Cyclone.
Os LEs possuem uma característica de somador/subtrator dinâmico, que livra
recursos lógicos de usar um conjunto de LE’s para implementar ambas as operações.
Essa característica é controlada pelo sinal de controle addnsub, que coloca o LAB para
realizar tanto A + B quanto A – B.
O dispositivo Cyclone possui dois modos de operação dos LEs: modo normal e
modo aritmético dinâmico. Cada modo usa os recursos do LE diferentemente.
Em cada modo, oito entradas são disponíveis para a LE (quatro dados de entrada
da interconexão local da LAB, carry-in0 e carry-in1 da LE anterior, o carry-in do LAB e a
7
conexão da cadeia de registradores), que são direcionadas para diferentes destinos
para implementar a função lógica desejada.
O modo normal é apropriado para aplicações de lógica gerais e funções
combinatórias. O sinal addnsub só é permitido no modo normal se o LE está no final de
uma cadeia de somador/subtrator. Este modo é apresentado na figura 5.
O modo aritmético dinâmico é ideal para implementar somadores, contadores,
acumuladores, funções de paridade e comparadores.
Um LE no modo aritmético usa quatro LUT’s de duas entradas configuradas como
um somador ou subtrator dinâmico. O modo aritmético dinâmico é apresentado na
figura 6.
Figura 5 - LE em modo normal.
Na arquitetura Cyclone, os LE’s, blocos de memória M4K e dispositivos de E/S
são providos por uma estrutura de interconexão MultiTrack. A interconexão MultiTrack
consiste de linhas contínuas roteadoras e de performance otimizada de diferentes
velocidades usadas para realizar conexões inter e intra blocos. Simplifica o estágio de
integração de projetos baseados em blocos, eliminando os ciclos de re-otimização que
geralmente geram mudanças de projeto. Consiste de interconexões de linha e coluna
com distâncias fixas. Linhas dedicadas interconectam sinais roteados de e para LAB’s,
PLL’s, blocos de memória M4K dentro de uma mesma linha. Essas linhas incluem (1)
interconexões de links diretos entre LAB’s e blocos adjacentes e (2) R4 Interconnect
(Row4) que liga quatro blocos (figura 7).
8
Figura 6 - LE em modo aritmético dinâmico.
Figura 7 - Conexões de Interconnect.
A interconexão de colunas opera similarmente a interconexão de linhas. Colunas
dedicadas interconectam sinais roteados de e para LAB’s, PLL’s, blocos de memória
M4K verticalmente. Essas colunas incluem: cadeias de LUT’s dentro de um LAB,
cadeias de Registradores programáveis dentro de um LAB, C4 interconecta quatro
blocos.
9
A memória embarcada do Cyclone consiste em colunas de blocos da memória
M4K. Cada bloco de M4K pode executar vários tipos de memória com ou sem
paridade, incluindo dual-port verdadeiro, dual-port simples e single-port de RAM, ROM
e FIFO. A figura 8 apresenta os sinais de controle dos blocos de memória. E a figura 9
mostra a relação entre linhas dos LABs com os bloco memória M4K
Figura 8 - Sinais de controle do bloco M4K RAM.
Figura 9 - Relação de linhas do LAB com bloco de M4K RAM.
10
Os dispositivos Cyclone fornecem uma rede global do pulso de clock. Há quatro
pinos dedicados para o clock (CLK[3..0 ], dois pinos no lado esquerdo e dois pinos no
lado direito). A rede global do pulso de clock é mostrada na figura 10.
Figura 10 - Geração do clock global.
Tensão de trabalho dos elementos de E/S do dispositivo Cyclone são os
seguintes padrões:

3.3 V LVTTL/LVCMOS

2.5-V LVTTL/LVCMOS

1.8-V LVTTL/LVCMOS

1.5-V LVCMOS

3.3-V PCI

LVDS

RSDS

SSTL-2 class I and II

SSTL-3 class I and II.
11
Tabela 2 - Padrões de E/S do Cyclone.
2.1.2 Placa de desenvolvimento Nios
A placa de desenvolvimento Nios inclui a FPGA que é utilizada, além de oferecer
outros recursos que podem utilizado no projeto como apresentado na figura 11.
Figura 11 - Diagrama em blocos da placa de desenvolvimento Nios.
12
Os conectores de expansão da placa do Nios, PROTO1 e PROTO2 compartilham
dos pinos do E/S do dispositivo Cyclone, os disponibilizando para o usuário. O
PROTO1 compartilha seus pinos com o conector do compact flash. As figuras 12 e 13
apresentam os conectores de expansão.
Figura 12 - Conector de expansão 1.
Figura 13 - Conector de expansão 2.
13
Figura 14 – Disposição dos componentes da placa de desenvolvimento Nios [ALTERA, 2004].
14
A
figura
14
apresenta
a
disposição
dos
componentes
na
placa
de
desenvolvimento Nios, edição Cyclone.
Na placa de desenvolvimento Nios, há dois displays sete segmentos (U8 e U9),
conectados ao dispositivo Cyclone, de modo que cada segmento seja controlado
individualmente por um pino de E/S do dispositivo. Quando o pino do Cyclone dirige a
lógica para nível lógico baixo, o diodo emissor de luz correspondente é ativado. Os
displays e a correspondente pinagem de cada um é mostrada na figura 15.
A placa contém push-buttons e LEDs, todos conectados a portas individuais do
dispositivo Cyclone. A tabela 3 contém os pinos de cada push-button conectado ao
Cyclone e na tabela 4 é apresentada a pinagem dos LEDs. Na figura 16 é apresentada
a disposição dos LEDs e push-buttons na placa de desenvolvimento do Nios.
Figura 15 - Display 7 segmentos da placa de desenvolvimento do Nios.
Tabela 3 - Pinagem dos push-buttons da placa de desenvolvimento Nios.
Tabela 4 - Pinagem dos LEDs da placa de desenvolvimento Nios.
Figura 16 - Disposição dos push-buttons e LEDs na placa.
15
A configuração do dispositivo Cyclone é feita através da interface JTAG (J24)
disponível na placa de desenvolvimento Nios, que permite a configuração via software
Quartus II.
2.2
Redes Neurais
2.2.1 Histórico
Em 1943, um trabalho pioneiro sobre redes neurais artificiais foi realizado por
Warren McCullock e Walter Pitts “A Logical Calculus of the Ideas Immament in Nervous
Activity”.
Eles desenvolveram um estudo sobre o comportamento do neurônio biológico,
com o objetivo de criar um modelo matemático capaz de simular o comportamento do
neurônio biológico. As conclusões desta pesquisa foram de extrema importância para a
futura implementação computacional do neurônio formal. O modelo de McCullock e
Pitts foi chamado de nodos MCP.
A grande discussão em torno de RNA é a aprendizagem [BRAGA, 2000], que não
foi foco da pesquisa de McCullock e Pitts. Eles se concentraram em descrever o
neurônio matematicamente e não como seria a aprendizagem. Em 1949, Donald Hebb
mostrou como a aprendizagem se daria a partir de uma atualização de pesos na
entrada dos nodos (neurônios).
Frank Rosenblatt, em 1958, implementou o primeiro modelo neural, o perceptron.
Ele demonstrou que acrescentando pesos aos nodos MCP a rede neural poderia ser
treinada para reconhecimento de alguns padrões. O perceptron simples de
comportava-se como um classificador, dividindo o espaço em regiões distintas para
cada uma das classes existentes. O perceptron só é capaz de separar padrões que
sejam linearmente separáveis [BRAGA, 2000].
Em 1969, Minskey e Papert mostraram que o percepton não era capaz de
executar algumas funções. O perceptron é capaz de aprender tudo aquilo que ele
consegue representar [BRAGA, 2000], problemas de entrada que a solução não
poderia ser separadas linearmente, não haveria solução.
Um exemplo de função que o perceptron não poderia resolver é a função XOR.
Supondo um plano onde x e y são as entradas da rede e o ponto cartesiano (x,y) é o
valor da respectiva saída, como na figura 17.
16
Figura 17 - Representação gráfica do XOR.
Como mostra a figura 17, não é possível traçar uma única reta (função linear)
capaz de dividir plano de maneira que as saídas com valor zero ficam situadas de um
lado da reta e as com valor um do outro.
Após Minskey e Papert demonstrarem este problema, um período chamado de
anos negros das redes neurais artificiais iniciou, por desencorajar novas pesquisas e
desestimular o estudo mais profundo deste campo.
Em 1982, Teuvo Kohonen [KOHONEN, 1997] definiu um novo modelo de rede
neural, conhecido como mapa auto-organizável de características. Ao contrário do
perceptron, ele não era limitado a valores binários, mas os valores das entradas, dos
pesos e das saídas poderiam ser contínuos.
A grande importância do trabalho de Kohonen foi ter introduzido um novo
paradigma no estudo das redes neurais: o aprendizado não-supervisionado, onde a
rede neural não precisa ficar sendo comparada constantemente a um valor de saída
durante a fase de aprendizado, mas este método é válido apenas para as redes SelfOrganizing Maps - SOM (as redes LVQ utilizando o algoritmo supervisionado para seu
treino).
2.2.2 Neurônio Biológico
Os neurônios biológicos são divididos em três partes: o corpo da célula, os
dendritos e o axônio [BRAGA, 2000].
Os dendritos têm como função receber os impulsos de outros neurônios e levá-los
até o corpo da célula. A informação que chega ao corpo da célula é processada, novos
impulsos são gerados e levados pelos axônios até os dendritos de outros neurônios. A
figura 18 apresenta a estrutura do neurônio.
17
Figura 18 - Componentes do neurônio biológico.
No neurônio há uma diferença de potencial entre seu interior (concentração de
potássio) e exterior (concentração de sódio). Dentro da célula a concentração de íon de
potássio gera um potencial de -70mV em relação ao seu exterior. Para que a célula
consiga produzir um impulso nervoso, as sinapses necessitam produzir um potencial de
-50mV, como mostrado na figura 19. Neste momento há a inversão do nível de
potássio e sódio, fazendo com que a célula se torne positiva em relação ao exterior,
fazendo com que o impulso seja propagado pelo axônio. O impulso chegando ao
terminal
do
axônio
fará
com
que
este
se
abra,
liberando
as
moléculas
neurotransmissoras, que continuarão o mesmo processo para o neurônio seguinte.
Figura 19 - Potencial de ação em um neurônio.
18
2.2.3 Neurônio Modelado
O neurônio modelado é uma descrição matemática de McCullock e Pitts, sobre o
que sabiam a respeito do neurônio biológico.
O neurônio modelado possui terminais de entrada x1, x2, ..., xn, que representam
os dendritos. Um terminal de saída y que representa o axônio. E pesos acoplados as
entradas w1, w2, ..., wn, que representam o comportamento das sinapses. A figura 20
apresenta a estrutura do neurônio modelado.
O neurônio biológico é disparado quando a soma dos impulsos ultrapassa o limiar
de excitação [BRAGA, 2000]. No neurônio modelado o mecanismo é muito parecido,
uma soma ponderada entre os valores da entrada (x1w1 + x2w2 + ... + xnwn, uma soma
ponderada) é realizada, quando o limiar é ultrapassado (função de ativação θ) ele é
disparado (saída igual a 1), caso a soma não ultrapasse o limiar de ativação ele não é
disparado (saída igual a 0).
A função de ativação que define o disparo do neurônio é dada por:
n
∑x w
i =1
i
i
≥θ
(1)
Figura 20 - Neurônio de McCulloch e Pitts.
O conhecimento é adquirido pelo ajuste do neurônio a partir de um processo de
aprendizagem. Esse processo se dá pela força de conexões entre os neurônios, que
são utilizados para armazenar o conhecimento adquirido.
2.2.4 Arquiteturas de RNAs
Algumas arquiteturas de RNAs foram definidas e são apresentados na figura 21.
19
As arquiteturas de rede podem ser divididas quanto ao número de camadas e tipo
de conexões.
o Quanto ao número de camadas:
•
Rede de camada única é quando só há um nó (neurônio) entre a
entrada e qualquer saída (Figura 21 a).
•
Rede de múltiplas camadas quando só há mais de um nó (neurônio)
entre a entrada e qualquer saída (Figura 21 b, c, d).
o Quanto ao tipo de conexão:
•
Rede feedforward ou acíclica quando a saída de um neurônio na iésima camada da rede não pode ser usada como entrada de nodos
em camadas de índices maior ou igual a i (figura 21 a, b, c).
•
Rede feedback ou cíclica quando a saída de algum neurônio na iésima camada da rede é usada como entrada de nodos em
camadas de índices menor ou igual a i (figura 21 d, e). Quando
todas as saídas de uma rede são cíclicas, ela é denominada autoassociativa (figura 26 e).
Figura 21 - Exemplos de arquiteturas de RNAs.
20
2.2.5 Aprendizado
“O aprendizado é um processo pelo qual os parâmetros de uma rede neural são
ajustados através de uma forma continua de estímulos pelo ambiente no qual a rede
está operando, sendo o tipo especifico de aprendizagem realizado definido pela
maneira particular como ocorrem os ajustes realizados nos parâmetros” [BRAGA,
2000].
Para a aprendizagem das redes neurais artificiais foram desenvolvidos diversos
métodos, que podem ser divididos em dois paradigmas: aprendizado supervisionado e
não-supervisionado.
2.2.5.1 Aprendizado Supervisionado
O aprendizado supervisionado é um mecanismo onde a entrada e a saída
desejada da rede são fornecidas por um supervisor (também conhecido como
professor). Neste método, o supervisor apresenta o comportamento da rede como
sendo bom ou ruim, visando encontrar uma ligação entre a entrada e a saída da rede,
assim direcionando o processo de treinamento.
Com isso, os dados de entrada são apresentados à rede neural, juntamente com
a saída desejada. O valor obtido pelo processamento é comparado ao valor desejado e
assim o ajuste de pesos é feito para aproximar esses valores de saída da rede. Na
figura 22 é mostrada a estrutura do treinamento supervisionado.
Figura 22 - Aprendizagem Supervisionado.
21
2.2.5.2 Aprendizado Não-supervisionado
O aprendizado não-supervisionado acontece quando somente os padrões de
entrada são apresentados à rede neural [BRAGA, 2000]. Não há um supervisor
acompanhando o processo. Como mostra a figura 23.
Figura 23 - Aprendizado Não-supervisionado.
2.2.6 Algoritmo de treinamento para Retropropagação (Back-propagation)
Alguns algoritmos de treino de redes neurais são citados, começando pelo mais
comum, algoritmo de retropropagação de erro, para treinamento de redes MLP
(Multilayer Perceptron).
O perceptron de múltiplas camadas consiste em um conjunto de unidades
sensoriais formando a camada de entrada, uma ou mais camadas ocultas e uma
camada de saída. A figura 24 representa a estrutura de um perceptron de múltiplas
camadas.
Figura 24 - Perceptron de múltiplas camadas.
O algoritmo consiste de dois passos: a propagação que se dá quando um vetor de
dados é aplicado à entrada da rede e este se propaga pela rede camada a camada
(neste ponto os pesos da rede permanecem fixos). O segundo passo é o de
22
retropropagação, onde os pesos são ajustados de acordo com a regra de correção de
erro.
2.2.7 SOM (Self-Organizing Maps)
O SOM (mapa auto-organizado), método criado por Kohonen [KOHONEN, 1997],
são redes neurais com treinamento não-supervisionado, ela por si própria define seus
parâmetros, sem auxílio externo.
O princípio de utilização de Self-Organizing é que para reconhecimento de
padrões que compartilham características, estes deverão ser agrupados numa única
classe. Para tanto, é necessária a redundância dos dados de entrada, para que a rede
possa encontrar padrões sem a ajuda de um professor (caso não haja redundância,
estes são considerados ruídos aleatórios).
Figura 25 - Exemplo de mapeamento usando SOM.
Na figura 25 é apresentado um exemplo de treino do algoritmo SOM, onde um
conjunto de dados de entrada (cruzes vermelhas) é submetido ao treino e é obtido o
mapeamento das classes (bolinhas azuis).
23
O SOM consiste numa grade n-dimensional (geralmente bi-dimensional) de
neurônios. Cada neurônio é composto por um vetor de pesos e eventualmente uma
“etiqueta” que identifica o estado que esse neurônio representa. O valor de saída de
um neurônio é a medida da distancia euclidiana entre o seu vetor de pesos, e o vetor
de dados que é apresentado à rede. Em vez do produto interno, pode ser usada
qualquer medida de distância entre os dois vetores. O neurônio vencedor será o que
tiver maior valor de saída.
2.3
Classificador LVQ
Learning Vector Quantization (LVQ) define uma família de algoritmos criados por
Kohonen. A LVQ é um classificador baseado em agrupamento (clustering) [PILLA,
1999], ou seja, é um método de treinamento de redes neurais para classificação de
padrões no qual cada saída representa uma classe em particular (porém, várias saídas
também podem ser usadas para uma única classe).
Cada classe é referenciada por um vetor de pesos, que representam os centros
de clusters (ou centróides) que definem as superfícies de decisão das classes. Este
tipo de rede assume que o conjunto de padrões de treinamento é conhecido, junto com
uma distribuição inicial dos vetores de referência (mesmo que centróides).
Na figura 26 é apresentada a arquitetura da rede LVQ. Esta rede possui uma
camada competitiva [PILLA, 2000] que classifica o padrão de entrada, relacionando a
uma subclasse, e assim estabelecendo através das subclasses os vetores de
referência e a camada linear que agrupa as subclasses às classes.
Figura 26 - Arquitetura da Rede LVQ.
24
2.3.1 A Classificação LVQ
A atribuição de uma classe à um vetor de características é efetuada pela
identificação do protótipo mais próximo deste vetor. Na rede LVQ, a classificação é
processada calculando-se a distância do vetor de entrada ao conjunto de protótipos.
Esta classificação pode ser expressa matematicamente pela equação 2.
c = arg min{ x − mi }
(2)
Onde a x é atribuída a classe a que pertence o protótipo c. Os pesos de cada
célula devem posicionar os protótipos de tal forma que, o espaço seja dividido em
regiões distintas para as diferentes classes. As células que se encontram na fronteira
das classes definem o limite de cada classe. O processo de treino é realizado a partir
da excessiva classificação de um conjunto de exemplos pré-classificados, onde há o
progressivo ajuste dos pesos.
Podem ser destacados alguns processos de treino apresentados por Kohonen:
LVQ1, LVQ2 e LVQ3 [KOHONEN, 1997].
2.3.2 LVQ1
Considere x(t) o vetor de características aplicado ao processo de treino na
iteração t. Admita mi(t) como vetor de pesos da célula na mesma iteração. O processo
de adaptação dos pesos mi(t) acontece pela identificação da célula vencedora c,
equação 2.
A alteração dos pesos mi, garante a convergência e minimiza a taxa de erros,
equação 3.
m c (t + 1) = mc (t ) + α (t )[x(t ) − mc (t )]
se mc e x ∈ a mesma classe
m c (t + 1) = mc (t ) − α (t )[x(t ) − mc (t )]
se mc e x ∈ a mesma diferentes
m i (t + 1) = mi (t )
para I ≠ c
(3)
No processo de treino, mc aproxima-se de x(t), se mc e x(t) pertencem a mesma
classe. No caso de x(t) e a célula vencedora c não pertençam a mesma classe, o
25
centróide se afastará do exemplo x(t). A atualização só é feita para a célula vencedora
e as outras permanecendo inalteradas.
A função α (t) representa o passo de adaptação do algoritmo.
o α (t) deve estar compreendido entre os valores 0 e 1, para garantir
estabilidade;
o α (t) deve decrescer para 0, para garantir convergência.
A forma como α (t) decresce (que pode ser definido como uma função
exponencial ou linear) para 0 não é o mais importante para convergir o processo,
desde que um número suficiente de iterações seja realizado.
2.3.3 LVQ2
O processo de classificação é o mesmo para todos os métodos LVQ, o que difere
cada um deles é a forma do treino. LVQ2 atualiza duas células simultaneamente em
cada iteração do processo de treino. As células atualizadas referem-se aos protótipos
mi e mj mais próximos do conjunto de treino. A atualização obedece as seguintes
condições:
o A célula mais próxima mi deve pertencer a x(t) e a segunda célula mais
próxima mj, deve pertencer a uma classe diferente de x(t).
o Os pesos das duas células só são atualizados se x(t) estiver numa “janela”
definida em torno do plano de separação das duas células.
Nesta situação, as distâncias di e dj (distâncias euclidiana de x(t) aos centróides
mi e mj) devem respeitar a condição apresentada na equação 4.
⎛ d d j ⎞ 1− w
min⎜⎜ i , ⎟⎟ >
⎝ di di ⎠ 1 + w
(4)
Onde w é a largura da janela. A w é atribuído um valor entre 0,2 e 0,3. Se o
exemplo x(t) respeitar as duas condições, os centróides serão atualizados segundo a
equação 5.
m c (t + 1) = mc (t ) + α (t )[x(t ) − mc (t )]
Para classes (mi) = classe (x(t))
m c (t + 1) = mc (t ) − α (t )[x(t ) − mc (t )]
Para classes (mi) ≠ classe (x(t))
(5)
26
2.3.4 LVQ3
LVQ3 foi definida a partir de uma combinação da melhor fronteira de LVQ2, com a
estabilidade de LVQ1. Identificando em LVQ3 as duas células mais próximas mi e mj do
exemplo x(t). Para que sejam atualizadas, devem verificar as condições:
o Pelo menos uma delas pertencer a x(t);
o A distância di e dj (distância euclidiana de x(t) aos centróides mi e mj),
respeitar as condições como em LVQ2 na equação 4.
Se as suas células respeitam as condições e pertencem as classes diferentes,
são atualizadas pela equação 5.
Mas se mi e mj pertencem a mesma classe e por conseqüência a x(t) são
atualizados pela equação 6.
mk (t + 1) = mk (t ) + εα (t )[x(t ) − mk (t )]
K Є {i, j}
(6)
A constante ε está compreendida entre 0,1 e 0,5 para uma janela w entre 0,2 e
0,3. Este algoritmo conduz à convergência mesmo em processos longos de treino.
2.3.5 Diferenças entre LVQ1, LVQ2 e LVQ3
Na maior parte das implementações, os três métodos levam a mesma
semelhança nas precisões estatísticas. LVQ1 e LVQ3 apresentam métodos mais
robustos de treino. Já LVQ2 é adequada para afinações finais da rede, por exemplo,
após um treino da LVQ1. Para este tipo de afinação é recomendável que sejam
utilizados passos de adaptação bastante baixos e poucas iterações.
2.3.6 Classificador LVQ
O classificador LVQ é um comparador de pontos. Cada amostra de entrada da
rede é classificada como pertencente à classe do centro de cluster mais similar à
amostra, ou seja, a medida de similaridade ou de dissimilaridade entre dois pontos x e
y pode ser implementada como a distância euclidiana entre esses dois pontos. Para
este projeto a distância que é utilizada é Manhattan, simplificando os cálculos em
hardware, como é apresentado na equação 7 [KUGLER, 2003].
27
n =i
d ( x, y ) = ∑ x ni − y n
(7)
1
2.3.7 Porque usar LVQ
Esta rede neural foi escolhida por ser interessante para a implementação em
hardware devido ao fato da rede ser baseada no cálculo de distância euclidiana entre
as amostras e os vetores de referência. O que elimina a necessidade de
multiplicadores, que necessitam mais ciclos de clock para execução dos cálculos
[KUGLER, 2003], como, a utilização de redes MLP, com o algoritmo de
retropropagação de erro para o treinamento, que exige um grande número de
multiplicações, o que dificultaria a implementação em lógica programável.
2.4
Interface USB
A versão 1.1 do barramento USB suporta dois modos de transferência: o modo
full speed, operando com velocidade de 12Mbits/s e o modo low speed, operando a
uma velocidade de 1.5 Mbits/s. Este segundo, mesmo sendo mais lento, é muito menos
susceptível a interferências eletromagnéticas, reduzindo assim os custos com
componentes de maior qualidade e com enrolamentos em barra de ferrite.
Taxas de transferência obtíveis atualmente com o barramento USB:
•
High Speed - 480Mbits/s (USB 2.0)
•
Full Speed - 12Mbits/s (USB 1.1 e 2.0)
•
Low Speed - 1.5Mbits/s (USB 1.1 e 2.0)
A USB é um barramento com interface mestre / escravo, isto é, só é permitido
um mestre (host) por barramento. O host é responsável por gerenciar todas as
transações e a coordenação da banda utilizada por cada dispositivo do barramento. Os
dados podem ser enviados por vários métodos de transmissão, sempre utilizando um
protocolo baseado em tokens.
A topologia do barramento USB é baseada no sistema estrela, assim como nas
redes Ethernet. Do ponto de vista de que a USB foi desenvolvida para diminuir a
quantidade de cabos que saem do computador, ela não é muito efetiva. Mesmo
considerando que a maioria dos seus dispositivos pode ser alimentada pelo próprio
barramento, ainda é necessário um cabo saindo da CPU para cada dispositivo, ao
28
contrário do funcionamento dos computadores da Apple, onde você pode ligar o mouse
no teclado e o teclado na CPU.
Isto até é possível com a USB tradicional, mas há o inconveniente de que cada
dispositivo que servisse como uma nova porta USB precisaria ter um host controller,
isto é, um gerenciador para os dispositivos que estivessem acoplados a este
equipamento. Este sistema, além de dificultar mais o projeto dos dispositivos de
hardware, também apresenta o empecilho do aumento do custo de produção de
qualquer equipamento que viesse a ser conectado neste barramento.
Mesmo com uma maior quantidade de cabos, a topologia estrela oferece alguns
benefícios à interface USB, principalmente no que diz respeito à alimentação dos
dispositivos. Com esta topologia, cada equipamento pode ter a sua alimentação
controlada individualmente. No caso de uma falha causando sobrecarga no barramento
em algum dispositivo, este pode ser desativado sem interferir nos demais.
Com relação à quantidade de dispositivos que podem ser adicionados a um
mesmo controlador provavelmente não haverá problemas, visto que cada controlador
pode gerenciar até 127 dispositivos.
O nome USB sugere já no nome uma comunicação serial (Universal Serial Bus).
Este utiliza 4 fios, sendo um par de alimentação (+5V e GND) e outro par de sinais de
dados. Esta comunicação é baseada no sistema de codificação NRZI (Non Return to
Zero Invert), o qual envia os dados acompanhados de um sinal de sincronização.
A figura 32 mostra os conectores utilizados pela porta USB.
A:
B:
Figura 27 - Conectores utilizados pela USB.
A) Conector fêmea tipo A, encontrado no Host. B) Conector fêmea tipo B, encontrado nos dispositivos.
Tabela 5 - Pinos da interface USB
Número Pino
1
2
3
4
Cor do Cabo
Vermelho
Branco
Verde
Preto
Função
Vbus (5V)
DD+
GND
29
A especificação USB suporta a conexão plug-and-play, com carregamento
dinâmico dos drivers. Basta apenas o usuário conectar o dispositivo à uma porta USB
que o host o detectará, carregando automaticamente o driver para o equipamento. O
usuário final não precisa se preocupar com configurações complicadas, tais como IRQs
e endereços de portas, assim como está dispensada a reinicialização do computador.
Tão fácil como a conexão é a desconexão de um dispositivo USB. Basta retirar o cabo,
que o host automaticamente irá descarregar o driver da memória.
O carregamento do driver apropriado para o dispositivo é realizado através do
PID (Product ID) e do VID (Vendor ID). O VID é um número fornecido pelo USB
Implementor’s Forum com um certo custo. Outras organizações provêem outros VIDs
para uso não comercial, como ensino ou pesquisa. Para uma detecção coerente do
dispositivo conectado ao barramento, os fabricantes realizam uma combinação de VID
e PID para que não haja outro equipamento no mercado com o mesmo código,
evitando assim conflitos posteriores. Esta combinação funciona como um endereço fixo
de cada dispositivo do barramento.
Só pode existir um USB Host, e este é o master do barramento. Ele toma
conhecimento da inserção e do desligamento dos dispositivos, inicia o processo de
enumeração e comanda todas as transações subsequentes no barramento. É de sua
responsabilidade também coletar os status e as estatísticas de cada dispositivos.
A estrutura do software:

Host Controler driver: Camada que "linka" as diferentes implementações
do host ao resto da estrutura USB.

USB System software: Camada que atua entre o Controlador e o software
cliente (parte do sistema operacional).

Client software: Permite ao cliente comunicar com um dispositivo USB
através de abstrações da camada USB System.
O host USB envia constantemente, a cada 1 milisegundo, um pacote de início de
frame (SOF - start of frame). Todos os dispositivos estão continuamente "ouvindo" o
barramento. Quando o host envia um token cujo endereço "casa" com o do dispositivo,
este decodifica o pacote, verifica o tipo do mesmo e, de acordo com o tipo, toma as
devidas atitudes.
O escalonamento de envio pela banda compartilhada é feito trocando o
dispositivo-alvo nos SOF.
Cada pacote tem um PID que especifica o tipo, como mostra a figura 28. A
transação inicia quando o host controller envia um pacote token com o endereço do
30
periférico, endpoint number (porto), a direção de transferência de dados e o tipo de
canal de transferência. O endereço do periférico é selecionado de acordo com o
endereço passado pelo token. Se o host estiver pedindo dados, então o pacote de
dados é enviado pelo periférico. Geralmente, depois que o dado é enviado, o
destinatário (host ou periférico) envia um pacote handshake, que pode ser ACK, NAK
ou STALL.
Figura 28 - Formatos dos pacotes do protocolo USB.
31
3 ESPECIFICAÇÃO TÉCNICA
Inicialmente é apresentada a visão geral do sistema e a descrição funcional de
cada módulo. A figura 29 apresenta o diagrama em blocos do sistema.
Figura 29 - Diagrama em Blocos do sistema.
O sistema consiste na implementação de uma rede neural utilizando computação
reconfigurável. Para tanto, o sistema é dividido em três módulos: módulo FPGA,
módulo de comunicação e módulo PC. Sendo o módulo da FPGA responsável pela
rede neural em hardware. O módulo de comunicação responsável pela transferência
dos dados do PC para a FPGA. E, o módulo do PC responsável pelo treino da rede
neural (realizado no MatLab), configuração da FPGA e envio da configuração da rede
neural.
32
3.1
Especificação de Hardware
3.1.1 Módulo FPGA
O módulo da FPGA consiste em um dispositivo lógico que contém uma rede
neural do tipo LVQ para o reconhecimento de padrões.
Este dispositivo permite várias gravações, o que auxilia no desenvolvimento de
projetos e nas mudanças necessários. Outra vantagem do uso de uma FPGA é que
com o hardware dedicado ao processamento da rede neural, é possível obter um maior
poder computacional, como mostra [RIBEIRO, 2002], foi implementada na USP uma
rede neural em uma FPGA e esta respondeu aos dados de entrada em 10ns, enquanto
que a mesma rede implementada em um PC necessita de pelo menos 23µs.
O módulo da FPGA possui dois modos de configuração: (1) JTAG e (2) USB, os
quais são apresentados a seguir.
3.1.1.1 Configuração via interface JTAG
Como desenvolvimento do firmware da FPGA, o dispositivo pode ser configurado,
o que acontece através do software Quartus II, pela interface JTAG. Após a
configuração do dispositivo, pode prosseguir com a configuração da rede neural.
3.1.1.2 Configuração via interface USB
Pela interface USB é configurada a rede neural na FPGA, com o envio dos
parâmetros de configuração e dados que são analisados pela rede. Isso acontece
através de um aplicativo desenvolvido, que é responsável pelo envio desses dados:
•
Configuração da rede neural
o Número de sub-classes;
o Número de dimensões;
o Vetores de referência (subclasses);
o Mapeamento das classes com as subclasses;
•
Dados para análise.
A rede LVQ na FPGA faz a análise dos dados recebidos do PC e o resultado da
classificação é exibido por displays sete segmentos.
33
O algoritmo de classificação da rede LVQ segue os passos descritos na figura 30.
Figura 30 – Algoritmo de classificação da rede LVQ.
3.1.2 Módulo de comunicação
Este módulo é responsável pela comunicação entre a FPGA e o PC. Para esta
comunicação são utilizados um microcontrolador de arquitetura CISC (Complex
Instruction Set Computers), da família 8051 da ATMEL (89S51 ou 89C51 que já
possuem memória de programa integrada no chip) e um conversor USB / Serial
(TUSB).
A figura 31, mostra como é formado este módulo.
Figura 31 - Módulo de comunicação.
Os dados são enviados pelo PC pela interface USB para o TUSB, este faz o envio
dos dados para μC pela porta serial. Quando os dados são recebidos pelo μC, este faz
a transmissão para a FPGA.
Quando o μC recebe um novo dado, ele faz a transmissão deste dado para um de
seus port e sinaliza a chegada de um novo dado para a FPGA. Como é mostrado no
fluxograma da figura 32.
O dispositivo que faz a interface entre PC e FPGA, o TUSB ao ser conectado a
uma porta USB do computador, é automaticamente reconhecido como um dispositivo
externo e o seu driver é solicitado. O driver utilizado para a conversão de USB para
Serial é compatível com Windows 98SE, Milenium, 2000 e XP.
Após o dispositivo ter sido instalado corretamente, será adicionada uma porta
serial COMx na lista de dispositivos do Windows, com a qual pode-se estabelecer uma
comunicação assim como com qualquer outro dispositivo serial.
34
Figura 32 - Fluxograma do firmware do µC.
Figura 33 - Diagrama em blocos da utilização do TUSB.
35
3.2
Especificação de Software
O módulo do PC pode ser dividido em três módulos: treinamento, configuração da
rede LVQ e configuração da FPGA.
O treinamento é realizado pelo software MatLab, que gera um arquivo de saída do
seu treino. O software de configuração é responsável por importar os dados resultantes
do treino no MatLab e armazená-los em um banco de dados. A partir destes dados
armazenados, eles podem ser enviados para a rede na FPGA. O software Quartus II é
responsável pela configuração da FPGA com o firmware da rede LVQ genérica.
3.2.1 Treinamento da RNA no MatLab
O treinamento é feito no software MatLab. A partir de um conjunto de dados, o
MatLab realiza o treino, que tem como resultado a geração de um arquivo que contém
a os vetores de referência, com as suas subclasses e o mapeamento destas com as
classes. O treinamento no MatLab é feito seguindo os passos da figura 34.
Figura 34 - Fluxograma do treinamento da rede LVQ no MatLab.
36
3.2.2 Software de configuração da rede LVQ
O software de configuração da rede LVQ também é responsável pela interface
com o usuário. E possui as seguintes funções:
•
Armazenamento dos dados de configuração da rede neural;
•
Envio dos vetores de referência da Rede Neural LVQ;
•
Envio dos dados para análise.
Os dados de saída do treinamento no MatLab são importados pelo software de
configuração da rede. Este software contém um banco de dados que é capaz de
armazenar qualquer tipo de treino da rede LVQ.
Para realizar a classificação, a rede LVQ deve ser configurada. Os vetores de
referência e o mapeamento das classes são enviados para a FPGA (que está
configurada), para configurar a rede LVQ. Esses dados de configuração da rede são
selecionados no software, a partir dos arquivos que foram importados.
A configuração da rede LVQ consiste no envio dos seguintes parâmetros: número
total de vetores de referência (número de subclasses), número de dimensões
(características dos dados), envio de cada um dos vetores de referência e o
mapeamento das classes de saída da rede.
3.2.3 Firmware
O firmware do μC é responsável pela transmissão dos dados recebidos do PC
(porta serial) para a FPGA (porta paralela), como na figura 35.
Figura 35 - Fluxograma da execução do μC.
37
3.3
Especificação de Validação
3.3.1 Validação de Hardware
A validação do hardware é feita a partir da análise de cada umas das partes. Para
isso faz-se necessário verificar a comunicação entre:
o Módulo de Comunicação e PC – recebimento pelo módulo de
comunicação.
o Módulo da FPGA e PC – recebimento pelo módulo da FPGA.
3.3.2 Validação de Software
A validação da rede neural faz-se a partir de um comparativo entre os resultados
obtidos pela rede LVQ na FPGA e da mesma no PC (MatLab).
Uma forma de validar a rede em hardware é aplicar uma função com resposta
conhecida, e verificar se o resultado obtido é o mesmo do esperado.
3.4
Infra-estrutura
A tabela 6 apresenta os ambientes de desenvolvimento e ferramentas de software
utilizadas e na tabela 7 as linguagens empregadas.
Foi utilizada a plataforma Windows para o desenvolvimento.
Tabela 6 - Ambientes e ferramentas de desenvolvimento.
Software
Borland C++Builder
Quartus II
MatLab 6.5
Keil
Utilização
Para o desenvolvimento da interface com o usuário.
Para a implementação da rede neural em lógica programável
Para a realização do treinamento da Rede Neural
Utilizado para desenvolvimento do programa assembly e C
para microcontrolador com núcleo 8051 da ATMEL
Tabela 7 - Linguagem de programação.
Linguagem
Assembly/C para 8051
MySQL
C/C++ para Microsoft Windows
C para ambiente do MatLab
Linguagem de descrição de hardware
Ferramentas de Software
Keil
DB Tools
Borland C++Builder
MatLab
Quartus II
38
3.5
Estudo de Viabilidade Técnico-econômica
O custo estimado do projeto pode ser verificado na tabela 8.
Tabela 8 - Tabela de custos.
Descrição
Qtde.
Horas de trabalho (aprox. 4 hrs/dia)
600
TUSB3410
1
AT89C51
1
Box para o circuito externo
1
Regulador de Tensão UA7833
1
Placa de desenvolvimento Nios, edição
1
Cyclone
Componentes Variados
1
Fonte 110V - 12V
1
*considerando US$ 1,00 = R$ 2,78 (18/3/05)
3.6
Custo Unitário
R$ 15,00
US$ 2,50*
R$ 9,00
R$ 25,00
US$ 0,25*
Total
R$ 9.000,00
US$ 2,50 *
R$ 9,00
R$ 25,00
US$ 0,25 *
US$ 1.022,30*
US$ 1.022,30*
R$ 50,00
R$ 10,00
Mão de Obra:
Materiais:
TOTAL:
R$ 50,00
R$ 10,00
R$ 9.000,00
R$ 2.943,63
R$ 11.943,63
Cronograma
Na tabela 9 são mostradas as principais atividades do projeto final com as
respectivas datas de entrega. E nas figuras 36 e 37 é apresentado o cronograma de
realização do projeto.
Tabela 9 – Eventos do Projeto Final.
Data
28/2/2005
28/3/2005
2/5/2005
10/10/2005
24/10/2005
7/11/2005
28/11/2005
12/12/2005
Atividade a ser apresentada
Entrega da proposta do projeto dentro do padrão específico
Entrega da especificação técnica do projeto
Entrega do projeto (monografia) e do resumo e abstract do artigo
para congresso
Apresentação do projeto implementado e qualificação para fase
final
Segunda apresentação do projeto implementado e qualificação
para fase final (decréscimo de 30% na nota)
Entrega da documentação completa em espiral para banca
examinadora (3 vias), contendo a monografia, manual técnico,
manual do usuário e artigo científico.
Defesa formal do projeto.
Entrega de toda a documentação do projeto, encadernado, em 2
vias, contendo a monografia, manual técnico, manual do usuário,
artigo científico. Mais CD contendo, no formato WEB, todo
conteúdo dos manuais.
39
Figura 36 - Cronograma do Projeto (parte I).
40
Figura 37 - Cronograma do Projeto (parte II).
41
4 PROJETO
4.1
Requisitos mínimos para funcionamento
Os requisitos mínimos de hardware para o funcionamento são:
•
Microcomputador funcionando a pelo menos 600MHz, com porta USB
(1.1).
Os requisitos de software:
4.2
•
Windows 98 e NT;
•
Windows 2000 e XP;
•
Banco de dados My-SQL;
•
MatLab.
Projeto de Hardware
O projeto de hardware é dividido em dois blocos, sendo um o módulo de
comunicação e outro o módulo da FPGA, como mostrado na figura 38.
Figura 38 - Divisão dos módulos de hardware.
42
O módulo de comunicação é composto de um μC e um conversor USB/Serial
(TUSB). Ele é responsável pelo controle da comunicação da FPGA com o PC, sendo a
“ponte da comunicação”.
Na tabela 10 á apresentado os sinais de controle da interface USB do PC
utilizados e na tabela 11 é apresentado os pinos do µC utilizados.
Tabela 10 - Sinais da comunicação com porta USB.
Sinais
DD+
GND
Responsabilidade
Sinais de dados
Sinais de dados
Terra
Tabela 11 - Pinos utilizados do µC.
Sinais
D0 a D7
WR
DIR
RX
TX
Port
P0
P1.0
P1.1
P3.0
P3.1
Pinos do µC
32 a 39
1
2
10
11
O µC tem como responsabilidade a transmissão de dados entre a FPGA e o PC.
Os dados enviados pelo PC são recebidos pelo conversor USB/Serial e enviados para
o µC pela interface serial. Para isso é implementado um conversor serial/paralelo no
µC.
Na figura 61 (anexo 1), é apresentada a forma de alimentação do µC, sendo feita
a partir de uma fonte de alimentação com tensão com valores entre 7 e 12V.
A figura 62 (anexo 1), apresenta o conversor USB/Serial. Sua saída é ligada
direto a porta serial do µC, apresentado na tabela 12.
Tabela 12 - Sinais da comunicação com µC.
Sinais
RX
TX
Responsabilidade
Recebe os dados da porta
Envia os dados da porta
43
O segundo módulo é o da FPGA que possui a rede neural LVQ. Na FPGA são
utilizados os pinos descritos na tabela 13.
Tabela 13 - Sinais da comunicação µC e FPGA.
Sinais
uC0 a uC7
WR
RD
Responsabilidade
Barramento de dados
Sinalização de chegada de dado
Sinaliza leitura da resposta da rede
Ativação
Barramento
↑ (Borda de subida)
1 (nível lógico alto)
FIM_DAT
Sinaliza final da leitura dos dados
A alimentação da placa da FPGA também é feita a partir de uma fonte externa, no
qual a entrada para a fonte está na própria placa, alimentado todos os componentes.
A figura 63 (anexo 1), apresenta os pinos utilizados da FPGA, que são
apresentados na tabela 14.
São necessários dois sinais de controle. Um deles para a comunicação paralela,
para sinalizar a chegada de um novo dado, esse sinal é ativo em nível lógico baixo,
sendo nomeado como WR, este sinal é apresentado na figura 65 (anexo 1). O outro
sinal de controle é o RD que é utilizado para a leitura dos resultados obtidos pela
classificação, ativo em nível lógico alto.
Tabela 14 - Pinos utilizados no FPGA.
Pinos
C18
C19
D18
D19
D17
D20
E17
F17
G15
G20
Nome
uC0
uC1
uC2
uC3
uC4
uC5
uC6
uC7
WR
RD
Função
Barramento de dados
0 (nível lógico baixo)
Para esta implementação é estimada a utilização dos componentes apresentados
na tabela 15.
Nas figuras 64 e 65 (anexo 2) são apresentados os layout das placas do módulo
de comunicação.
44
Tabela 15 - Componentes utilizados.
Itens
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
4.3
Parte
470R
470R
1K5
10K
33R
100K
4.7K
15K
33K
1µF
4.7µF
10µF
22pF
33pF
100nF
1N4148
AT89C51
74LS245
TUSB3410
UA78M33CKC
RD,
RST,
RESET
11.0592 MHz
12MHz
CN-USB
CONN
JACK
PWR
Display
Placa Nios
Referência
R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11
R12, R13, R14, R15, R16, R17, R18, R19, R20, R21
R26
R22, R23, R31, R33
R27, R28
R24, R25
R29
R30
R32
C6, C8, C10
C7, C11
C12
C1, C3, C13, C14
C2, C4
C5, C9
D1
U10
U9, U11
U6
U7, U8
Qtd
11
10
2
4
2
2
1
1
1
3
2
1
4
2
2
1
1
2
1
2
SW1, SW2, SW3
3
Y2
Y1
CN1
1
1
1
J3
1
U1, U2, U3, U4, U5
Placa de desenvolvimento
5
1
Projeto de Software
No PC há duas partes distintas implementadas: a primeira se refere ao software
que interage com o usuário (que realiza o envio de dados). E o segundo é a
implementação do treino do classificador LVQ no MatLab.
4.3.1 Software de Comunicação
Os principais casos de uso encontrados no software são apresentados na figura
66 (anexo 3).
Cadastrar Dados de entrada: responsável pelo cadastro de dados de entrada da
rede neural.
45
Configurar Parâmetros da rede: responsável pelos parâmetros de configuração da
rede neural no FPGA.
Comunicar com FPGA: responsável pela comunicação entre PC e a FPGA.
Para os casos de uso encontrados, as figuras 67, 68 e 69 (anexo 3) apresentam
os correspondentes diagramas de seqüência.
Os dados são persistidos para que sejam feitas futuras análises e o mesmo é feito
com os parâmetros de configuração da rede gerados pelo MatLab. É utilizado o modelo
relacional apresentado na figura 70 (anexo 3).
As principais classes que são utilizadas:
cPorta: responsável pela comunicação com a porta USB.
cDados: responsável pela dados de análise da rede neural.
cBrokerDados: broker responsável pela persistência dos dados de análise da rede
neural.
cConfiguracao: responsável pela configuração de parâmetros da rede neural na
FPGA.
cBrokerConfiguracao: responsável pela persistência dos dados de configuração
da rede neural.
cFileRW: responsável pela leitura e escrita de arquivos.
O relacionamento entre as classes é apresentado na figura 71 (anexo 3), que
mostra o diagrama de classes.
Nas figuras 72, 73, 74 e 75 (anexo 4) são apresentados os protótipos de tela do
software.
4.3.2 Treinamento do Classificador LVQ no MatLab
No PC também é feito o treino da rede LVQ no MatLab. A partir de uma
ferramenta disponível no software MatLab é realizado o treino. Essa ferramenta permite
criar uma rede do tipo LVQ, passar os parâmetros do treino e obter os centróides
(vetores de referência).
O algoritmo de treino da rede é descrito na figura 39. O treino é realizado
mediante o ajuste de pesos (vetores de referência) [MUKAI, 2001].
Para o treino realizado, os vetores de referência iniciais foram gerados utilizando
o comando fcm (fuzzy c-means) do MatLab, que permite encontrar um conjunto de
cluster para um dado conjunto de entrada, os parâmetros dessa função é a matriz de
46
dados e um número inteiro que corresponde ao total de clusters que serão
encontrados.
A partir dessa distribuição inicial dos vetores de referência (centróides ou cluster),
os parâmetros de treino são inicializados, como número máximo de épocas, coeficiente
de aprendizagem, percentual de dados pertencente a cada classe, e número de cluster.
Inicio
Inicializar vetores de referência
Inicializar taxa de aprendizado (n)
faça
Determinar j de tal forma que || x - Wj || seja um mínino.
Se T = Cj
Wj (novo) = Wj (anterior) + n [x - Wj (anterior)]
Senão
Wj (novo) = Wj (anterior) - n [x - Wj (anterior)]
Fim Se
Enquanto for falsa, repetir
Figura 39 - Algoritmo de treino do classificador LVQ.
4.3.3 Firmware
O firmware do µC é responsável por receber dados de uma porta serial, enviá-los
por uma porta paralela. A cada dado que o µC recebe, ele os envia para a porta P0 e
gera um pulso indicando a chegada de um novo dado para a FPGA.
A figura 40 apresenta o fluxograma da execução do µC.
A rede LVQ que é implementada em uma FPGA tem o funcionamento descrito na
figura 41 que mostra o diagrama de estados e na figura 42 é apresentado o diagrama
em blocos da rede LVQ em hardware.
A rede LVQ é baseada no cálculo de distância euclidiana. A rede define
centróides, que representam as diferentes subclasses. Para cada dado de entrada é
calculada a distância a cada um dos centróides, aquele que obtiver a menor distância
se torna a subclasses vencedora.
A rede LVQ desenvolvida tem capacidade de classificar no máximo 16 subclasses
com 16 dimensões.
47
Figura 40 - Fluxograma de processamento do µC.
Figura 41 - Diagrama de estados da rede neural LVQ.
48
Figura 42 - Diagrama em blocos da rede no FPGA.
O firmware completo da FPGA consiste em três partes: recepção dos dados (fase
A), processamento (fase B) e exibição dos resultados (fase C). Cada uma dessas fases
é exibida em um display para ser possível acompanhar o processo da FPGA.
A recepção dos dados é feita como descrita no diagrama de estados da figura 44.
Há opções que podem ser executadas: (1) recepção dos dados para análise, (2)
configuração da rede LVQ e (3) início do processamento. Essa máquina de estados
também tem a responsabilidade de sinalizar para as demais máquinas de estados qual
fase está sendo processada. Por exemplo, quando é iniciada a execução, ela gera um
sinal para a máquina de estados que controla o fluxo de execução da rede LVQ que já
pode iniciar o processo. Quando acontece o termino da execução dos dados, é esta
máquina de estados que sinaliza que os dados podem ser lidos.
Com a configuração da rede completa, o processamento pode ser iniciado.
Quando isso ocorre, há uma máquina de estados que controla a execução da rede,
disponibilizando os dados na entrada do classificador, e aguardando a resposta que é
gravada em um registrador, como descrito na figura 44.
Depois do fim do processamento de todos os dados, a FPGA aguarda um sinal de
leitura do resultado, e cada sinal desse exibe no display 7 segmentos a classe e o
correspondente dado. Esse processo é descrito na figura 43.
49
Figura 43 - Diagrama de estados da leitura dos resultados da classificação.
50
Figura 44 - Diagrama de estados de recepção e controle da execução.
51
4.4
Procedimentos de testes e validação do projeto
Para verificar o correto funcionamento do projeto, cada módulo é testado
isoladamente e ao final o conjunto. Os procedimentos para teste são descritos nas
seções a seguir.
4.4.1 Procedimentos de teste do módulo de comunicação
O módulo de comunicação tem a verificação de funcionamento com uma troca de
mensagens entre PC e µC.
Um dado é enviado por um software de teste pela porta USB, que aguarda o
recebimento de um dado vindo do µC. Para garantir que o dado enviado foi recebido
pelo µC e enviado ao PC corretamente, é somado o valor um ao dado, e enviado
novamente ao PC. Assim se o valor que chegar ao PC corresponder ao valor enviado
mais um, significa que a comunicação está correta. A tabela 16 apresenta um exemplo
de como é o teste de comunicação.
Tabela 16 – Seqüência de dados esperado pelo teste da comunicação.
Dado enviado pela PC Dado enviado pelo µC
A
B
a
b
1
2
4.4.2 Procedimentos de teste da comunicação entre PC e FPGA
O teste de recebimento de dados na FPGA é feito a partir de envio de uma
seqüência de dados pelo PC através do módulo de comunicação. Esses dados
enviados são exibidos em um display 7 segmentos para verificar se o valor enviado
realmente chega até o destino.
A figura 45 apresenta a transmissão de um dado para a FPGA e qual a
representação do resultado nos displays. O valor de teste deve ser entre 0 e 99, já que
há dois displays disponíveis na placa.
52
Figura 45 - Teste de envio de dado para a FPGA.
4.4.3 Procedimentos de teste para validação da rede LVQ na FPGA
A rede LVQ é validada realizando a classificação de uma função conhecida (uma
função lógica), e verificando se os valores de classes de saída correspondem ao valor
verdadeiro. Por exemplo, utilizando a função XOR, a partir de sua tabela verdade,
realizando o treino no MatLab, é enviando a rede a configuração obtida no treino
(vetores de referência e mapeamento das classes) e os dados para a análise (a própria
tabela verdade da função XOR, sem a resposta) como mostra a tabela 17, e verificando
se o resultado esperado pela rede é obtido.
Tabela 17 - Resultado esperado no teste da rede em hardware.
Vetores
Mapeamento Dado para Resultado
de
Subclasses
das classes
análise
Esperado
referência
A
B
A
B
1
1
1
1
1
1
1
1
2
2
2
1
2
2
2
1
3
2
2
1
2
2
2
4
1
2
2
1
53
5 RESULTADOS
Neste capitulo é apresentado os resultados obtidos em cada um dos módulos
implementados.
5.1
Comunicação USB → µC
Para testar a comunicação entre o PC e o módulo de comunicação, foi realizado
um teste, que consiste no envio de um dado do PC ao µC, e este deveria retornar o
valor enviado somando o valor um, assim comprovando que o valor realmente estava
sendo recebido, que poderia ser o próprio valor enviado lido do buffer da serial. Foi
verificado que a comunicação funcionou sem problemas.
5.2
Comunicação PC → FPGA
A comunicação entre o PC e a FPGA é realizado um teste, onde o PC faz o envio
de um dado pela porta USB, que é recebido no µC e este o envia para a FPGA que
exibe o valor no display 7 segmentos da placa.
Quando o µC recebe um novo dado, ele é movido para a porta P0 do e sinalizado
através do bit P1.0 que um novo dado válido está disponível. O sinal gerado pelo µC
pode ser visto na figura 46.
Figura 46 - Sinal gerado pelo µC para a FPGA.
54
Na figura 47, é apresentada a transmissão de um dado do PC para a FPGA e na
figura 48 a exibição deste valor no display da FPGA.
Figura 47 - Dado transmitido para a FPGA.
Figura 48 - Dado de teste da FPGA.
5.3
Treino no MatLab
O treino no MatLab da função XOR, depois de sucessivas tentativas, obteve-se os
seguintes resultados, apresentados nas figuras 49, 50, 51 e 52. Para cada uma das
figuras, um coeficiente de aprendizagem diferente foi usado. Sendo que para todos os
diferentes coeficientes de aprendizagem, utilizado o mesmo número de épocas no
treino, igual a 100 épocas. O resultado obtido no treino é apresentado como sendo o
resultado esperado (representado pelo símbolo +) e o resultado obtido (representado
pelo símbolo o).
55
Figura 49 - Resultado do treino com coeficiente de aprendizagem igual a 0,01.
56
Figura 52 - Resultado do treino com coeficiente de aprendizagem igual a 1.
57
5.4
Software
No software foram persistidos os dados que posteriormente são analisados pela
rede e os dados resultantes do treino no MatLab.
Na figura 53, as marcar vermelhas representam os dados que são enviados para
a FPGA. E a marca azul representa o resultado esperado do processamento da rede
LVQ na FPGA.
Figura 53 - Dados enviados para a FPGA.
5.5
Classificador LVQ em hardware
Para a validação e verificação de funcionamento do sistema foi submetido a uma
função com resposta conhecida, no caso a função XOR. A partir do resultado do treino
da função XOR no MatLab, foi simulado no software Quartus II.
A execução da rede LVQ na FPGA segue alguns passos. Primeiramente, é feita a
configuração da rede, com os parâmetros da rede (vetores de referência e
mapeamento das classes) e envio dos dados, como mostram as figuras 54 e 55.
58
Quando a configuração e recepção dos dados ocorrem corretamente, um flag
(WRITE_OK) é ativado, sinalizando que o processamento pode iniciar.
O processamento da função XOR na rede LVQ, considerando apenas o tempo de
processamento dos dados, a uma freqüência de 2 MHz na FPGA, tem duração de
aproximadamente 417 µs. Enquanto que a rede executada em um microcomputador
AMD Sempron 2 GHz com 256 MBytes de RAM, levou cerca de 1,688 ms, que mostra
grande vantagem da FPGA no processamento de uma rede neural deste tipo.
A rede LVQ implementada na FPGA tem capacidade de diferenciar até 16
classes, com 16 características.
Para implementação dessa rede foram utilizados os seguintes recursos da FPGA:
2352 bytes de memória RAM, apenas 6% do total da memória. 1042 LE (elementos
lógicos) que correspondem apenas a 5% do que disponível no dispositivo. E
considerando todos os sinais de controle, dados e bits utilizados na própria placa de
desenvolvimento do Nios, foram utilizados 115 dos 301 pinos do Cyclone disponíveis.
Na figura 56 é apresentado os recursos do chip Cyclone que foram usados. Pela
figura é possível observar que os recursos disponíveis no chip não foram totalmente
utilizados, o que permitiria um aumento na arquitetura da rede e maior número de
classes separáveis pela rede. O aumento no tamanho da arquitetura da rede implicaria
em aumento considerável do uso de memória e não do uso de elementos lógicos.
É possível verificar o total de memória necessária para implementar uma
arquitetura de rede maior, como mostra a equação 9. Sendo d o número de dimensões,
n o número de dados, I a largura dos dados e sc o número de subclasse.
[
Tmemoria = dl (n + sc + 1) + (n * sc )
]
(9)
Nas figuras 57 e 58 são apresentados os gráficos de uso da memória em bits
conforme o total de número de classes e dimensões para barramento 8 bits.
As figuras 59 e 60 mostram o número máximo de dados que pode ser configurada
a arquitetura de 8 bits com número de classes e dimensões para o dispositivo Cyclone
EP1C20F4400C7. Para a arquitetura implementada, é utilizado o número máximo de
128 dados (que corresponde a 2048 bytes) que podem ser enviados para análise, mas
esse número não representa o máximo suportado pelo dispositivo e o gráfico apresenta
os valores máximos para cada configuração de classes e dimensões.
59
Figura 54 - Processo de recepção dos dados.
60
Figura 55 - Fases do processo de classificação.
61
Figura 56 - Total do chip utilizado.
62
Figura 57 - Uso de memória (número de dimensões x número de classes – 3D).
Figura 58 – Uso de memória (número de dimensões x número de classes).
63
Figura 59 - Número máximo de dados para análise (3D).
Figura 60 - Número máximo de dados para análise.
64
6 CONCLUSÃO
Com a conclusão da implementação deste projeto, observou-se um resultado
satisfatório na rede neural em hardware, comprovando seu funcionamento.
Com o desenvolvimento desta arquitetura em VHDL, verificou-se que é um
processo bastante complexo.
Para continuação deste projeto, alguns pontos podem ser melhorados, como a
comunicação entre o PC e a FPGA bidirecional, que por falta de tempo hábil, foi
realizada a comunicação unidirecional. Isso seria interessante para possibilitar o
armazenamento dos resultados obtidos para posterior estudos e análises de
desempenho da rede.
Seria importante a implementação de uma rede neural mais robusta, já que a
implementada, tem como limitação o máximo de 16 classes e subclasses e 16
dimensões, com largura de dados de 8 bits, o que para a maioria dos problemas reais
acaba se tornando inviável sua solução. Mas caso aja necessidade de um barramento
de maior largura e mais memória para armazenamento de dados e vetores de
referência, para resolução de um problema específico, este é facilmente adaptado com
a arquitetura desenvolvida.
Essa área de pesquisa demonstra ser promissora, já que cresce a pesquisa de
reconhecimento de padrões. E, a FPGA se mostrou capaz de suprir as necessidades
de desempenho para o trabalho com redes neurais.
65
7 REFERÊNCIAS
Altera Corporation. Nios Development Board, Reference Manual, Cyclone Edition.
2004.
Altera Corporation. Nios Development Kit, Cyclone Edition, Getting Started User Guide.
2003.
Altera Corporation. FPGA Cyclone - DATASHEET. Datasheet da família Cyclone. [online]
Disponível
na
Internet
em
WWW
por
http://altera.com/literature/hb/cyc/cyc_c5v1_01.pdf (pesquisar realizada em 10 de
outubro de 2005).
Altera Corporation. Cyclone Device Handbook, Volume 1. [on-line] Disponível na
Internet em WWW por http://altera.com/literature/hb/cyc/cyc_c5v1.pdf (pesquisar
realizada em 10 de outubro de 2005).
AT89C51 – DATASHEET. Datasheet do AT89C51 da ATMEL. [on-line] Disponível na
Internet
em
WWW
por
http://www.atmel.com/dyn/resources/prod_documents/doc0265.pdf (pesquisar realizada
em 10 de maio de 2005).
BEYOND LOGIC. USB in a NutShell. [on-line] Disponível na Internet em WWW por:
http://www.beyondlogic.org/usbnutshell/usb2.htm ( pesquisar realizada em 10 de maio
de 2005).
BRAGA, Antônio de Pádua. “Redes Neurais Artificiais: Teoria e Aplicações”. LTC. Rio
de Janeiro. 2000.
KOHONEN, Teuvo. “Self-Organizing Maps”. 2. ed. Heidelberg: Springer-Verlag. 1997.
KUGLER, Mauricio. “Desenvolvimento de uma Rede Neural LVQ em Linguagem VHDL
para Aplicações em Tempo-Real”. Artigo publicado em VI Congresso Brasileiro de
Redes Neurais. São Paulo. 2003.
MUKAI, Ivana Naomi, PILLA, Valfredo Jr, LOPES, Heitor S. “Análise de peditórios no
domínio do tempo para classificadores LVQ de padrões de EEG relacionados ao
movimento”. Artigo publicado em CBRN – Congresso Brasileiro de Redes Neurais.
Curitiba. 2001.
PILLA, Valfredo Jr. “Detecção de Padrões Eletroencefalográficos Relacionados ao
Movimento para uma Interface Cérebro-computador”. Dissertação de mestrado.
Curitiba. CEFET-PR. 1999.
PILLA, Valfredo Jr, LOPES, Heitor S. “Análise de um classificador neural de sinais de
EEG na detecção de movimentos”. Artigo publicado em CBEB – Congresso Brasileiro
de Engenharia Biomédica. Curitiba. 2000.
RIBEIRO, Alexandre Alves de Lima. “Reconfigurabilidade dinâmica e remota de
FPGAs”. Dissertação de mestrado. ICMC – USP. São Paulo. 2002.
66
USP – Universidade de São Paulo. [on-line] Disponível em WWW
http://www.icmc.usp.br/~lcr/comp_reconfiguravel.htm (18 de março de 2005).
por:
TUSB3410 – DATASHEET. Datasheet do conversor USB/Serial. [online] Disponível na
Internet em WWW por: http://www-s.ti.com/sc/ds/tusb3410.pdf (pesquisar em 29 de
abril de 2005).