redes neurais artificiais aplicadas na construção de ... joão carlos testi ferreira júnior...

UNIVERSIDADE FEDERAL DE SANTA CATARINA

DEPARTAMENTO DE INFORMÁTICA E ESTATÍSTICA

SISTEMAS DE INFORMAÇÃO

Redes Neurais Artificiais Aplicadas na Construção de Exercícios

para Verificação de Aprendizagem

João Carlos Testi Ferreira

Júnior Barbosa Dymow

Florianópolis, outubro de 2005

ii





Trabalho de Conclusão de Curso submetido à Universidade Federal de Santa Catarina como

parte dos requisitos para a obtenção do grau de Bacharel em Sistemas de Informação.

Orientação:

Prof. Dr. Jovelino Falqueto

Banca Examinadora:

Profª. Drª. Edla Maria Faust Ramos

Profª. Drª. Rosane Porto Seleme Heinzen

Florianópolis, outubro de 2005

iii





Este Trabalho de Conclusão de Curso foi julgado adequado para a obtenção do título de

Bacharel em Sistemas de Informação, e aprovado em sua forma final pela Coordenadoria do

Curso de Bacharelado em Sistemas de Informação.

___________________________________________________

Orientador – Prof. Dr. Jovelino Falqueto

___________________________________________________

Co-orientador - Profª. Drª. Edla Maria Faust Ramos

___________________________________________________

Membro da Banca - Pro fª. Drª. Rosane Porto Seleme Heinzen

iv

AGRADECIMENTOS

Agradecemos ao apoio de nosso orientador, prof. Falqueto e à prof. Edla, não

somente pela orientação e apoio na elaboração deste trabalho, mas pelo prazer e

oportunidade de cursar disciplinas tendo-os como professores.

Agradecemos de forma especial a prof. Rosane, pois sem seu incondicional apoio não

teríamos atingido o objetivo do trabalho em área tão diversa de nossa formação. Sua

participação foi fundamental desde a proposição do assunto até a validação dos resultados

finais.

Lembramos ainda de todos os professores dos quais fomos alunos durante nossa

formação. Os conhecimentos adquiridos no decorrer do curso nos deram os subsídios

necessários para enfrentar este desafio.

Também lembramos com carinho de nossos familiares que nos apoiaram e

compreenderam nossa aventura no conhecimento.

v

SUMÁRIO

LISTA DE FIGURAS ........................................................................................................................VIII

RESUMO ...............................................................................................................................................IX

RESUMO ...............................................................................................................................................IX

ABSTRACT............................................................................................................................................ X

CAPÍTULO I ......................................................................................................................................... 11

1 INTRODUÇÃO ............................................................................................................................. 11

1.1 OBJETIVOS........................................................................................................................... 12

1.1.1 OBJETIVOS ESPECÍFICOS.............................................................................................. 12

1.2 MOTIVAÇÃO........................................................................................................................ 13

1.3 JUSTIFICATIVA ................................................................................................................... 14

CAPÍTULO II........................................................................................................................................ 15

2 INTELIGÊNCIA ARTIFICIAL ............................. ..................................................................... 15

2.1 REDES NEURAIS ARTIFICIAIS................................................................................................... 17

2.1.1 Rede Neural de uma Única Camada (Perceptron) ............................................................18

2.1.2 Rede Perceptron de Múltiplas Camadas (Multi-Layer Perceptron).................................. 19

CAPÍTULO III ...................................................................................................................................... 23

3 ENSINO À DISTÂNCIA............................................................................................................... 23

3.1 SOFTWARES EDUCACIONAIS.................................................................................................... 24

3.2 HIPERMÍDIA E HIPERTEXTO..................................................................................................... 25

3.3 ASPECTOS DE USABILIDADE .................................................................................................... 26

3.4 A DISCIPLINA DE NEUROANATOMIA ........................................................................................ 28

CAPÍTULO IV ...................................................................................................................................... 29

4 A BIBLIOTECA DE CLASSES PARA CONSTRUÇÃO DE RNAS ....................................... 29

4.1 COMPOSIÇÃO DOS PACOTES.................................................................................................... 30

4.1.1 O Pacote redeNeural ......................................................................................................... 31

4.1.2 O Pacote funcoesSaida ...................................................................................................... 31

4.1.3 O Pacote manipulacaoArquivos ........................................................................................ 32

4.1.4 O Pacote geradoresCódigo................................................................................................ 33

4.2 SEU USO EM APLICAÇÕES........................................................................................................ 33

vi

CAPÍTULO V........................................................................................................................................ 34

5 A APLICAÇÃO PARA GERAÇÃO DE REDES NEURAIS .................................................... 34

5.1 UTILIZANDO O GERADOR DE REDES NEURAIS......................................................................... 35

5.1.1 Configurando a Rede ......................................................................................................... 35

5.1.2 Lendo um arquivo de padrões............................................................................................ 37

5.1.3 Configurando Aspectos de Treinamento............................................................................ 38

5.1.4 Treinando a rede................................................................................................................ 39

5.1.5 Salvando o código fonte da rede treinada ......................................................................... 40

5.2 EXEMPLO DE APLICAÇÃO COM RNA NA DISCIPLINA DE NEUROANATOMIA ............................. 41

CAPÍTULO VI ...................................................................................................................................... 45

6 CONCLUSÕES.............................................................................................................................. 45

6.1 O GERADOR DE REDES NEURAIS............................................................................................. 45

6.2 O APLICATIVO PARA A DISCIPLINA DE NEUROANATOMIA ........................................................ 46

6.3 CONSIDERAÇÕES FINAIS.......................................................................................................... 47

7 REFERÊNCIAS ............................................................................................................................ 48

ANEXOS ................................................................................................................................................ 49

ANEXO 1 - DIAGRAMAS DE CLASSE ............................................................................................ 50

DIAGRAMA DE CLASSES DO PACOTE REDENEURAL .............................................................................. 50

DIAGRAMA DE CLASSES DO PACOTE FUNCOESSAIDA ........................................................................... 51

DIAGRAMA DE CLASSES DO PACOTE MANIPULACAOARQUIVOS........................................................... 52

DIAGRAMA DE CLASSES DO PACOTE GERADORESCODIGO.................................................................... 53

ANEXO 2 – PADRÕES DE TREINAMENTO DA APLICAÇÃO....... ............................................ 54

ANEXO 3 – DOCUMENTAÇÃO – FORMATO JAVADOC........... ................................................ 55

CLASS REDENEURAL ........................................................................................................................... 55

CLASS TREINAREDE............................................................................................................................ 66

CLASS PADROESTREINAMENTO........................................................................................................... 73

INTERFACE FUNCAOSAIDA .................................................................................................................. 76

CLASS FUNCAOSIGMOIDAL ................................................................................................................. 78

CLASS FUNCAOTANGHIPERB .............................................................................................................. 81

CLASS LEITORPADROES...................................................................................................................... 84

CLASS PERSISTENCIAREDE.................................................................................................................. 86

CLASS GRAVADORARQUIVOPESOS..................................................................................................... 89

CLASS GERADORCODIGO .................................................................................................................... 91

CLASS GERADORCODIGOJS................................................................................................................. 95

vii

CLASS GERADORCODIGOJAVA ............................................................................................................ 97

CLASS GERADORCODIGOCPP ............................................................................................................. 99

CLASS GERADORCODIGOOP ............................................................................................................. 102

ANEXO 4 – FUNÇÃO RNAMLP...................................................................................................... 104

ANEXO 5 – EXERCÍCIO COMPLETO HTML/JAVASCRIPT......... .......................................... 107

ANEXO 6 – QUESTIONÁRIO DE USO DO APLICATIVO HTML.... ........................................ 115

ANEXO 7 – CÓDIGO FONTE .......................................................................................................... 116

CLASSE REDENEURAL ....................................................................................................................... 116

CLASSE TREINAREDE ........................................................................................................................ 123

CLASSE PADROESTREINAMENTO....................................................................................................... 130

CLASSE FUNCAOSAIDA ...................................................................................................................... 132

CLASSE FUNCAOSIGMOIDAL ............................................................................................................. 133

CLASSE FUNCAOTANGHIPERB........................................................................................................... 134

CLASSE LEITORPADROES................................................................................................................... 135

CLASSE GRAVADORARQUIVOPESOS................................................................................................. 140

CLASSE PERSISTENCIAREDE.............................................................................................................. 143

CLASSE GERADORCODIGO ................................................................................................................ 148

CLASSE GERADORCODIGOJAVA ........................................................................................................ 150

CLASSE GERACODIGOOP.................................................................................................................. 154

CLASSE GERACODIGOCPP................................................................................................................ 158

CLASSE GERACODIGOJS ................................................................................................................... 162

CLASSE PRINCIPAL (INTERFACE GRÁFICA DA APLICAÇÃO) ................................................................ 166

viii

LISTA DE FIGURAS

Figura 1 - Esquema de Unidade McCulloch – Pitts ............................................................ 17

Figura 2 - Problema da Separabilidade Linear .................................................................. 19

Figura 3 - Perceptron de múltiplas camadas com uma camada escondida. Quatro.............. 20

variáveis de entrada, três variáveis de saída. Função de saída g(z) sigmoidal..................... 20

Figura 4 – Diagrama dos pacotes que compõem a biblioteca............................................. 30

Figura 5 – Diagrama simplificado de classes do pacote redeNeural .................................... 31

Figura 6 – Diagrama de classe simplificado do pacote funcoesSaida .................................. 32

Figura 7 – Diagrama simplificado de classes do pacote manipulacaoArquivos..................... 32

Figura 8 – Diagrama simplificado de classes do pacote geradoresCodigo ........................... 33

Figura 9 - Tela inicial do Gerador de Redes Neurais......................................................... 35

Figura 10 - Tela de Configurações da Rede...................................................................... 36

Figura 11 - Tela de Configurações do Treinamento........................................................... 38

Figura 12 - Gráfico de Evolução do Treinamento .............................................................. 40

Figura 13 - Aplicativo para Neuroanatomia em HTML e Javascript utilizando RNA............... 41

Figura 14 - Resultado do Exercício................................................................................... 42

ix

RESUMO

Podemos utilizar Redes Neurais Artificiais em praticamente qualquer área do

conhecimento. Esta se mostra muito eficiente no reconhecimento de padrões. A criação

destas redes, no entanto, normalmente é feita caso a caso. São construídas aplicações para

cada problema que queira se utilizar desta tecnologia. Hoje este tipo de tecnologia é

utilizada em diversas áreas. A união da IA com a WEB, através das RNA, pode ser muito

promissora, pois permite uma interatividade mais agradável, simplificada e com recursos

dinâmicos muito mais abrangentes. As características principais das RNA são as mesmas,

assim, estamos apresentando uma aplicação que permite a criação da RNA de forma

facilitada, fornecendo inclusive código fonte em algumas linguagens e/ou os pesos

resultantes do treinamento da rede para que tais configurações possam ser utilizadas em

uma aplicação desenvolvida em linguagem qualquer. Neste trabalho apresentamos um

exemplo de uso para ensino de Neuroanatomia pela WEB. No intuito de simplificar seu uso

para o usuário e também de reduzir o tamanho do código gerado, as RNA fornecidas pela

aplicação utilizam sempre a mesma função de saída. Esta não é uma limitação das RNA, mas

sim da aplicação, pois consideramos que o grau de dificuldade a ser imposto para o usuário

não justifica tal implementação.

x

ABSTRACT

Artificial Neural Networks can be used in almost every area of knowledge. They are

very efficient in the recognition of standards. Creating these networks, however, is a process

in which every case is separatedly evaluated. Applications are built for each problem where

this kind of technology can be used. Nowadays, this kind of techology is used in several

areas. The union between AI and WEB, by the ANNs, can be very agreeable, since it allows a

clean and pleasing interactivity, with several dynamic resources. The main issues of the

ANNs are always the same, so we are presenting an application which allows an easy way of

creating these networks. This application can also supply the source code and / or

generated weights of the RNAs for use in other applications written in other languages. This

monograph presents a WEB use example for the Neuroanatomy discipline.

In order to simplify the use and reduce the source codes's size, the ANNs supplied by the

application always use the same activation function. This is not a RNA limition, and was

implemented with the intention of making the user's interaction easier.

CAPÍTULO I

1 INTRODUÇÃO

Durante muito tempo, as possibilidades de ensino não presencial foram bastante

limitadas, pois se resumiam a materiais escritos enviados de forma postal. Com o forte

desenvolvimento da tecnologia da informação presenciado nos últimos anos, a realidade

hoje é outra: um aluno que tenha disposição de procurar, provavelmente vai encontrar na

Internet muito material que precisa para estudar determinado assunto, apesar de nem

sempre ser material confiável.

Entretanto, a existência da informação de fácil alcance não necessariamente resulta

em um aprendizado mais efetivo. Para que isto ocorra, ela deve estar organizada de forma

didática e interativa, fazendo com que o aluno mantenha a atenção no tema tanto quanto

em uma aula de qualidade ministrada presencialmente, com amplos recursos audiovisuais.

O ensino não presencial tem sido incentivado por diversos governos nos últimos

anos, pois além de complementar o aprendizado acadêmico, em diversas situações ele gera

economia para as instituições de ensino. Por exemplo, o uso de ambientes virtuais que

simulem um laboratório pode proporcionar uma “aula prática” sem que tenha sido necessário

o uso de laboratório, que dependendo da disciplina, pode ter restrições quanto à obtenção

de materiais e equipamentos.

Porém, em diversos ambientes de aprendizado on-line os exercícios para verificação

de aprendizagem são concebidos de forma pouco eficiente. De forma geral, o aprendiz

responde a algumas questões objetivas e no final o sistema retorna a pontuação atingida e a

alternativa correta de cada questão. Caso o usuário deseje realizar o teste novamente,

geralmente são apresentadas as mesmas questões. Isto direciona o usuário ao acerto sem

que o conteúdo tenha sido, de fato, compreendido pelo aprendiz, pois ele já poderá saber

qual a alternativa correta, ou no mínimo, que aquela selecionada anteriormente está

incorreta.

Desta forma, pretende-se no presente trabalho utilizar Redes Neurais Artificiais no

processo de elaboração de exercícios para verificação de aprendizagem, permitindo que

estes sejam concebidos de forma dinâmica.

12

Como exemplo de aplicação desta tecnologia, será criado um exercício para avaliação

de aprendizagem em uma disciplina de Neuroanatomia, o qual funcionará em ambiente Web.

O fato de ter-se escolhido esta disciplina como ambiente de aplicação prática do uso

de uma RNA deu-se principalmente pelos seguintes motivos:

• Há interesse de utilizar um ambiente virtual para aprendizagem na UFSC nesta

área, o que torna mais objetiva a aplicação de exercícios on-line, e já existe um

trabalho com um tutorial sobre o tema, não sendo necessário, portanto,

desenvolver toda uma plataforma web para este fim. Será necessário apenas

integrar o módulo de exercícios à aplicação existente.

• Com base em diagnóstico (áreas afetadas do cérebro) identificar sintomas é um

caso que se encaixa perfeitamente ao uso de RNAs, pois depende de entradas

(áreas afetadas) e saídas (sintomas) bem definidas. É possível ainda fazer-se

uma inferência na ordem inversa: Dados os sintomas, pode-se identificar o

diagnóstico do paciente.

A obtenção de material para análise, em aulas práticas, é bastante restrita. Desta

forma, uma ferramenta computacional interativa que permita minimizar o uso de tais

materiais é de grande utilidade, pois evita problemas como custo de obtenção de cadáveres

para dissecação, alocação de laboratórios, possíveis problemas respiratórios causados pela

exposição continuada ao formol, etc. A própria extração do cérebro de um cadáver é uma

operação bastante delicada, e segundo Heinzen, não raro são os casos nos quais os órgãos

são danificados durante o procedimento.

1.1 OBJETIVOS

O objetivo do trabalho é a criação de uma aplicação que gere redes neurais artificiais

para serem utilizadas em exercícios mais adequados ao ensino a distância.

Devido às características de uma rede neural artificial, estas podem ser utilizadas

para qualquer fim para os quais estas sejam treinadas, entretanto este trabalho será voltado

na demonstração de seu uso na construção de exercícios.

1.1.1 OBJETIVOS ESPECÍFICOS

a) Desenvolver uma biblioteca de classes JAVA para construção de redes neurais artificiais.

Estas classes devem permitir a construção de uma rede neural de múltiplas camadas

qualquer (Multi-Layer Perceptron), permitir seu treinamento pelo método de retro-

13

propagação (Backpropagation), possibilitar seu salvamento em arquivo, e gerar arquivos

com o seu código fonte em linguagens de alto nível bem como uma linguagem de script

para uso na WEB;

b) Criar uma aplicação com interface gráfica, fazendo uso da biblioteca desenvolvida. Esta

aplicação deverá permitir a criação de redes neurais artificiais que permita, após

seutreinamento, gerar o código fonte em linguagens de alto nível em arquivo texto;

c) Elaborar um exercício em ambiente WEB utilizando-se do código gerado pela aplicação a

fim de demonstrar a sua aplicabilidade.

1.2 MOTIVAÇÃO

A Inteligência Artificial é uma área que fascina por ser aplicável a praticamente

qualquer área ou tema. Stuart Russell e Peter Norvig citam, na introdução de seu livro

“Inteligência Artificial”, que “... a IA é citada regularmente como ‘o campo em que eu mais

gostaria de estar’ por cientistas de outras disciplinas...”1. O interesse pela

interdisciplinaridade como forma de busca do conhecimento, construção de novas idéias,

solução de problemas, encontra na IA uma forte aliada. Usar IA para o ensino é uma boa

estratégia para tornar mais agradável a apresentação do modelo de aprendizagem, fazendo

que o aluno possa ter uma melhor interatividade com a ferramenta que lhe é oferecida.

A idéia do uso de IA na elaboração de exercícios de verificação de aprendizagem

surgiu ao constatar-se que a avaliação de conhecimento é um fator crítico em diversos

sistemas que se propõem ao ensino a distância, dadas as limitações apresentadas

anteriormente. Além disso, influiu na decisão de abordar este assunto o fato de podermos

contribuir com um trabalho já existente desenvolvido pela professora Rosane Porto Seleme

Heinzen em sua tese de doutorado, sobre uma aplicação para ensino de Neuroanatomia.

É interessante destacar que a área da saúde, em nível nacional, utiliza-se de alta

tecnologia na parte curativa da ciência. Entretanto, quanto à questão de ensino, as

tecnologias utilizadas estão muito aquém do desejável. Ferramentas interativas que

permitam simulações de situações reais podem trazer diversos benefícios educacionais e

econômicos. Obviamente, tais ferramentas dificilmente substituirão completamente uma

situação real. A idéia é apenas ter-se uma alternativa a ela.

1 RUSSELL, Stuart; NORVIG, Peter. Inteligência Artificial. Introdução.

14

1.3 JUSTIFICATIVA

O uso da WEB como auxiliar no ensino apresenta diversas vantagens que podem ser

aplicadas em algumas disciplinas, como a redução da necessidade de alocação de

laboratórios, da presença de professores em tempo integral e de aquisição de alguns

materiais. No caso específico da Neuroanatomia, há restrições do uso de peças anatômicas

pela sua pouca durabilidade, dificuldade de obtenção, possibilidade de contaminação e

indisponibilidade de auxílio aos alunos por parte de um monitor, visto a dificuldade de

alocação de pessoal para trabalhar em laboratórios de anatomia.

Mas para que tal forma de ensino possa ser viável, um ambiente que tenha este

propósito deve proporcionar mais do que apenas a exposição do conhecimento. Deve

interagir com o aluno, tornando-os co-autores da comunicação e da aprendizagem.

Conforme constata HEINZEN, “Observa-se uma ausência quanto à disponibilização de

ambientes virtuais inteligentes em disciplinas morfológicas nos cursos das áreas médicas e

biomédicas, com especial atenção à Neuroanatomia, uma vez que os sistemas de multimídia

disponíveis no mercado, são de difícil acesso aos alunos e professores, pelo alto custo

(BRYAN, 2001), incompatibilidade de material técnico, e por serem editados em diferentes

idiomas, além de apresentarem situações dissociadas da realidade brasileira (VILLELA,

1993)2”.

O uso de IA Conexionista para este trabalho, através de Redes Neurais Artificiais do

tipo Perceptron com múltiplas camadas, deve-se ao fato dos exercícios a serem propostos

tratarem de identificação de padrões (por exemplo, a partir de determinados sintomas,

identificar as possíveis áreas afetadas do cérebro), onde este tipo de abordagem é o mais

indicado por ter um algoritmo de funcionamento mais simples e apresentar uma alta

eficiência. A principal limitação desta abordagem é que ela pode ser vista com uma “caixa

preta”. A partir dos dados de entrada obtemos uma saída, mas não é possível identificar a

razão pela qual se chegou àquele resultado.

2 HEINZEN, Rosane Porto Seleme. Modelo de ambiente virtual para a aprendizagem de Neuroanatomia. Introdução.

15

CAPÍTULO II

2 INTELIGÊNCIA ARTIFICIAL

Por muito tempo não se acreditou ser possível simular a inteligência em uma

máquina. Ainda há muita discussão sobre o que pode ser considerado como inteligência, de

fato. Vamos definir melhor, então, estas palavras:

“A palavra inteligência vem do latim inter (entre) e legere (escolher). Inteligência significa aquilo que permite ao ser humano escolher entre uma coisa e outra. Inteligência é a habilidade de realizar de forma eficiente uma determinada tarefa.” “A palavra artificial vem do latim artificiale, significa algo que não é natural, isto é, produzido pelo homem. Portanto, inteligência artificial é um tipo de inteligência produzida pelo homem para dotar as máquinas de algum tipo de habilidade que simula a inteligência do homem.3”.

O estudo da simulação da inteligência humana teve como seu precursor o trabalho de

Warren McCulloch e Walter Pitts, em 1943, onde eles propuseram um modelo matemático

para um neurônio. Através dos estados “ligado” ou “desligado”, uma “rede” de neurônios

poderia dar passagem a um sinal, desde que estivesse suficientemente estimulado. A partir

desta idéia, haveria meios de “treinar” esta rede para que esta pudesse, por exemplo, ser

utilizada no reconhecimento de padrões.

A partir de então diversos trabalhos surgiram, os quais poderiam ser hoje

classificados como IA. Entretanto Alan Turing foi o pioneiro no sentido de articular uma visão

completa sobre o tema em seu artigo “Computing Machinery and Intelligency”, publicado em

1950.

A literatura indica que o termo “Inteligência Artificial” data de 1956, sugerido por

John McCarthy, em um seminário organizado em Dartmouth, mas o próprio MacCarthy não

garantiu não ter ouvido ainda esta expressão. Neste seminário, dois pesquisadores do

Carnegie Tech, Allen Newell e Herbert Simon, apresentaram um programa de raciocínio, o

Logic Theorist, que era capaz de demonstrar teoremas matemáticos.

3 FERNANDES, Ana Maria da Rocha. Inteligência artificial: noções gerais. Cap. 1.

16

FERNANDES, citando SIMON e GANASCIA(1993)4 aponta, a partir dos diversos

campos de estudo, quatro abordagens para a IA:

• Cognitiva – Também conhecida como descendente ou simbólica, procura

reproduzir a forma de raciocínio humano, baseando-se em aspectos psicológicos e

algorítmicos. Os pioneiros neste tipo de abordagem foram John McCarty,

Marquem Minsky, Newell e Simon. Modelos de referência:

o Sistemas Baseados em Regras – Implementam comportamentos

inteligentes de especialistas humanos.

o Raciocínio Baseado em Casos – Problemas são resolvidos a partir da

consulta de casos já solucionados anteriormente, adaptando tais soluções

ao problema atual.

• Conexionista – Também denominada de biológica ou ascendente, procura

reproduzir o modelo de funcionamento do cérebro. Os primeiros a utilizar esta

abordagem foram McCulloch, Pitts, Rosenblatt e Widrow. Modelo de referência:

o Redes Neurais Artificiais – São conhecidas também como Redes

Neuronais, Modelo Conexionista, Neurocomputação, Modelo de

Processamento Paralelo Distribuído, Sistemas Neuromórficos e

Computadores Biológicos. Seu modelo de funcionamento consiste na

modelagem de prognóstico a partir do ajuste repetido de parâmetro.

• Evolucionista – Procura reproduzir a inteligência com base em mecanismos

evolutivos biológicos. Modelos de referência:

o Algoritmo Genético – Modelo de aprendizagem baseado na teoria de

seleção natural de Charles Darwin, onde apenas os indivíduos mais aptos

sobrevivem. Computacionalmente, os indivíduos são representados por

cromossomos que simulam o processo evolutivo;

o Programação Genética – Campo de estudo da IA voltado para a

construção de programas que visam imitar o processo natural da genética.

o Programação Evolutiva – Assemelha-se aos algoritmos genéticos,

dando maior ênfase na relação comportamental entre os parentes e seus

descendentes.

4 FERNANDES, Ana Maria da Rocha. Inteligência artificial: noções gerais. Cap. 1, p. 3, 4.

17

• Estatístico / Probabilístico – Utiliza modelos estatísticos para executar tarefas

de descoberta de conhecimento. Modelo de referência:

o Lógica Fuzzy – Também conhecida como lógica nebulosa, serve para

representar, manipular e modelar informações incertas.

2.1 Redes Neurais Artificiais

A IA Conexionista baseia-se na idéia de que se conseguirmos reproduzir o modelo do

cérebro humano, faremos emergir um comportamento inteligente deste modelo.

Três conceitos são essenciais para a compreensão das RNAs:

� Neurônio – Unidade computacional básica da rede;

� Arquitetura – Estrutura topológica pela qual os neurônios estão conectados;

� Aprendizagem – Processo que faz com que a rede se adapte para realizar uma

tarefa.

Existem algumas definições sobre o que é exatamente uma RNA. Segundo Kohonen

(1972) elas são redes massivamente paralelas e interconectadas, as quais interagem com o

mundo real da mesma forma que o sistema biológico. Já para Lippman (1997), RNAs são

sistemas físicos que podem adquirir, armazenar e utilizar conhecimentos experimentais.

Figura 1 - Esquema de Unidade McCulloch – Pitts

Uma RNA é composta por várias unidades de processamento, os neurônios, conforme

podemos ver na Figura 1. Estes são interconectados por canais de comunicação que

possuem um certo peso, representados na figura pela letra w. Cada neurônio realiza

operações apenas sobre as entradas (x) recebidas por suas conexões. De modo geral o

18

comportamento inteligente RNA é fruto das interações entre os neurônios. McCulloch e Pitts

resumem a operação do neurônio da seguinte forma:

• Um neurônio recebe um conjunto de sinais (x);

• Cada sinal é multiplicado por um número (w), proporcional à sua influência no

resultado final;

• É feita a soma ponderada dos sinais (Σ). Em seguida é aplicada sobre o resultado

uma função de saída. Se a saída desta função for superior a um limite estipulado –

função de limiar (threshold), é gerada uma saída excitatória (presença de sinal na

saída) ou inibitória (ausência de sinal na saída).

2.1.1 Rede Neural de uma Única Camada (Perceptron)

Uma RNA na qual as entradas estão diretamente conectadas às saídas, sem estágios

intermediários, é chamada de Rede Neural de uma Única Camada ou Rede Perceptron.

Embora este modelo de rede tenha a capacidade de representar funções booleanas bastante

complexas como a Função Maioria (saída 1 somente se mais da metade das entradas é igual

a 1), Minsky e Papert provaram que, independente do algoritmo de aprendizagem aplicado,

este modelo é incapaz de resolver problemas cujo plano de respostas não seja linearmente

separável, conforme podemos ver na Figura 2. Um exemplo disto é a função Ou Exclusivo

(XOR), que gera uma resposta 0 quando duas entradas X e Y forem iguais e resposta 1

quando X e Y tiverem valores diferentes. Podemos observar na Figura 2 que não podemos

“separar a área de respostas corretas” através de uma linha reta para o Ou Exclusivo.

19

Figura 2 - Problema da Separabilidade Linear

Esta limitação restringia bastante a aplicação prática de RNAs, fazendo com que os

estudos sobre o assunto despertassem pouco interesse durante a década de 70 e o início

dos anos 80.

2.1.2 Rede Perceptron de Múltiplas Camadas (Multi-Layer Perceptron)

A deficiência das redes de uma única camada foi superada, nos anos 80, por

Rumelhart, Hinto e Williams, através da inclusão de camadas intermediárias de neurônios e

de um algoritmo de aprendizagem por retro-propagação para correção de erros, conforme

podemos ver na Figura 3. Outra característica deste tipo de rede é o fato de que todos os

neurônios de uma camada estão diretamente conectados a todos os neurônios das camadas

vizinhas, tornando-a uma rede totalmente conectada.

Conforme podemos ver na Figura 3, as camadas das redes Perceptron de múltiplas

camadas (Multi-Layer Perceptron - MLP) são as seguintes:

• Camada de Entrada (x)– Onde os padrões são apresentados à rede;

• Camada(s) Intermediária(s) ou Escondida(s) (h)– Esta camada é a principal

responsável pela identificação de características dos padrões.

• Camada de saída (d)– Onde o resultado final é apresentado.

20

Figura 3 - Perceptron de múltiplas camadas com uma camada escondida. Quatro

variáveis de entrada, três variáveis de saída. Função de saída g(z) sigmoidal

• Algoritmo de Aprendizagem por Retro-propagação

Para que uma rede “aprenda” a identificar um padrão, primeiramente ela deve ser

treinada. Este treinamento ocorre da seguinte forma: é apresentado à rede um conjunto de

dados sabidamente corretos (padrão = entradas e suas saídas esperadas). Os sinais gerados

pelo padrão de entrada são processados por cada camada, redimensionados pelos pesos de

cada conexão (simulando a idéia da plasticidade das sinapses – ligações entre neurônios

biológicos) e por fim é gerada uma saída. Esta é comparada ao valor esperado, e se não

estiver correta, um valor de erro é calculado. Com base neste erro, são arbitradas correções,

as quais são propagadas a partir da saída até a camada de entrada, fazendo com que os

pesos das conexões sejam modificados. Com os novos pesos ajustados, o processo

recomeça e é refeito até que o erro detectado seja aceitável.

Conforme FALQUETO (apud Freemann), podemos definir o algoritmo de treinamento

em passos genéricos:

“...

0 – inicializar os pesos WHji e WO

kj com elementos aleatórios

21

1 – aplicar o vetor de entrada do padrão p: Xp=(Xp1, Xp2, ... Xpn)

aos nós de entrada

2 – calcular os somatórios ponderados que chegam aos nós

escondidos: netHpj = ΣN

i=1 WHij Xpi + βj (nó de viés), j = 1, ..., L

3 – calcular as saídas dos nós hpj = fHj(netH

pj)

4 – ir para a camada de saída O, calcular os somatórios

ponderados que chegam aos nós de O netOpk = ΣL

j=1WOkj hpj +

βOk (nó de viés), k = 1, ..., M

5 – calcular as saídas de Opk = fOk(netOpk)

6 – calcular as correções dos erros nos nós de saída (O)

WOkj(t+1) = WO

kj(t) + η(YpkOpk) f’Ok(netOpk) hpj

∆Opk = (Ypk – Opk) f’Ok(netO

pk)

7 – calcular as correções dos erros da camada escondida (H)

∆Hpj = f’Hj(netH

pj) Σ(∆Opk WO

kj)

(notar que a atualização dos pesos da camada (I· H) depende

de todas as parcelas de erro na camada de saída):

WHji(t+1)=WH

ji(t)+ηf’Hj(netHpj) xi Σ(Ypk Opk)f’Ok(netO

pk)WOkj

...”

• Características do Treinamento por Retro-propagação

O algoritmo de Aprendizagem por Retro-propagação implementa um gradiente

descendente no quadrado da soma do erro em funções lineares (função de saída). O

resultado obtido é utilizado para corrigir os pesos. Somente uma parte do resultado é

utilizado. Para isso é utilizado um multiplicador entre 0 e 1, chamado neste algoritmo de

fator de aprendizagem. Quanto maior o multiplicador, mais rápido será a aprendizagem da

rede, pois maior parcela do fator de correção será aplicada. Entretanto, um valor muito alto

pode implicar em oscilação do treinamento, podendo até fazer com que a rede nunca seja

treinada. Um treinamento mais lento, ou seja, com um multiplicador pequeno, tende a ser

mais eficiente, garantindo uma melhor convergência para o resultado. Um problema que

pode ocorrer com um multiplicador muito pequeno, no entanto, é o super-treinamento.

Como o processo de aprendizagem acontece lentamente, a rede acaba perdendo a

capacidade de generalizar resultados, passando a ser eficiente somente nos padrões

utilizados no processo de treinamento. Assim, devemos ter como objetivo usar o maior

22

mutiplicador possível, mas que não deixe a rede em oscilação no treinamento. Um número

que costuma ser bom é o multiplicador (fator de aprendizagem) 0,25.

Outro fator importante na rede é a quantidade de nós intermediários (camada

escondida) que devem ser utilizados. A quantidade de nós a serem utilizados ainda não é um

tema muito bem compreendido. FALQUETO sugere em sua tese, como uma tentativa inicial,

o uso da média aritmética do número de nós das camadas de entrada e saída.

A quantidade e qualidade dos padrões a serem utilizados no processo também têm

relação direta com o sucesso do treinamento. Quanto mais diversificados forem estes

padrões, maiores as chances de se obter bom resultado. Nem sempre dispomos de um

conjunto adequado de padrões, sendo esta uma das grandes limitações do uso de redes

neurais.

23

CAPÍTULO III

3 ENSINO À DISTÂNCIA

O uso da Internet com aplicações WEB para ensino tem crescido nos últimos anos. A

idéia de ensino a distância não é nova, desde os anos 50 existiam cursos oferecidos à

distância onde a comuinicação se dava com o uso do correio. Através destes cursos por

correspondência as pessoas buscavam qualificar-se em alguma atividade. A procura por

estes dava-se principalmente nos locais onde cursos presenciais não eram oferecidos. Havia

muito preconceito com esta forma de ensino, pois existiam várias deficiências relacionadas a

ele. A começar quando o aluno tivesse dúvidas. Este teria que encaminhar uma carta e

aguardar a resposta, prejudicando em muito a eficiência do método. Outro fator era a

limitação dos recursos didáticos, pois todo o tema a ser estudado seria abordado por meio

de apostilas (mais tarde foram oferecidos cursos por meio de discos de vinil, fitas cassete e

fitas de vídeo), com recursos de apresentação bastante limitados.

Com o avanço tecnológico e da comunicação, a idéia de ensino à distância começa a

ganhar maior credibilidade, pois já existem meios do aluno tirar suas dúvidas no momento

em que elas surgem, e os meios de apresentação já podem ser bastante ricos, utilizando

textos, hipertextos, imagens, sons, vídeos e teleconferências. O ambiente de aprendizagem

pode ser configurável, adaptável ao aluno e às suas necessidades.

O uso de Inteligência Artificial é outra forma de melhorar a interatividade do aluno

com o curso oferecido. Quando usamos o termo “Tutorial Inteligente” estamos informando

que o tutorial faz uso de algum tipo de Inteligência Artificial. Com ela é possível melhorar a

adaptabilidade do ensino, corrigir formas de navegação através do curso, elaborar melhores

exercícios, tornar mais agradável a forma de apresentação do conteúdo. Este trabalho

apresenta o uso da IA na elaboração de exercícios, permitindo que estes sejam mais

eficientes, trabalhando com uma gama maior de variáveis de forma a torná-los mais

flexíveis, agradáveis e instrutivos.

24

3.1 Softwares Educacionais

De acordo com a proposta de Thomas Dwyer (em Galvis, 1988), podemos classificar

as aplicações computacionais para uso educativo em dois grupos: software com enfoque

algorítmico e software com enfoque heurístico. RAMOS define o primeiro caso como sendo

“predominante a ênfase na transmissão de conhecimento do sujeito que sabe para o sujeito

que deseja aprender. Neste caso, a função do criador do software é projetar uma

seqüência bem planejada para a apresentação do conteúdo. Este deve ser subdividido em

pequenas doses e permeado de atividades que exijam uma resposta ativa em cada etapa,

proporcionando avaliação imediata desta resposta juntamente com atividades de reforço (ou

feedback). Espera-se com isto conduzir o aprendiz a um objetivo previamente determinado”.

Quanto ao enfoque heurístico, ainda segundo RAMOS, “... o aspecto predominante é a

aprendizagem experimental ou por descobrimento, devendo o software criar um ambiente

rico em situações que o aluno deve explorar conjecturalmente 5”.

O aplicativo com o qual estamos trabalhando, oriundo da tese de doutorado de

Heinzen, tem características claras de um enfoque algorítmico e determinístico, pois se trata

de um tutorial. Entretanto, na parte de aplicação de exercícios, onde serão utilizadas as

RNAs, tem-se um enfoque muito mais heurístico, pois o sistema gerará um diagnóstico

aleatoriamente, e caberá ao aluno indicar os sintomas do paciente. Em aplicativos similares

que não utilizam RNAs, um problema na aplicação de exercícios ocorre quando o aluno erra

a resposta de uma questão e o sistema então realiza a mesma pergunta novamente. Por

tentativa e erro, o aluno em determinado momento acertará a questão. Com uma RNA bem

treinada, os parâmetros de um exercício (valores e condições fornecidas) poderão ser

gerados de forma aleatória, e o aluno terá diante de si sempre situações inéditas, o que

exigirá dele real conhecimento sobre o problema para solucioná-lo.

Embora existam muitas críticas quanto a aplicações educacionais algorítmicas,

existem situações onde realmente é necessário hierarquizar e direcionar o modo de

aprendizado, principalmente quando não existe nenhum conhecimento prévio do aprendiz

quanto ao assunto abordado. Mas na aplicação dos conhecimentos supostamente adquiridos,

5 RAMOS, Edla Maria Faust. Análise ergonômica do sistema hiperNet buscando o aprendizado

da cooperação e da autonomia. Cap. 5

25

exercícios gerados com o auxílio de RNAs podem realmente tornar o processo de

aprendizado mais dinâmico e interessante, criando situações não previamente planejadas.

3.2 Hipermídia e Hipertexto

Em um ambiente de ensino não presencial, deve-se observar que manter o interesse

de quem está estudando é um fator fundamental para que o método seja eficaz. Mesmo em

aulas presenciais, muitas vezes é difícil ter-se uma visão mais concreta do assunto em

questão sem uso de recursos audiovisuais. Em ensino a distância, estes recursos têm sua

importância ainda mais acentuada, pois diversas vezes uma imagem é fundamental para que

se possa entender determinado conceito. Neste fator, a Internet leva uma grande vantagem

quanto aos outros métodos de ensino a distância, pois conta com interatividade a partir de

dispositivos de hipermídia. Esta une os conceitos de não-linearidade, hipertexto, interface e

multimídia numa só linguagem. Diferentemente de multimídia, hipermídia não é a mera

reunião de mídias existentes, e sim a fusão destas a partir de elementos não-lineares.

Uma forma bastante comum de Hipermídia é o Hipertexto, sistema para a

visualização de informação cujos documentos contêm referências internas para outros

documentos (chamadas de hiperlinks ou simplesmente links). Antes mesmo do advento da

popularização da Internet e de outros ambientes hipermidiáticos, Pierre Lévy elaborou em

1990 uma definição para o termo “hipertexto” ainda totalmente aplicável aos ambientes

interativos hoje existentes: “Tecnicamente, um hipertexto é um conjunto de nós ligados por

conexões. Os nós podem ser palavras, páginas, imagens, gráficos ou partes de gráficos,

seqüências sonoras, documentos complexos que podem eles mesmos ser hipertextos. Os

itens de informação não são ligados linearmente, como em uma corda com nós, mas cada

um deles, ou a maioria, estende suas conexões em estrela, de modo reticular. Navegar em

um hipertexto significa portanto desenhar um percurso em uma rede que pode ser tão

complicada quanto possível. Porque cada nó pode, por sua vez, conter uma rede inteira 6”.

A não linearidade inerente a estas tecnologias permite ao aluno estudar conteúdos

sem que seja necessário seguir um roteiro rigoroso. Entretanto é necessário observar,

durante a criação de conteúdos dinâmicos, a correlação entre links disponíveis e o assunto

abordado, de forma que exista sempre uma lógica a ser seguida.

6 LÉVY, Pierre. As Tecnologias da Inteligência. Cap. 2

26

Quanto ao aprendizado, diversos autores defendem que a participação do aluno no

processo e a qualidade de aprendizagem estão diretamente conectadas. Pierre Lévy

argumenta que “O hipertexto ou a multimídia interativa adequam-se particularmente aos

usos educativos. É bem conhecido o papel fundamental do envolvimento pessoal do aluno

no processo de aprendizagem. Quanto mais ativamente uma pessoa participar da aquisição

de um conhecimento, mais ela irá integrar e reter aquilo que aprender. Ora, a multimídia

interativa, graças a sua dimensão reticular ou não linear, favorece uma atitude exploratória,

ou mesmo lúdica, face ao material a ser assimilado. É, portanto, um instrumento bem

adaptado a uma pedagogia ativa 7”.

3.3 Aspectos de Usabilidade

A liberdade de acesso em ambientes hipermidiáticos tem seu preço: quanto mais

opções existem para acessar as informações, maiores serão as quantidades de decisões que

o usuário deverá tomar. Isto pode muitas vezes caracterizar um problema de usabilidade,

pois se determinado recurso não é devidamente descrito ou não está visível de forma clara,

ou ele não será utilizado ou o será de forma errônea. Desta forma, deve-se também

observar layout das páginas, significância de ícones, intuitividade na navegação, dicas (hints)

explicativas em cada recurso disponível, entre outros fatores, de forma que o usuário tire o

máximo proveito do ambiente oferecido, evitando assim que ele o abandone devido a

frustrações no uso deste.

Na área de psicologia cognitiva, é interessante ressaltar algumas considerações feitas

por Barthet (1988:20): Que existem diferentes usuários, os quais não utilizam a mesma

lógica em uma determinada tarefa; que existe uma diferença fundamental entre a lógica de

funcionamento do computador e a lógica de utilização do computador pelos homens; que se

deve distinguir entre as tarefas previstas e as efetivamente executadas pelo usuário. Ele

ainda propõe três modelos de representação de um sistema: a conceitual (que descreve a

lógica geral do software), a interna (ponto de vista do programador) e externa (ponto de

vista do usuário). Dificilmente a visão sistêmica do usuário, mesmo sob a ótica da lógica de

utilização, será parecida com a do programador.


27

Seguindo a premissa de que a interação humana em diferentes contextos deve ser

considerada na elaboração de um sistema hipermidiático, Pierry Levy (1990) ressalta que

“(...) pessoas diferentes irão atribuir significados por vezes opostos a uma mensagem

idêntica. Isto porquê, se por um lado o texto é o mesmo para cada um, por outro o

hipertexto pode diferir completamente. O que conta é a rede de relações pela qual a

mensagem será capturada, a rede semiótica que o interpretante usará para captá-la 8”.

Coutaz (1990) faz uma relevante observação quanto aos desenvolvedores de

ferramentas: para atingir-se o objetivo concebido, na interação com o usuário a ferramenta

deve conduzi-lo a este objetivo.

Diante disso, utilizaremos alguns critérios de usabilidade propostos por Scapin e

Bastien no projeto do software gerador de RNAs:

• Condução: O usuário deve saber onde está e que caminhos poderá tomar. É

necessário que o aplicativo disponibilize de forma clara as ferramentas disponíveis

e as formas de acessá-las. Outro fator importante é o feedback imediato. Quando

o usuário realiza uma ação, o software deve informá-lo prontamente sobre o

andamento da tarefa solicitada. O agrupamento de itens na interface também é

um aspecto que deve ser considerado. Mesmo em aplicativos de pequeno porte

esta característica é fundamental para que o usuário tenha plena ciência do modo

de utilização de cada opção fornecida.

• Gestão de erros: O sistema deverá também sempre reduzir, quando possível, a

incidência de erros por parte do usuário. Controle de botões habilitados,

verificação de valores de entrada durante a digitação e mensagens claras são

características que devem ser observadas neste sentido.

• Homogeneidade / Coerência: A linguagem utilizada nos rótulos do aplicativo

deve ser clara, dizendo ao usuário exatamente qual a utilidade de cada comando.

Isto pode reduzir sensivelmente a incidência de erros de operação. Além disso,

muitas vezes o uso de padrões “de fato” na elaboração de interfaces torna o uso

do aplicativo mais intuitivo, pois a estrutura já é provavelmente conhecida do

usuário (por exemplo, um menu que tenha “Arquivo”, “Ferramentas”, “Ajuda”,

nesta ordem, está presente em grande parte dos aplicativos comerciais).


28

Existem outros aspectos ergonômicos não citados aqui, mas devido à pequena

dimensão do software, julgamos estes suficientes para atender aos principais requisitos de

usabilidade.

3.4 A disciplina de Neuroanatomia

A Neuroanatomia é o ramo da anatomia que se dedica ao estudo do sistema nervoso.

Esta disciplina é apresentada em sua forma teórica utilizando-se de materiais de apoio como

transparências, imagens de livros e mais recentemente programas em CD. Em suas aulas

práticas, utilizam-se de peças conservadas em álcool, formol ou glicerinadas. A durabilidade

destas peças é, no entanto, muito pequena.

Cada vez tem sido mais difícil obter estas peças para uso na disciplina. Existem

dificuldades legais, dificuldade na extração das peças para estudo e as peças obtidas

possuem pouca durabilidade. Isto tem motivado a busca por alternativas no auxílio

pedagógico com relação a esta disciplina.

29

CAPÍTULO IV

4 A BIBLIOTECA DE CLASSES PARA CONSTRUÇÃO DE RNAS

Como um dos objetivos deste trabalho, foi construída uma biblioteca de classes JAVA,

na versão 1.5, divididas em pacotes com finalidades bem delimitadas.

A razão para a escolha desta linguagem é a sua capacidade de execução em diversos

sistemas operacionais9 e porque esta tem sido a linguagem com maior ênfase no curso de

Sistemas de Informação na UFSC. Outro fato que consideramos foi que tanto a máquina

virtual quanto o ambiente de desenvolvimento para esta linguagem, onde foram utilizados as

IDEs Eclipse e Netbeans, são softwares de livre distribuição.

As atividades a serem executadas por esta biblioteca serão:

- Criar uma rede neural artificial;

- Treinar uma rede neural artificial;

- Manipular arquivos de entrada e saída;

- Gerar código fonte em linguagens de alto nível da rede neural artificial.

A atividade de criar a rede neural artificial implica em permitir que uma rede neural

qualquer possa ser criada, ou seja, com qualquer quantidade de nós de entrada, saída e

escondidos. Na sua criação seus pesos serão atribuídos com valores aleatórios.

Em uma rede neural artificial, cada nó ou neurônio pode ter uma função de saída

específica diferente das demais. Isso, no entanto, normalmente não é utilizado e cria uma

complexidade muito grande tanto na configuração da rede pelo usuário quanto na confecção

do código da aplicação. Assim, na construção desta biblioteca adotou-se uma única função

de saída para todos os nós, exatamente da forma como normalmente se usa na prática,

simplificando seu posterior uso.

A atividade de treinar a rede será feita através do recebimento de uma rede

previamente criada, de um arquivo com os padrões para treinamento e definição das

características do treinamento, tais como: quantidade de épocas, erro máximo admissível e

fator de aprendizagem.

9 A execução de aplicações JAVA em qualquer plataforma ou sistema operacional é possível

desde que a Máquina Virtual Java esteja instalada no ambiente onde a aplicação será utilizada.

30

A manipulação de arquivos referem-se a leitura do arquivo de padrões permitindo sua

validação (verificar sua compatibilidade em relação a rede a ser treinada) e a escrita de

arquivo contendo as informações da rede, permitindo que esta possa ser usada em

momento posterior sem ter que recria-la.

A geração de código em linguagem de alto nível compreende a geração em arquivo

texto de uma rede gerada e treinada em algumas linguagens, tais como: Java, C++, Object

Pascal e Javascript.

Para permitir que outras funções de saída possam ser incluídas na biblioteca, esta foi

implementada como interface em Java. Assim, havendo necessidade de utilizar outras

funções além das implementadas (sigmoidal e tangente hiperbólica), basta implementar esta

interface para a nova função.

4.1 Composição dos Pacotes

Em função das definições citadas anteriormente, a biblioteca construída para uso em

aplicações de rede neural é composta de quatro pacotes de classes, conforme podemos ver

na Figura 4:

Figura 4 – Diagrama dos pacotes que compõem a biblioteca

O critério para a criação destes pacotes foi a distribuição de responsabilidades de cada

classe, conforme a definição, de modo a facilitar a portabilidade para aplicações que possam

fazer uso delas. Assim, por exemplo, se o objetivo é construir uma aplicação de uma rede

neural para uso específico, apenas os pacotes redeneural e funcoesSaida precisam ser

importados.

31

4.1.1 O Pacote redeNeural

Este pacote contém as classes da rede neural propriamente dita e as classes

necessárias para seu treinamento, conforme a Figura 5:

Figura 5 – Diagrama simplificado de classes do pacote redeNeural

Este pacote contém todas as classes necessárias para a criação e treinamento de uma

rede neural.

A classe RedeNeural faz uso de uma função de saída, que é uma interface, conforme a

definição.

Conforme podemos ver na Figura 5, a classe RedeNeural agrega esta interface (-

funcao). Com esta estratégia, qualquer função implementada por esta interface pode ser

usada pela rede.

A classe TreinaRede utiliza a interface FuncaoSaida e RedeNeural e

PadroesTreinamento. A separação destas classes foi feita porque uma rede, depois de

treinada, não utiliza mais esta funcionalidade. Assim, o treinamento é um serviço inicial a ser

feito na rede, mas não faz parte dela.

4.1.2 O Pacote funcoesSaida

Este pacote foi criado, conforme citado, para flexibilizar o modelo a fim de que novas

funções de saída possam ser inseridas no pacote através do uso de uma interface, conforme

podemos ver na Figura 6:

32

Figura 6 – Diagrama de classe simplificado do pacote funcoesSaida

O uso da interface permite uma total flexibilização na inclusão de novas funções de

saída ao modelo. Foram implementadas no pacote as funções mais populares para este uso,

sigmoidal e tangente hiperbólica.

4.1.3 O Pacote manipulacaoArquivos

O conteúdo deste pacote são as classes responsáveis pela manipulação de arquivos

básicos para a construção de uma aplicação que se utilize desta biblioteca. Estão disponíveis

no pacote, conforme o diagrama, as seguintes classes:

Figura 7 – Diagrama simplificado de classes do pacote manipulacaoArquivos

No pacote temos a classe LeitorPadroes, responsável pela leitura do arquivo que

contém os padrões para o treinamento, inserindo as informações lidas na estrutura de dados

utilizada para no treinamento. A classe PersistenciaRede é responsável por fazer a gravação

e leitura em arquivo de uma Rede Neural e a classe GravadorArquivoPesos é responsável por

gravar em arquivo texto os pesos de uma rede para uso em alguma aplicação.

Este pacote normalmente será usado para aplicações que gerem novas redes.

33

4.1.4 O Pacote geradoresCódigo

Este é o último pacote do grupo. Nele estão contidas as classes responsáveis pela

geração dos códigos de uma Rede Neural em diversas linguagens. A estratégia adotada foi o

uso de uma classe abstrata. Ela é parcialmente implementada, ficando sob responsabilidade

das novas classes a implementação do método gerarFuncaoRNAMLP. As classes já

implementadas no pacote podem ser vistas no diagrama a seguir:

Figura 8 – Diagrama simplificado de classes do pacote geradoresCodigo

O diagrama de classes de cada um dos pacotes apresentados encontra-se no Anexo 1.

4.2 Seu Uso em Aplicações

Com este conjunto de pacotes, podemos construir aplicações que façam necessitem

fazer uso de redes neurais.

Com o uso desta biblioteca foi desenvolvida uma aplicação que permite construir o

código em linguagem de alto nível para ser utilizado em aplicativos que necessitem utiliza

este tipo de recurso. Em nosso exemplo, utilizaremos em um gerador de exercícios para

Neuroanatomia, de forma que sejam criados sempre exercícios novos a cada chamada da

aplicação.

Com objetivo de usabilidade, foram verificados os métodos de todas as classes que

poderiam ter sua execução de forma demorada. Os métodos candidatos foram treinar, da

classe TreinaRede, e lerDadosTreinamento, da classe LeitorPadroes. Estes métodos

podem ser demorados porque o tempo de treinamento de uma rede é muito variável e a

leitura de um arquivo de padrões poderá demorar se o arquivo for muito grande. Para

facilitar o uso em interface gráfica, estes métodos foram sobrecarregados, passando um

objeto barra de progresso (JProgressBar) como parâmetro, permitindo o uso desta

ferramenta para indicar ao usuário, em uma aplicação com interface gráfica, o andamento

da atividade que está sendo executada pela aplicação.

34

CAPÍTULO V

5 A APLICAÇÃO PARA GERAÇÃO DE REDES NEURAIS

Para a criação da aplicação proposta pelo trabalho, foi utilizada além da biblioteca

criada neste trabalho, a biblioteca javax.swing para criar uma interface gráfica amigável para

o usuário.

Para tornar mais fácil o seu uso, foram utilizados critérios de usabilidade em sua

confecção, tais como feed-back imediato, condução, gestão de erros e homogeneidade. Na

tela inicial do software, conforme a Figura 9, pode-se observar características de

homogeneidade. Foram utilizadas uma barra de menu e uma barra de ferramentas, ambas

de uso comum nos aplicativos comerciais. A forma de apresentação da barra de menu segue

o padrão mais adotado, tendo como itens de menu “Arquivo” e “Ajuda”. Dada a natureza da

aplicação, foi inserido ainda um menu “Rede”, que intui ao usuário que ações referentes à

rede encontram-se neste menu. Na barra de ferramentas, também seguindo um padrão

largamente adotado, estão os botões “Novo”, “Abrir”, “Salvar” e “Configurações”, além de

um outro referente a uma funcionalidade específica da aplicação, “Treinar”. A Figura 9

apresenta ainda um dos botões com um indicador em amarelo, chamado hint ou dica,

também freqüente em aplicações comerciais e que servem para auxiliar o usuário na

compreensão da finalidade do mesmo. Também temos presente na aplicação uma barra de

status, indicando ao usuário o que fazer, o que está sendo executado ou se algum problema

aconteceu.

35

Figura 9 - Tela inicial do Gerador de Redes Neurais

5.1 Utilizando o Gerador de Redes Neurais

O treinamento de uma rede depende de três configurações principais: A estrutura da

rede, a leitura de um arquivo que contenha os padrões que serão utilizados e as

configurações de treinamento. A configuração da rede deve ser feita antes da leitura do

arquivo de padrões, pois o aplicativo esperará que o arquivo lido esteja dentro das

configurações selecionadas.

5.1.1 Configurando a Rede

O aplicativo permite configurar uma rede por dois caminhos: Abrindo uma

configuração existente ou criando uma nova.

Para utilizar uma configuração de rede já salva anteriormente, deve-se clicar no

menu “Arquivo”, submenu “Abrir”, opção “Configurações de Rede”, e selecionar o arquivo

desejado.

Para configurar uma nova rede, deve-se primeiramente clicar no menu “Rede” depois

no submenu “Configurar” e então na opção “Rede”. A seguinte tela será exibida:

36

Figura 10 - Tela de Configurações da Rede

No primeiro item, “Quantidade Nós de Entrada”, deve ser informada a quantidade de

entradas da rede, ou seja, quantas variáveis, ou parâmetros, serão informados. Em seguida,

temos o item “Quantidade de Nós de Saída”, que é a quantidade de parâmetros resultantes.

O terceiro item, “Quantidade de Nós Escondidos”, informa quantos neurônios estarão

presentes na camada intermediária. A aplicação calcula automaticamente este valor e sugere

ao usuário que use o valor calculado, mas não o impede de usar outro valor. Em seguida,

temos a configuração do “Bias” (nó auxiliar de valor 1, presente na camada de entrada e na

camada escondida). O usuário poderá informar se deseja ou não utilizar este nó. Como

padrão, a opção selecionada é “Sim”.

O último parâmetro a ser configurado é o tipo de “Função de Saída” (função utilizada

para calcular a saída de cada nó), podendo ser “Sigmoidal” ou “Tangente Hiperbólica”.

Utilizamos como padrão o valor “Sigmoidal”.

Alterados os parâmetros, basta clicar no botão “Configurar”. Será exibida a

mensagem “Rede Configurada”.

É possível salvar os parâmetros de configuração selecionados clicando-se no menu

“Arquivo”, submenu “Salvar”, opção “Configurações de Rede”, e selecionar o caminho e

37

nome do arquivo. Caso a gravação seja bem sucedida, será exibida a mensagem

“Configurações gravadas com sucesso!”.

Quanto a aspectos de usabilidade, podemos destacar nesta tela a presença dos

botões com “?” ao lado de cada opção de configuração. Estes botões, ao serem clicados,

informam de forma resumida o que quer dizer cada um dos parâmetros. Além disso, a cada

opção acessada pelo usuário é exibida um texto de “ajuda contextual”, na barra inferior da

tela (barra de status).

5.1.2 Lendo um arquivo de padrões

Configurada a rede, pode-se então abrir um arquivo de padrões clicando-se no menu

“Arquivo”, submenu “Abrir”, opção “Arquivo de padrões”. O arquivo selecionado deve ser do

tipo texto pleno e estar no seguinte formato:

A;B;C

XXXX

XXXX

XXXX

Onde A é a quantidade de nós de entrada, B é a quantidade de nós de saída, C é a

quantidade de padrões que o arquivo contém, e X são os padrões. Por exemplo, um arquivo

de padrão com 3 nós de entrada, 1 nó de saída e 5 padrões teria o seguinte formato:

3;1;5

0001

0011

0101

1000

1010

Os três primeiros valores dos padrões seriam utilizados como entradas (no caso 000,

001, 010, 100 e 101) e o último valor (1, 1, 1, 0 e 0) seria utilizado como a saída esperada

38

para cada padrão. Logicamente, os valores dos padrões poderiam ser diferentes, mas o

cabeçalho (3;1;5) deveria ser como o exemplificado para a rede proposta.

Caso o arquivo lido esteja dentro das configurações selecionadas, será exibida a

mensagem “Arquivo Lido com Sucesso”, juntamente com um indicador de progresso da

leitura.

5.1.3 Configurando Aspectos de Treinamento

Neste ponto já temos a rede configurada e os padrões lidos. Pode-se agora

configurar alguns aspectos de treinamento clicando-se no menu “Rede”, submenu

“Configurar”, opção “Aspectos de Treinamento”. A seguinte tela será exibida:

Figura 11 - Tela de Configurações do Treinamento

O primeiro parâmetro a se configurar é o “Erro Máximo”, que informará basicamente

qual a tolerância para as saídas serem interpretadas com zero ou um. Um valor muito alto

poderia resultar em uma rede “mal treinada”, enquanto que um valor baixo demais poderia

causar “super-treinamento” (rede que produz acertos apenas com os dados de treinamento).

Como padrão, o valor selecionado é 0,1, que já é bem pequeno.

39

O “Número de Épocas Máximo” indica quantas vezes a rede poderá ter o conjunto de

padrões reaplicados às entradas para realizar o treinamento. Se durante o treinamento for

atingido este número e a rede ainda não estiver treinada (valores de saída dentro de um

erro aceitável), será exibida uma mensagem indicando que o treinamento não foi bem

sucedido. O valor padrão da aplicação é 1000.

O último parâmetro, “Fator de Aprendizagem” (valor padrão de 0,25), deve ser

preenchido com um valor entre 0 e 1. Este valor é o multiplicador da correção calculada para

os pesos. A cada padrão submetido ao treinamento é calculado um fator de correção que

será multiplicado por este valor para corrigir os pesos. Desta forma, quanto mais alto o valor

mais rápido a rede poderá ser treinada, mas ao mesmo tempo, a probabilidade de que ela

seja efetivamente treinada diminui, pois a chance de passar do ponto ótimo do peso

aumenta, causando oscilação no treinamento. Ao clicar-se no botão “Configurar”, será

exibida a mensagem “Treinamento Configurado”.

Da mesma forma que a tela citada anteriormente, esta possui botões de ajuda para

cada opção e uma ajuda contextual na barra de status quando cada opção é acessada. É

interessante ressaltar que a opção “Aspectos de Treinamento” só estará habilitada depois de

lidos os padrões de treinamento, o que auxilia na condução do uso do aplicativo e também

na gestão de erros, pois evita que o usuário tente treinar uma rede sem que existam

padrões previamente carregados na memória.

5.1.4 Treinando a rede

Completadas as configurações, pode-se então treinar a rede clicando-se no menu

“Rede”, opção “Treinar” (opção que também estará disponível apenas depois de carregados

os padrões de treinamento). Caso o treinamento seja bem sucedido, será exibida a

mensagem “Rede treinada com sucesso”, juntamente com um indicador de progresso e o

botão “Resultado”. Ao clicar-se neste botão, será exibido um gráfico demonstrando a

evolução da convergência dos valores de erro de saída rumo ao valor de erro configurado,

conforme a Figura 12.

40

Figura 12 - Gráfico de Evolução do Treinamento

A linha em azul, na base, indica o valor de erro configurado, enquanto que a

vermelha indica o valor de erro na saída a cada iteração.

5.1.5 Salvando o código fonte da rede treinada

A aplicação permite que, ao treinar-se uma rede, seu “código fonte” seja salvo para

que possa ser utilizado em outros aplicativos, em diversas linguagens. É isto que permite,

por exemplo, que uma rede treinada no software seja reproduzida em uma página HTML

(utilizando Javascript) proporcionando que novos dados sejam aplicados à entrada da rede e

esta calcule as saídas.

Para salvar o código fonte, deve-se clicar no menu “Arquivo”, submenu “Salvar”,

submenu “Código Fonte” e selecionar a linguagem desejada, lembrando que esta opção só

estará habilitada se uma rede for previamente treinada com sucesso. As opções disponíveis

são Java, C++, Object Pascal e Javascript. Será solicitado ao usuário digitar o “Limiar de

Saída” (função threshold), que é o limite que o programa utilizará para delimitar valores

41

entre 0 e 1. Por exemplo, se for digitado o valor 0.4, o programa considerará como 0 valores

menores que 0,4 e como 1 valores iguais ou acima disso.

Deve-se então selecionar o caminho e o nome do arquivo (sem a extensão, que será

inserida automaticamente de acordo com a linguagem selecionada). Caso o arquivo seja

salvo corretamente, será exibida a mensagem “Arquivo Gerado com Sucesso”.

5.2 Exemplo de aplicação com RNA na disciplina de Neuroanatomia

Para exemplificar o uso de redes neurais geradas pelo software, foi criado um

aplicativo em HTML para a disciplina de Neuroanatomia, que utiliza uma rede neural para

geração dinâmica de exercícios. Podemos ver a tela inicial deste aplicativo na Figura 13,

conforme a seguir:

Figura 13 - Aplicativo para Neuroanatomia em HTML e Javascript utilizando RNA

42

Este aplicativo funciona da seguinte maneira: a partir das áreas destacadas em

vermelho na figura que representa o cérebro humano, o aluno deverá selecionar quais

sintomas o paciente deverá apresentar caso estas estejam afetadas. Ao clicar em confirmar,

cada um dos sintomas marcados ou desmarcados corretamente estarão como verde, e cada

opção marcada ou desmarcada erroneamente estará em vermelho, conforme demonstrado

na Figura 14:

Figura 14 - Resultado do Exercício

Neste caso, o aluno teria acertado (conforme treinamento da rede) ao marcar as

opções “Dislexia” e “Alteração da Olfação”, mas teria errado ao deixar de marcar as opções

“Alteração Emocional” e “Alteração Sensorial Superficial dos Membros Inferiores”. Quando

ele clicar em “Tentar de Novo”, serão selecionadas novas áreas do cérebro. O número de

43

áreas selecionadas é aleatório, podendo ser ajustado um número máximo de áreas grifadas

simultaneamente.

Pode-se observar que esta aplicação permite vários exercícios dentro de um só, pois

como tanto as áreas selecionadas quanto a quantidade delas é aleatória, a quantidade de

possibilidades é bastante grande. Certamente que o acerto ao avaliar as respostas do aluno

dependerá da qualidade de treinamento da rede.

Para gerarmos a rede desta aplicação, utilizamos um arquivo de padrões contendo 76

registros que fornecem as dez entradas e suas respectivas 10 saídas, conforme Anexo 2.

As entradas correspondem às 10 regiões mapeadas do cérebro utilizadas neste

exercício são:

1. face medial superior do giro pré-central,

2. giro parahipocampal,

3. face medial do giro pré-central,

4. face medial do giro pós-central,

5. giro do cíngulo,

6. face medial do giro frontal superior,

7. área do sulco calcarino,

8. giro occipito temporal lateral e giro temporal inferior,

9. tálamo – região ventral posterior,

10. uncus.

Os padrões contêm dez saídas que correspondem a dez sintomas possíveis, a saber:

1. hemianopsia

2. dislexia

3. alteração emocional

4. alteração de memória

5. mal funcionamento do esfíncter anal/vesical

6. personalidade alterada

7. alteração da olfação

8. ataxia

9. hemiplegia dos membros inferiores

10. alteração sensorial superficial dos membros inferiores

44

A aplicação geradora da rede cria apenas a função javascript para identificação da

resposta conforme o que é apresentado na figura, o restante da página WEB é criada pelo

autor do exercício.

No Anexo 4 podemos ver a função gerada para o exercício apresentado. No Anexo 5

temos o código completo HTML/Javascript do exercício. A linha apresentada em destaque

refere-se a uma adaptação do código gerado para o uso da função de forma diferenciada,

permitindo que o resultado da rede seja lido em outro momento. Com base neste exemplo

podemos observar que o código gerado auxilia a criação do exercício, mas não o cria por

completo. Sua maior relevância está no fato de que a parte complexa de fato do código é a

que foi criada pela aplicação, ou seja a rede neural.

45

CAPÍTULO VI

6 CONCLUSÕES

De forma geral, obteve-se bons resultados com o desenvolvimento deste trabalho. O

maior aprofundamento na área de Inteligência Artificial, tanto de forma prática quanto

teórica, foi o que tornou o desenvolvimento do projeto possível.

A preocupação com aspectos ergonômicos durante o desenvolvimento da aplicação

objetivou apenas, em um primeiro momento, tornar o aplicativo mais adequado a questões

relevantes de usabilidade. No entanto, percebeu-se que o uso do aplicativo por terceiros foi

muito mais facilitado pelo fato de tais questões terem sido observadas.

6.1 O Gerador de Redes Neurais

O desenvolvimento da aplicação para geração de redes neurais, principal foco prático

deste trabalho, atingiu os objetivos esperados: a partir de configurações dos parâmetros da

rede, da leitura de arquivos de padrões dentro do formato esperado e das configurações de

treinamento, é possível obter-se uma rede treinada para qualquer problema que tenha como

parâmetros entradas / saídas. Contudo, a possibilidade e a qualidade do treinamento ficam

sujeitas às amostras apresentadas à rede (padrões) bem como às características

configuradas.

Entretanto, um aplicativo que somente treinasse uma rede teria utilidade duvidosa,

pois só informaria ao usuário que os padrões fornecidos são suficientes para que o

treinamento seja realizado. O fato de poder-se exportar a estrutura da rede, já com os

pesos adequados do treinamento, para diversas linguagens de programação, permite que o

uso do aplicativo seja sensivelmente ampliado, pois torna viável o desenvolvimento de novos

softwares que apenas façam uso de uma rede previamente treinada, como o exemplo

desenvolvido para a disciplina de Neuroanatomia.

É interessante ressaltar ainda que o perfil do usuário deste software é o de alguém

que já tenha algum conhecimento sobre IA, para que este tenha condições de configurar

corretamente os parâmetros estruturais e de treinamento da rede.

46

6.2 O aplicativo para a disciplina de Neuroanatomia

O aplicativo desenvolvido para a disciplina de Neuroanatomia, baseado em HTML e

Javascript, utilizou uma RNA gerada pelo Gerador de Redes Neurais, cujos padrões foram

formatados através de dados previamente fornecidos pela professora da disciplina, Rosane

Heinzen, que ao utilizar o software constatou que “O aplicativo apresenta uma interface de

fácil utilização. Associa a imagem real do cérebro humano a exercícios de múltipla escolha,

permitindo ao usuário relacionar o conteúdo teórico com o curso prático. Gera exercícios de

forma aleatória, apresentando resposta correta nos vinte (20) casos testados”.

Como o aplicativo é bastante simples, em princípio não é necessário nenhum

conhecimento prévio para utilizá-lo, pois basta selecionar os sintomas e clicar em um dos

dois botões existentes. Mas é claro que, para que se tenha uma taxa de acertos razoável,

são necessários conhecimentos prévios em Neuroanatomia.

Sete alunos do curso de Medicina interagiram com o software, sendo que todos ao

final responderam a uma pesquisa quanto ao uso, qualidade e pertinência do aplicativo

(síntese das respostas no Anexo 6). Todos consideraram que a utilização foi fácil, que a

qualidade das respostas foi boa / ótima, e que de forma geral exercícios on-line trazem

benefícios para o estudo prático individual, como destacou um dos alunos ao comentar que a

possibilidade de realização de exercícios de Neuroanatomia pela Internet “É bastante

importante para disponibilizar momentos fora de sala de aula ou fora do horário de monitoria

para alunos que não possam comparecer nos horários previstos, já que as peças de

Neuroanatomia, devido à sua friabilidade, têm um acesso mais restrito para utilização pelos

alunos”. Heinzen também comentou que “A disponibilização do aplicativo on line visa

propiciar o estudo individual para alunos dos cursos das Ciências da Saúde, Humanas e

Biológicas, flexibilizando o atual método tradicional de ensino/aprendizagem da disciplina de

Neuroanatomia na UFSC”.

Com uma rede bem treinada, é possível utilizar este HTML inclusive para avaliação de

aprendizado, pois mesmo que o aluno verifique o código HTML da página, não encontrará lá

as respostas, pois verá apenas a distribuição dos pesos da rede e sua estrutura. Isto se deve

a uma característica intrínseca das RNAs, o fato destas serem caixas-pretas (não se sabe

porquê chegou-se a determinado resultado, ou seja, qual a influência de cada entrada na

rede). Tal característica, muitas vezes considerada uma limitação, mostrou-se neste caso de

grande utilidade.

47

6.3 Considerações finais

Foi interessante e estimulante a oportunidade de pesquisa em áreas não tão

diretamente correlatas à Computação, como ensino a distância e Neuroanatomia. O trabalho

desenvolvido procurou, através do agrupamento destas áreas, demonstrar como é grande o

espectro de possibilidades nas quais o uso de IA pode ser uma opção.

Como trabalho futuro, existe a possibilidade de integração de um módulo inteligente

de aplicação de exercícios ao sistema de ensino on-line demonstrado na tese de doutorado

de Heinzen, o que proporcionaria um ambiente completo de aprendizado virtual para a

disciplina de Neuroanatomia. Cabe ressaltar que tal módulo poderia ser incluído em qualquer

sistema de ensino multimídia, o que enriqueceria substancialmente as possibilidades de

aprendizado.

48

7 REFERÊNCIAS

1. Russell, Stuart Jonathan; NORVIG Peter. Inteligência artificial. Rio de Janeiro:

Elsevier, 2004 2. FERNANDES, Ana Maria da Rocha. Inteligência artificial: noções gerais.

Florianópolis: Visual Books, 2003

3. OLIVEIRA NETTO, Alvim Antônio de. IHC – Interação humano computador: modelagem e gerência de interfaces com o usuário. Florianópolis: Visual Books, 2004

4. MORGAN, Michael. Java 2 para programadores profissionais. Rio de Janeiro:

Ciência Moderna Ltda, 2000

5. JANDL JUNIOR, Peter. Introdução ao Java. São Paulo: Berkley Brasil, 2002

6. JANDL JUNIOR, Peter. Mais Java. São Paulo: Futura, 2003

7. SIKORA, Michael. Java: guia prático para programadores. Tradução de Altair Dias Caldas de Moraes. Rio de Janeiro: Campus, 2003

8. HORSTMAN, Cay; CORNELL, Gary. CoreJava 2: fundamentos. Tradução de João

Eduardo Nóbrega Tortello. São Paulo: Makron Books, 2001

9. HORSTMAN, Cay; CORNELL, Gary. CoreJava 2: recursos avançados. Tradução de João Eduardo Nóbrega. São Paulo: Pearson Education do Brasil, 2002

10. MEDEIROS, Ernani Sales de. Desenvolvendo software com UML 2.0: definitivo.

São Paulo: Pearson Makron Books, 2004

11. LEVY, Pierre. As tecnologias da inteligência: o futuro do pensamento na era da informática. Rio de Janeiro: Ed. 34, 1993

12. ALVES, Lynn; NOVA, Cristiane. Educação a Distância São Paulo: Futura, 2003

13. FALQUETO, Jovelino. Inspiração biológica em IA. 2002. 164 f. Tese (Doutorado)

Universidade Federal de Santa Catarina. Florianópolis, 2002

14. HEINZEN, Rosane Porto Seleme. Modelo de ambiente virtual para a aprendizagem de neuroanatomia. 2004. 127f. Tese (Doutorado) Universidade Federal de Santa Catarina, Florianópolis, 2004

15. RAMOS, Edla Maria Faust; FAGUNDES, Lea da Cruz. Análise ergonômica do

sistema hiperNet buscando o aprendizado da cooperação e da autonomia. 1996. 353f. Tese (Doutorado) - Universidade Federal de Santa Catarina, Florianópolis, 1996

49

ANEXOS

50

ANEXO 1 - DIAGRAMAS DE CLASSE

Diagrama de classes do pacote redeNeural

51

Diagrama de classes do pacote funcoesSaida

52

Diagrama de classes do pacote manipulacaoArquivos

53

Diagrama de classes do pacote geradoresCodigo

54

Anexo 2 – Padrões de Treinamento da Aplicação

10;10;76 10000000000000100000 01000000000001000000 00100000000000000010 00010000000000000001 00001000000010000000 00000100000000010000 00000010001000000000 00000001000100000000 00000000100000000100 00000000010000001000 10000000010000101000 01000000100001000100 00010010001000000001 10100000000000100010 00001010001010000000 00000000110000001100 00010100000000010001 01001000000011000000 00101000000010000010 00010000100000000101 10101000000010100010 01010100000001010001 00101010001010000010 00010101000100010001 00001010101010000100 00000101010100011000 00100100100000010110 01001000010011001000 11000100000001110000 00110010001000000011 11110000000001100011 00111100000010010011 00001111001110010000 00000011111100001100 10101010001010100010 00010101010100011001 01001010011011001000 00110100100000010111

10001100010010111000 00110010101000000111 11011000010011101001 00110011101100000111 10101010101010100110 01001101010111011000 10111010011010101011 11000101100101110100 10100111001100110010 01001100110011011100 10101001100110100110 00000111111100011100 11110000110001101111 01111011001111000011 10111001100110100111 01100011111101001110 10110110011000111011 10100111011100111010 11001111001111110000 10110101010100111011 11110011001101100011 10111010101010100111 11101110011011111010 11110101100101110111 10111100010010111011 10011111011110111001 10111101010110111011 01111110101011010111 00111111101110010111 01001111111111011100 00111111101110010111 01101111011111011010 10111111011110111011 01111111101111010111 10111101110110111111 11110011111101101111 11110111101101110111 10111110111010111111

55

ANEXO 3 – Documentação – Formato Javadoc

redeNeural

Class RedeNeural java.lang.Object

redeNeural.RedeNeural

public class RedeNeural extends java.lang.Object

Permite a criação de uma rede neural artificial para uso qualquer. A função de saída a ser usada na rede neural deve ser do tipo FuncaoSaida, outra classe (interface) pertencente ao pacote redeneural.

Version:

1.0.0

Author:

João Carlos Testi Ferreira e Júnior Barbosa Dymow

Constructor Summary

RedeNeural()

Contrutor vazio

Cria a rede com a seguinte característica:

- 2 nós de entrada

- 1 nó de saída

- 1 nó escondido

- bias na camada de entrada e camada escondida

- executa inicializaDefaults

RedeNeural(int nE, int nS, int nBias)

Contrutor com parametros

Cria a rede de acordo com os parâmetros informados.

56

Method Summary

void calculeNets()

Calcula os valores net da camada escondida e da camada de

saída

int getBias()

Getter do Bias

boolean getEstaTreinada()

Getter para estaTreinada

FuncaoSaida getFuncao()

Getter da função de saída

int getNosEntrada()

Getter da quantidade de nós de entrada.

int getNosEscondidos()

Getter da quantidade de nós escondidos

int getNosSaida()

Getter da quantidade de nós de saída

double[][] getPesosHI()

Getter dos pesos entre a camada de entrada e escondida

double[][] getPesosOH()

Getter do array de pesos entre a camada escondida e saída

double[] getSaida()

Getter para o vetor de saída

int getValorEntradas(int indice)

Getter para um valor da entrada

double getValorEscondidos(int indice)

Getter para um valor da camada escondida

double getValorPesosHI(int indiceJ, int indiceI)

Getter de um peso das camadas de entrada e escondida

double getValorPesosOH(int indiceK, int indiceJ)

Getter de um dos pesos entre a camada escondida e saída

57

double getValorSaidas(int indice)

Getter para um valor da saída

void inicializaPesos()

Inicializa os pesos com valores aleatórios

void reiniciaTreinamento()

Reinicia o treinamento da seguinte forma:

- define estaTreinada para false

- executa inicializaPesos

void setBias(int tB)

Setter do bias

void setEntrada(int[] vE)

Setter para os valores de entrada da rede

void setEstaTreinada(boolean et)

Setter para estaTreinada

void setFuncao( FuncaoSaida pFuncao)

Setter da função de saída

void setNosEntrada(int nE)

Setter da quantidade de nós de entrada.

void setNosEscondidos(int nE)

Setter da quantidade de nós escondidos

Redefine os arrays que dependem desta informação

void setNosSaida(int nS)

Setter da quantidade de nós de saída


void setPesosHI(double[][] phi)

Setter do array de pesos entre a camada de entrada e

escondida

void setPesosOH(double[][] poh)

Setter dos pesos entre as camadas escondida e saída

58

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify , notifyAll,

toString, wait, wait, wait

Constructor Detail

RedeNeural

public RedeNeural()

Construtor vazio

Cria a rede com a seguinte característica:

- 2 nós de entrada

- 1 nó de saída

- 1 nó escondido

- bias na camada de entrada e camada escondida

- executa inicializaDefaults

RedeNeural

public RedeNeural(int nE, int nS, int nBias)

Contrutor com parametros

Cria a rede de acordo com os parâmetros informados.

Parameters:

nE - quantidade de nós de entrada

nS - quantidade de nós de saída

nBias - uso do bias, se 0 não usa, se 1 usa.

O número de nós escondidos será a média entre os nós de entrada e nós de saída.

O construtor executa inicializaDefaults

Method Detail

setNosEntrada

public void setNosEntrada(int nE)

59

throws java.lang.Exception

Setter da quantidade de nós de entrada.

Redefine os arrays que dependem desta informação.

Parameters:

nE - quantidade de nós de entrada

Throws:

java.lang.Exception - Lança exceção caso o número de nós de entrada

seja inferior a 1.

getNosEntrada

public int getNosEntrada()

Getter da quantidade de nós de entrada.

Returns:

retorna o número de nós de entrada como um inteiro.

setNosEscondidos

public void setNosEscondidos(int nE) throws java.lang.Exception

Setter da quantidade de nós escondidos


Parameters:

nE - quantidade de nós escondidos

Throws:

java.lang.Exception - lança exceção caso o número de nós escondidos

seja inferior a 1.

getNosEscondidos

public int getNosEscondidos()

Getter da quantidade de nós escondidos

Returns:

retorna a quantidade de nós escondidos como um inteiro.

setNosSaida

60

public void setNosSaida(int nS) throws java.lang.Exception

Setter da quantidade de nós de saída


Parameters:

nS - quantidade de nós de saída

Throws:

java.lang.Exception - lança exceção caso o número de nós de saída seja

inferior a 1.

getNosSaida

public int getNosSaida()

Getter da quantidade de nós de saída

Returns:

retorna a quantidade de nós de saída como um inteiro.

getFuncao

public FuncaoSaida getFuncao()

Getter da função de saída

Returns:

retorna a função de saída como uma FuncaoSaida.

setFuncao

public void setFuncao( FuncaoSaida pFuncao)

Setter da função de saída

Parameters:

pFuncao - função de aticação, do tipo FuncaoSaida (interface)

61

setBias

public void setBias(int tB) throws java.lang.Exception

Setter do bias

Parameters:

tB - se 0 indica que não será usado bias, se 1 é usado bias

Throws:

java.lang.Exception - lança exceção se parâmetro for diferente de 0 ou 1.

getBias

public int getBias()

Getter do Bias

Returns:

retorna 1 se estiver usando bias e 0 se não estiver.

setEntrada

public void setEntrada(int[] vE) throws java.lang.Exception

Setter para os valores de entrada da rede

Parameters:

vE - vetor de entrada do tipo int

Throws:

java.lang.Exception - lança exceção se a quantidade de entradas não for

compatível com tamanho do vetor. Se o tamanho for igual ao do vetor, o método

insere, se necessário, o bias. Se o tamanho do vetor for igual ao número de nós de

entrada mais o bias, a responsabilidade de deixar o bias na primeira posição é do

usuário.

62

getValorEntradas

public int getValorEntradas(int indice)

Getter para um valor da entrada

Parameters:

indice - indica qual nó deve ser retornado

Returns:

retorna o valor do nó referenciado por indice como um inteiro

getValorEscondidos

public double getValorEscondidos(int indice)

Getter para um valor da camada escondida

Parameters:


Returns:

retorna o valor do nó referenciado por indice como um double

getValorSaidas

public double getValorSaidas(int indice)

Getter para um valor da saída

Parameters:


Returns:

retorna o valor do nó referenciado por indice como um double

63

getSaida

public double[] getSaida() throws java.lang.Exception

Getter para o vetor de saída

Returns:

retorna o vetor de saída do tipo double

Throws:

java.lang.Exception - lança exceção caso a rede não esteja treinada, pois

não há como gerar saidas.

getEstaTreinada

public boolean getEstaTreinada()

Getter para estaTreinada

Returns:

retorna true se a rede estiver treinada e false se não estiver.

setEstaTreinada

public void setEstaTreinada(boolean et)

Setter para estaTreinada

Parameters:

et - valor a ser atribuído a estaTreinada do tipo boolean

setPesosHI

public void setPesosHI(double[][] phi) throws java.lang.Exception

Setter do array de pesos entre a camada de entrada e escondida

Parameters:

phi - array de pesos do tipo double

Throws:

java.lang.Exception - lança exceção se o tamanho do array não for igual

ao array com os pesos entre a camada de entrada e escondida

64

getValorPesosHI

public double getValorPesosHI(int indiceJ, int indiceI)

Getter de um peso das camadas de entrada e escondida

Parameters:

indiceJ - índice do array referente a camada escondida

indiceI - índice do array referente a camada de entrada

Returns:

valor do peso referenciado pelos indices i e j

getPesosHI

public double[][] getPesosHI()

Getter dos pesos entre a camada de entrada e escondida

Returns:

retorna o array de pesos entre a camada de entrada e escondida

setPesosOH

public void setPesosOH(double[][] poh) throws java.lang.Exception

Setter dos pesos entre as camadas escondida e saída

Parameters:

poh - array com os pesos

Throws:

java.lang.Exception - lança exceção se o array passado como parâmetro

for de tamanho diferente do array de pesos entre a camada escondida e saída

getValorPesosOH

public double getValorPesosOH(int indiceK,int indiceJ)

Getter de um dos pesos entre a camada escondida e saída

Parameters:

indiceK - índice que referencia o nó da saída

indiceJ - índice que referencia o nó da camada escondida

Returns:

retorna o valor do peso referenciado pelos índices j e k

65

getPesosOH

public double[][] getPesosOH()

Getter do array de pesos entre a camada escondida e saída

Returns:

retorna o array de pesos entre a camada escondida e saída

calculeNets

public void calculeNets()

Calcula os valores net da camada escondida e da camada de saída

inicializaPesos

public void inicializaPesos()

Inicializa os pesos com valores aleatórios

reiniciaTreinamento

public void reiniciaTreinamento()

Reinicia o treinamento da seguinte forma:

- define estaTreinada para false

- executa inicializaPesos

66

redeNeural

Class TreinaRede java.lang.Object

redeNeural.TreinaRede

public class TreinaRede extends java.lang.Object

Treinamento de uma rede neural artificial

Author:


Constructor Summary

TreinaRede()

Construtor vazio

Usa os seguintes defaults:

- rede criada com construtor vazio - número máximo de épocas 1000 - fator de

aprendizagem 0.25 - Erro máximo 0.1

TreinaRede( RedeNeural rede, PadroesTreinamento pT,

int pEpocasMaximo, double pFatorAprendizagem, doubl e pErroAceitavel)

Construtor com parâmetros

Method Summary

double calculeErroGlobal()

Calcula o erro global da época

void calculeFatoresCorrecao()

Calcula os fatores de correção

Para seu uso, o array saidasEsperadas deve ter sido

inicializado com a saida do treinamento

67

void calculeFatoresCorrecao(int padrao)


void corrigePesos()

Corrige os pesos entre as conexões

int getEpocasMaximo()

Getter da quantidade máxima de épocas

double getErroAceitavel()

Getter do erro aceitável

double getErroMaximo()

Getter do maior erro obtido

java.util.ArrayList getErrosMaximos()

Getter dos erros máximos das épocas

double getFatorAprendizagem()

Getter do fator de aprendizagem

int getQtdEpocasAtual()

getter da quantidade de épocas atual

int[] setEntradaSaidaDoPadrao(int padrao)

Setter dos arrays de valores padrão (entrada e

saída)

void setEpocasMaximo(int eM)

Setter da quantidade máxima de épocas

void setErroAceitavell(double eA)

Setter do erro aceitavel

void setFatorAprendizagem(double fA)

Setter do fator de aprendizagem

boolean treinar()

Treina a Rede Neural

68




Constructor Detail

TreinaRede

public TreinaRede( RedeNeural rede, PadroesTreinamento pT, int pEpocasMaximo, double pFatorAprendizagem, double pErroAceitavel)


Parameters:

rede - rede a ser treinada

pT - padrões de treinamento a serem usados no treinamento

pEpocasMaximo - número máximo de épocas a ser treinada a rede

pFatorAprendizagem - fator de aprendizagem a ser aplicado no treinamento

pErroAceitavel - maior valor de erro a ser usado como referência na saída

TreinaRede

public TreinaRede()

Construtor vazio

Usa os seguintes defaults:

- rede criada com construtor vazio - número máximo de épocas 1000 - fator de

aprendizagem 0.25 - Erro máximo 0.1

69

Method Detail

getErrosMaximos

public java.util.ArrayList getErrosMaximos()

Getter dos erros máximos das épocas

Returns:

Maiores valores de erro obtidos em cada época em um ArrayList

getErroMaximo

public double getErroMaximo()

Getter do maior erro obtido

Returns:

retorna o maior erro obtido como double

getQtdEpocasAtual

public int getQtdEpocasAtual()

getter da quantidade de épocas atual

Returns:

quantidade de épocas atual como um inteiro

treinar

public boolean treinar() throws java.lang.Exception

Treina a Rede Neural

Returns:

retorna true ou false se conseguiu treinar ou não

Throws:

java.lang.Exception

70

setEntradaSaidaDoPadrao

public int[] setEntradaSaidaDoPadrao(int padrao)

Setter dos arrays de valores padrão (entrada e saída)

Parameters:

padrao - índice do padrão a ser aplicado nos vetores de entrada e saída

esperada

Returns:

retorna o vetor de entrada

calculeErroGlobal

public double calculeErroGlobal()

Calcula o erro global da época

Returns:

retorna o valor do erro global como um double

calculeFatoresCorrecao

public void calculeFatoresCorrecao(int padrao)


Parameters:

padrao - indice que identifica o padrão utilizado no treinamento

calculeFatoresCorrecao

public void calculeFatoresCorrecao()


Para seu uso, o array saidasEsperadas deve ter sido inicializado com a saida do

treinamento

71

corrigePesos

public void corrigePesos()throws java.lang.Exception

Corrige os pesos entre as conexões

Throws:

java.lang.Exception - lança exceção se ocorrer erro na redefinição dos

pesos

setErroAceitavell

public void setErroAceitavell(double eA)

Setter do erro aceitavel

Parameters:

eA - valor do erro aceitável do tipo double

getErroAceitavel

public double getErroAceitavel()

Getter do erro aceitável

Returns:

retorna o erro aceitável como double

setEpocasMaximo

public void setEpocasMaximo(int eM)

Setter da quantidade máxima de épocas

Parameters:

eM - quantidade máxima de épocas do tipo inteiro

getEpocasMaximo

public int getEpocasMaximo()

Getter da quantidade máxima de épocas

Returns:

retorna o número máximo de épocas como inteiro

72

setFatorAprendizagem

public void setFatorAprendizagem(double fA)

Setter do fator de aprendizagem

Parameters:

fA - valor do fator de aprendizagem como double

getFatorAprendizagem

public double getFatorAprendizagem()

Getter do fator de aprendizagem

Returns:

retorna o valor do fator de aprendizagem como double

73

redeNeural

Class PadroesTreinamento java.lang.Object

redeNeural.PadroesTreinamento

public class PadroesTreinamento extends java.lang.Object

Padrões de treinamento para serem usados no treinamento da rede

Author:

Joao Carlos Testi Ferreira e Júnior Barbosa Dymow

Constructor Summary

PadroesTreinamento()

Construtor vazio

Inicializa com tamanho 1x1 os arrays de padrões de entrada e saída

PadroesTreinamento(int[][] pE, int[][] pS)


Inicia os arrays com os arrays passados por parâmetro

Method Summary

int[][] getPadroesEntrada()

Getter dos padrões de entrada

int[][] getPadroesSaida()

Getter dos padrões de saída

void setPadroesTreinamento(int[][] pE, int[][] pS)

Setter dos arrays de padrões de entrada e saída

74




Constructor Detail

PadroesTreinamento

public PadroesTreinamento()

Construtor vazio

Inicializa com tamanho 1x1 os arrays de padrões de entrada e saída

PadroesTreinamento

public PadroesTreinamento(int[][] pE, int[][] pS)


Inicia os arrays com os arrays passados por parâmetro

Parameters:

pE - array com os parâmetros de entrada

pS - array com os parâmetros de saída

Method Detail

setPadroesTreinamento

public void setPadroesTreinamento(int[][] pE, int[][] pS)

Setter dos arrays de padrões de entrada e saída

Parameters:

pE - array com os padrões de entrada

pS - array com os padrões de saída

75

getPadroesEntrada

public int[][] getPadroesEntrada()

Getter dos padrões de entrada

Returns:

retorna o array de padrões de entrada

getPadroesSaida

public int[][] getPadroesSaida()

Getter dos padrões de saída

Returns:

retorna o array de padrões de saída

76

funcoesSaida

Interface FuncaoSaida

All Known Implementing Classes:

FuncaoSigmoidal, FuncaoTangHiperb

public interface FuncaoSaida

Interface que define a função de saída

Author:


Method Summary

double calcDerivada(double valor)

Método que deve se implementado para calcular o valor

de saída da derivada da função

double calcFuncao(double valor)

Método que deve ser implementado para calcular o

valor de saída da função

java.lang.String getNome()

Método a ser implementado para informar o nome da

função

77

Method Detail

calcFuncao


Método que deve ser implementado para calcular o valor de saída da função

Parameters:

valor - valor a ser aplicado na função como double

Returns:

retorna a saída da função como double

calcDerivada


Método que deve se implementado para calcular o valor de saída da derivada

da função

Parameters:

valor - a ser aplicado na derivada da função como double

Returns:

retorna a saída da derivada da função como double

getNome


Método a ser implementado para informar o nome da função

Returns:

retorna o nome da função como String

78

funcoesSaida

Class FuncaoSigmoidal java.lang.Object

funcoesSaida.FuncaoSigmoidal

All Implemented Interfaces:

FuncaoSaida

public class FuncaoSigmoidal extends java.lang.Object implements FuncaoSaida

Implementação da função de saída do tipo sigmoidal

Author:


Constructor Summary

FuncaoSigmoidal()

construtor vazio

Method Summary


Calcula o resultado da derivada da função


Calcula o resultado da função


Informa o nome da função de saída

79




Constructor Detail

FuncaoSigmoidal

public FuncaoSigmoidal()

construtor vazio

Method Detail

calcFuncao

public double calcFuncao(double valor)


Specified by:

calcFuncao in interface FuncaoSaida

Parameters:

valor - valor a ser aplicado na função do tipo double

Returns:

retorna o resultado da função com tipo double

calcDerivada

public double calcDerivada(double valor)


Specified by:

calcDerivada in interface FuncaoSaida

Parameters:

valor - valor a ser aplicado na derivada da função como double

Returns:

retorna o resultado da de derivada da função como double

80

getNome

public java.lang.String getNome()


Specified by:

getNome in interface FuncaoSaida

Returns:


81

funcoesSaida

Class FuncaoTangHiperb java.lang.Object

funcoesSaida.FuncaoTangHiperb

All Implemented Interfaces:

FuncaoSaida

public class FuncaoTangHiperb extends java.lang.Object implements FuncaoSaida

Implementação da função de saída do tipo tangente hiperbólica

Author:


Constructor Summary

FuncaoTangHiperb()

construtor vazio

Method Summary







82


clone, equals, finalize, getClass, hashCode, notify , notifyAl l,


Constructor Detail

FuncaoTangHiperb

public FuncaoTangHiperb()

construtor vazio

Method Detail

calcFuncao

public double calcFuncao(double valor)


Specified by:

calcFuncao in interface FuncaoSaida

Parameters:

valor - valor a ser aplicado na função do tipo double

Returns:

retorna o resultado da função com tipo double

calcDerivada

public double calcDerivada(double valor)


Specified by:

calcDerivada in interface FuncaoSaida

Parameters:

valor - valor a ser aplicado na derivada da função como double

Returns:

retorna o resultado da de derivada da função como double

83

getNome

public java.lang.String getNome()


Specified by:

getNome in interface FuncaoSaida

Returns:


84

manipulacaoArquivos

Class LeitorPadroes java.lang.Object

manipulacaoArquivos.LeitorPadroes

public class LeitorPadroes extends java.lang.Object

Le arquivo com os padrões de treinamento

Author:


Constructor Summary

LeitorPadroes()

Construtor vazio

LeitorPadroes(java.lang.String pNomeArquivo)

Construtor com parâmetro

Method Summary

redeNeural.PadroesTreinamento lerDadosTreinamento()

Leitor dos padrões para treinamento




85

Constructor Detail

LeitorPadroes

public LeitorPadroes()

Construtor vazio

LeitorPadroes

public LeitorPadroes(java.lang.String pNomeArquivo)


Parameters:

pNomeArquivo - nome do arquivo que contém os padrões

Method Detail

lerDadosTreinamento

public redeNeural.PadroesTreinamento lerDadosTreinamento() t hrows java.lang.Exception

Leitor dos padrões para treinamento

Returns:

quantidade de registros lidos

Throws:

lança - exceção de I/O ou erro de leitura no formato do arquivo

java.lang.Exception

86

manipulacaoArquivos

Class PersistenciaRede java.lang.Object

manipulacaoArquivos.PersistenciaRede

public class PersistenciaRede extends java.lang.Object

Persistência de rede neural artificial em arquivo texto

Author:


Constructor Summary

PersistenciaRede()

Construtor vazio

PersistenciaRede(java.lang.String nArquivo)


Method Summary

void gerarArquivoRede(java.lang.String nomeArquivo,

RedeNeural rna)

Cria o arquivo da rede

RedeNeural lerArquivoRede(java.lang.String nomeArquivo)

Leitor de rede neural artificial




87

Constructor Detail

PersistenciaRede

public PersistenciaRede()

Construtor vazio

PersistenciaRede

public PersistenciaRede(java.lang.String nArquivo)


Parameters:

nArquivo - nome do arquivo onde será gravada a rede

Method Detail

gerarArquivoRede

public void gerarArquivoRede(java.lang.String nomeArquivo, RedeNeural rna) throws java.lang.Exception

Cria o arquivo da rede

Parameters:

nomeArquivo - nome do arquivo que conterá a rede

rna - rede a ser gravada

Throws:

java.lang.Exception - Lança exceção se não for possível criar o arquivo ou

escrever nele

88

lerArquivoRede

public RedeNeural lerArquivoRede(java.lang.String nomeArquivo) throws java.lang.Exceptio n

Leitor de rede neural artificial

Parameters:

nomeArquivo - nome do arquivo que contém a rede

Returns:

retorna a rede neural lida como RedeNeural

Throws:

java.lang.Exception - Lança exceção se não for possível ler o arquivo, tiver

nome de função inválida, número de campos inválido no registro, não conseguir criar

a rede lida.

89

manipulacaoArquivos

Class GravadorArquivoPesos java.lang.Object

manipulacaoArquivos.GravadorArquivoPesos

public class GravadorArquivoPesos extends java.lang.Object

Grava arquivo de pesos de uma rede neural artificial

Author:


Constructor Summary

GravadorArquivoPesos()

Construtor vazio

GravadorArquivoPesos(java.lang.String nArquivo)


Method Summary

boolean gerarArquivoPesos(java.lang.String nomeArquivo,

RedeNeural rna)

Gera o arquivo de pesos




90

Constructor Detail

GravadorArquivoPesos

public GravadorArquivoPesos()

Construtor vazio

GravadorArquivoPesos

public GravadorArquivoPesos(java.lang.String nArquivo)


Parameters:

nArquivo - nome do arquivo onde serão gravados os pesos

Method Detail

gerarArquivoPesos

public boolean gerarArquivoPesos(java.lang.String nomeArquivo, RedeNeural rna) throws java.lang.Exceptio n

Gera o arquivo de pesos

Parameters:

nomeArquivo - nome do arquivo onde serão gravados os pesos

rna - rede neural da qual ser~ao gravados os pesos

Returns:

retorna true se conseguiu gravar

Throws:

java.lang.Exception - lan'ca exce'c~ao se n~ao conseguir criar ou

escrever no arquivo

91

geradoresCodigo

Class GeradorCodigo java.lang.Object

geradoresCodigo.GeradorCodigo

Direct Known Subclasses:

GeradorCodigoCPP, GeradorCodigoJava, GeradorCodigoJS, GeradorCodigoOP

public abstract class GeradorCodigo extends java.lang.Object

Author:


Field Summary

protected

java.io.BufferedWriter

arquivo

protected

java.lang.String

extensaoArquivo

protected

java.lang.String

fimComentarioBloco

protected

java.lang.String

inicioComentarioBloco

protected

java.lang.String

inicioComentarioLinha

Constructor Summary

GeradorCodigo()

Creates a new instance of GeradorCodigo

92

Method Summary

void escrvComentLinha(java.lang.String comentario)

Escrever comentário de uma única linha

void escrvLnhComentBlco(java.lang.String comentario)

Escrever uma linha em um bloco de comentário

void finalizarComentarioBloco()

Inserir caracter(es) de final de comentário de bloco

void gerarArquivoEmDisco(java.lang.String nomeArquivo)

Gera em disco um arquivo vazio com o nome passado como parâmetro

void gerarFuncaoRNAMLP(int nosEntrada, int nosEscondidos,

int nosSaida, double[][] pesosHI, double[][] pesosO H, int bias,

double limiar)

Escreve a função com os dados da rede treinada no arquivo do tipo

selecionado

void iniComentBloco()

Inserir caracter(es) de início de comentário de bloco




Field Detail

arquivo

protected java.io.BufferedWriter arquivo

inicioComentarioBloco

protected java.lang.String inicioComentarioBloco

93

fimComentarioBloco protected java.lang.String fimComentarioBloco

inicioComentarioLinha protected java.lang.String inicioComentarioLinha

extensaoArquivo protected java.lang.String extensaoArquivo

Constructor Detail

GeradorCodigo public GeradorCodigo()

Creates a new instance of GeradorCodigo

Method Detail

gerarArquivoEmDisco public void gerarArquivoEmDisco(java.lang.String nomeArquivo) throws java.lang.Exception

Gera em disco um arquivo vazio com o nome passado como parâmetro

Throws:

java.lang.Exception

escrvComentLinha public void escrvComentLinha(java.lang.String comentario) throws java.lang.Exception

Escrever comentário de uma única linha

Throws:

java.lang.Exception

iniComentBloco

public void iniComentBloco() throws java.lang.Exception

Inserir caracter(es) de início de comentário de bloco

Throws:

java.lang.Exception

94

escrvLnhComentBlco

public void escrvLnhComentBlco(java.lang.String comentario) throws java.lang.Exception

Escrever uma linha em um bloco de comentário

Throws:

java.lang.Exception

finalizarComentarioBloco

public void finalizarComentarioBloco() throws java.lang.Exce ption

Inserir caracter(es) de final de comentário de bloco

Throws:

java.lang.Exception

gerarFuncaoRNAMLP

public void gerarFuncaoRNAMLP(int nosEntrada, int nosEscondidos, int nosSaida, double[][] pesosHI, double[][] pesosOH, int bias, double limiar) throws java.lang.Exception


selecionado

Throws:

java.lang.Exception

95

geradoresCodigo

Class GeradorCodigoJS java.lang.Object


geradoresCodigo.GeradorCodigoJS

public class GeradorCodigoJS extends GeradorCodigo

Author:


Field Summary

Fields inherited from class geradoresCodigo.GeradorCodigo

arquivo , extensaoArquivo , fimComentarioBloco , inicioComentarioBloco ,


Constructor Summary

GeradorCodigoJS()

Creates a new instance of geradorCodigoJS

Method Summary

void gerarFuncaoRNAMLP(int nosEntrada, int nosEscond idos,

int nosSaida, double[][] pesosHI, double[][] pesosO H, int bias,

double limiar)


selecionado

96

Methods inherited from class geradoresCodigo.GeradorCodigo

escrvComentLinha , escrvLnhComentBlco , finalizarComentarioBloco ,

gerarArquivoEmDisco , iniComentBloco




Constructor Detail

GeradorCodigoJS

public GeradorCodigoJS()

Creates a new instance of geradorCodigoJS

Method Detail

gerarFuncaoRNAMLP

public void gerarFuncaoRNAMLP(int nosEntrada, int nosEscondidos, int nosSaida, double[][] pesosHI, double[][] pesosOH, int bias, double limiar) throws java.lang.Exception

Description copied from class: GeradorCodigo


selecionado

Overrides:

gerarFuncaoRNAMLP in class GeradorCodigo

Throws:

java.lang.Exception

97

geradoresCodigo

Class GeradorCodigoJava java.lang.Object


geradoresCodigo.GeradorCodigoJava

public class GeradorCodigoJava extends GeradorCodigo

Author:


Field Summary




Constructor Summary

GeradorCodigoJava()

Creates a new instance of GeradorCodigoJava

Method Summary

98



gerarArquivoEmDisco , gerarFuncaoRNAMLP , iniComentBloco




Constructor Detail

GeradorCodigoJava

public GeradorCodigoJava()

Creates a new instance of GeradorCodigoJava

99

geradoresCodigo

Class GeradorCodigoCPP java.lang.Object


geradoresCodigo.GeradorCodigoCPP

public class GeradorCodigoCPP extends geradoresCodigo.GeradorCodigo

Gera arquivo fonte em linguagem C++

Author:


Field Summary


arquivo, extensaoArquivo, fimComentarioBloco, inici oComentarioBloco,


Constructor Summary

GeradorCodigoCPP()

Construtor vazio Gera as variáveis relacionadas aos comentários e extensão de

arquivo

100

Method Summary

void gerarFuncaoRNAMLP(redeNeural.RedeNeural rna,

double limiar)

Implementação da função abstrata


escrvComentLinha, escrvLnhComentBlco, finalizarCome ntarioBloc o,

gerarArquivoEmDisco, iniComentBloco




Constructor Detail

GeradorCodigoCPP

public GeradorCodigoCPP()

Construtor vazio Gera as variáveis relacionadas aos comentários e extensão

de arquivo

101

Method Detail

gerarFuncaoRNAMLP

public void gerarFuncaoRNAMLP(redeNeural.RedeNeural rna, double limiar) throws java.lang.Exception

Implementação da função abstrata

Specified by:

gerarFuncaoRNAMLP in class geradoresCodigo.GeradorCodigo

Parameters:

rna - Rede neural com a qual será gerado o código fonte

limiar - limite entre o valor 0 e 1 da saída

Throws:

java.lang.Exception - lança exceção se não conseguir escrever no arquivo

102

geradoresCodigo

Class GeradorCodigoOP java.lang.Object


geradoresCodigo.GeradorCodigoOP

public class GeradorCodigoOP extends GeradorCodigo

Author:


Field Summary




Constructor Summary

GeradorCodigoOP()

Creates a new instance of GeradorCodigoOP

Method Summary



gerarArquivoEmDisco , gerarFuncaoRNAMLP , iniComentBloco

103




Constructor Detail

GeradorCodigoOP

public GeradorCodigoOP()

Creates a new instance of GeradorCodigoOP

104

ANEXO 4 – Função RNAMLP

function RNAMLP( valor1, valor2, valor3, valor4, va lor5, valor6, valor7, valor8, valor9, valor10 ) { var entrada = [1, valor1, valor2, valor3, valo r4, valor5, valor6, valor7, valor8, valor9, valor10]; var saida = new Array(10); var escondidos = new Array(11); var pesosHI = [ [-1.2856558579221395, -3.3546024179427647, 0.138089 80636806736, 0.7788557265218385, -3.663723505738529, 6.814339275 97742, 1.590259488692084, 1.3171995432140704, -1.770521516 0389425, 2.4569599466855405, -1.7627352741308377], [-1.9030009103486898, -0.09222009260296783, 0.25454 33888946836, 0.8248402873175982, -0.6306016081459316, -0.4864277 843397504, -1.0579876002364228, 5.455049306517363, 0.8614507683 642678, -2.2598068483598115, 0.48983030833878743], [1.5791080355866962, 1.1126830859316539, 2.08067614 86299226, 0.8358606741585255, -3.5825915527431857, -1.7467076 85515664, -1.271711791890792, -1.2678650336258377, 1.696222551 7309462, -0.7583112393123117, 0.3146227849727759], [1.3811458460364616, 2.566915117328856, -0.86398970 42529363, -1.6506867030635746, 0.29149801747624104, -3.7331368 822106383, 0.9351214828477853, 0.7098301502871806, -1.09068260 44844635, 1.1443098558699156, 0.07673126338924965], [3.6407741333214414, -3.9364044933229114, -2.994817 5942649438, 0.15315956057606944, -0.11850310790472499, -1.60237 40558529822, -0.5690093114567213, 0.2562284649306525, 0.408154979 81415894, -1.2591737931939333, 0.8574888383500717], [-2.596313433400822, 1.6292312558561262, -1.0917510 558689612, 5.617972865957996, 0.662377895827699, -0.5686429528 598356, 0.2730521011060961, -0.41282611022348087, -1.227612 200063836, -0.22122377896824008, 0.7997339332332916], [-3.031242348504958, 0.13600495222363043, 0.3658218 944698372, -1.350837240090895, 0.20141865197690725, 0.809063571 8730524, 0.8594466356086035, 0.25316698147111577, -0.6989354 794637509, 0.21713561161102007, 5.604808595088253], [-3.3088183631140002, 0.9334181516336892, -1.018931 3904658557, -0.4214245180334989, 1.7757691468433698, -0.46226463 189662415, 0.45941804628514243, -0.2891921720863641, 5.2162861 20029775, 0.4557248135224579, 0.07999525199370024], [0.7750881490651261, 0.3002802604550937, 0.53101214 53830041, -0.6704508008707264, 2.940638295467867, -0.732454695 7380885, -4.261796141402154, 0.17579344703024402, -0.52020928 88905405, 0.4332780965299074, 0.2827176150692071], [-1.8494966523813985, -1.8319088315007193, 3.301291 415089924, 0.8405531018459189, 1.6510731530166576, -1.28575206 5274323, 2.0501957031949294, 0.2104686173954527, -0.22885431 381364849, -0.5324394298815687, -0.1654749759645047], [1.7904963312487412, 1.8903473799894446, -0.1501206 40765903, -1.3496156794944019, 1.5601888334857037, 0.585619812 3045506, 0.21248308661881335, -0.7534446033074967, -0.039271 71079075187, -4.399377418601928, -0.590704164543097],

105

] var pesosOH = [[-0.787725138506782, 10.64392292 2017769, -2.5923543300505765, -0.021685354539227538, -1.68835 0030152189, -0.5381267010466972, -0.34513575689551396, -0.067998 84581371239, -0.3994258997081885, -0.40386133218184284, -2.309197 5531337146], [-3.830921890522562, 1.560252109939317, 1.990836962 8655072, -1.1776843598226274, -0.48202590732934353, -1.178870 7361739668, -0.7805217896712606, 10.566643532494298, -1.89029283 61129037, 0.40499379824681897, -1.145568319493568], [13.265903517655303, 0.9073707561793445, -4.0218738 91044608, -9.500957123697356, -5.68125463646632, -1.0792962960 197756, 1.1461402359045958, -0.6583422216693, -2.4251420020 40002, -3.750297544763434, -0.045864516119610815], [-2.3034363168091514, 0.7589655461662765, 3.6331641 902942304, -2.0601835274346043, -6.182752149984374, -3.33731485 97372118, 0.8476556305409105, -1.4105053927947653, 2.48984371 71701766, 8.90197479417717, -1.1082563249697226], [-5.214673196217013, 0.289684903672961, 1.865313860 7876867, 5.252415257814263, -8.802416489778418, 4.5377641424 21334, 1.1557448266025159, 1.9385986463863862, 0.175421325 54483894, -3.2788262825293715, 4.108821802711848], [1.4812132332539296, -1.003181305943442, -3.8899523 509534455, 2.405762478162071, -0.6085596103961814, 0.128135290 47533911, 1.576509619487255, 2.2053410247159935, -10.02873096 973665, 4.6382410567312835, 1.0114984126627093], [-5.672910908176199, -0.1436856719356623, 0.5181772 400775964, 0.26774045507871846, 0.23173776340482363, 0.7726011 098634623, 10.3201692155927, 0.3924799711314042, -0.0651760036 5995121, -0.5972605410724682, -0.5971845134496148], [5.9551734423373235, -2.181143551720631, -1.9456685 02770097, 1.3303559090965538, -2.2590447380096585, -0.0869378 6150461995, -0.198482287833655, 2.4171710408105627, 2.1209061802 4629, -0.5813378580836922, -10.937177458423054], [-1.364096656841394, 0.7615384771783854, -0.8478301 558027015, -2.2327765088195446, -1.8080383964432944, 10.6844192 62939869, -1.8602724564093847, 1.3195984374207343, 0.050638164 673315424, 0.07882040214924643, -2.1706674236879295], [-6.013143734676788, -2.067581763652359, -8.6618954 95552908, 1.536019227651033, -1.222478374878116, 3.5553323688 38095, 0.6311249924674665, 4.147994058827936, 5.5402811175 658275, 5.212886055989511, 2.9354627708783942], ] for(j = 0; j < 11; j++) { escondidos[j] = 0; for(i = 0; i < 11; i++) { escondidos[j] += pesosHI[j][i] * entrad a[i]; } } escondidos[0] = 1; for(j = 1; j < 11; j++){ escondidos[j] = (1/(1 + Math.exp(-escondido s[j]))); } for(k = 0; k < 10; k++) { saida[k] = 0; for(j = 0; j < 11; j++){ saida[k] += pesosOH[k][j] * escondidos[ j]; } }

106

for(k = 0; k < 10; k++){ saida[k] = (1/(1 + Math.exp(-saida[k]))); } for(k = 0; k < 10; k++){ saida[k] = saida[k] < 0.5 ? 0 : 1; } // --> O resultado é o vetor saida }

107

ANEXO 5 – Exercício Completo HTML/javascript

<HTML> <HEAD> <STYLE> H1 { font-family: Arial; font-size: 12pt; font-weight: bold; } TD { font-family: Arial; font-size: 10pt; } BODY { font-family: Arial; font-size: 10pt; } </STYLE> <TITLE>Exercício de Neuroanatomia</TITLE> <SCRIPT> var e = new Array(10); var saida = new Array(10); function RNAMLP( valor1, valor2, valor3, valor4, va lor5, valor6, valor7, valor8, valor9, valor10 ) { var entrada = [1, valor1, valor2, valor3, valo r4, valor5, valor6, valor7, valor8, valor9, valor10]; var escondidos = new Array(11); var pesosHI = [ [-1.2856558579221395, -3.3546024179427647, 0.138089 80636806736, 0.7788557265218385, -3.663723505738529, 6.814339275 97742, 1.590259488692084, 1.3171995432140704, -1.770521516 0389425, 2.4569599466855405, -1.7627352741308377], [-1.9030009103486898, -0.09222009260296783, 0.25454 33888946836, 0.8248402873175982, -0.6306016081459316, -0.4864277 843397504, -1.0579876002364228, 5.455049306517363, 0.8614507683 642678, -2.2598068483598115, 0.48983030833878743], [1.5791080355866962, 1.1126830859316539, 2.08067614 86299226, 0.8358606741585255, -3.5825915527431857, -1.7467076 85515664, -1.271711791890792, -1.2678650336258377, 1.696222551 7309462, -0.7583112393123117, 0.3146227849727759], [1.3811458460364616, 2.566915117328856, -0.86398970 42529363, -1.6506867030635746, 0.29149801747624104, -3.7331368 822106383, 0.9351214828477853, 0.7098301502871806, -1.09068260 44844635, 1.1443098558699156, 0.07673126338924965], [3.6407741333214414, -3.9364044933229114, -2.994817 5942649438, 0.15315956057606944, -0.11850310790472499, -1.60237 40558529822, -0.5690093114567213, 0.2562284649306525, 0.408154979 81415894, -1.2591737931939333, 0.8574888383500717], [-2.596313433400822, 1.6292312558561262, -1.0917510 558689612, 5.617972865957996, 0.662377895827699, -0.5686429528 598356, 0.2730521011060961, -0.41282611022348087, -1.227612 200063836, -0.22122377896824008, 0.7997339332332916], [-3.031242348504958, 0.13600495222363043, 0.3658218 944698372, -1.350837240090895, 0.20141865197690725, 0.809063571 8730524,

108

0.8594466356086035, 0.25316698147111577, -0.6989354 794637509, 0.21713561161102007, 5.604808595088253], [-3.3088183631140002, 0.9334181516336892, -1.018931 3904658557, -0.4214245180334989, 1.7757691468433698, -0.46226463 189662415, 0.45941804628514243, -0.2891921720863641, 5.2162861 20029775, 0.4557248135224579, 0.07999525199370024], [0.7750881490651261, 0.3002802604550937, 0.53101214 53830041, -0.6704508008707264, 2.940638295467867, -0.732454695 7380885, -4.261796141402154, 0.17579344703024402, -0.52020928 88905405, 0.4332780965299074, 0.2827176150692071], [-1.8494966523813985, -1.8319088315007193, 3.301291 415089924, 0.8405531018459189, 1.6510731530166576, -1.28575206 5274323, 2.0501957031949294, 0.2104686173954527, -0.22885431 381364849, -0.5324394298815687, -0.1654749759645047], [1.7904963312487412, 1.8903473799894446, -0.1501206 40765903, -1.3496156794944019, 1.5601888334857037, 0.585619812 3045506, 0.21248308661881335, -0.7534446033074967, -0.039271 71079075187, -4.399377418601928, -0.590704164543097], ] var pesosOH = [[-0.787725138506782, 10.64392292 2017769, -2.5923543300505765, -0.021685354539227538, -1.68835 0030152189, -0.5381267010466972, -0.34513575689551396, -0.067998 84581371239, -0.3994258997081885, -0.40386133218184284, -2.309197 5531337146], [-3.830921890522562, 1.560252109939317, 1.990836962 8655072, -1.1776843598226274, -0.48202590732934353, -1.178870 7361739668, -0.7805217896712606, 10.566643532494298, -1.89029283 61129037, 0.40499379824681897, -1.145568319493568], [13.265903517655303, 0.9073707561793445, -4.0218738 91044608, -9.500957123697356, -5.68125463646632, -1.0792962960 197756, 1.1461402359045958, -0.6583422216693, -2.4251420020 40002, -3.750297544763434, -0.045864516119610815], [-2.3034363168091514, 0.7589655461662765, 3.6331641 902942304, -2.0601835274346043, -6.182752149984374, -3.33731485 97372118, 0.8476556305409105, -1.4105053927947653, 2.48984371 71701766, 8.90197479417717, -1.1082563249697226], [-5.214673196217013, 0.289684903672961, 1.865313860 7876867, 5.252415257814263, -8.802416489778418, 4.5377641424 21334, 1.1557448266025159, 1.9385986463863862, 0.175421325 54483894, -3.2788262825293715, 4.108821802711848], [1.4812132332539296, -1.003181305943442, -3.8899523 509534455, 2.405762478162071, -0.6085596103961814, 0.128135290 47533911, 1.576509619487255, 2.2053410247159935, -10.02873096 973665, 4.6382410567312835, 1.0114984126627093], [-5.672910908176199, -0.1436856719356623, 0.5181772 400775964, 0.26774045507871846, 0.23173776340482363, 0.7726011 098634623, 10.3201692155927, 0.3924799711314042, -0.0651760036 5995121, -0.5972605410724682, -0.5971845134496148], [5.9551734423373235, -2.181143551720631, -1.9456685 02770097, 1.3303559090965538, -2.2590447380096585, -0.0869378 6150461995, -0.198482287833655, 2.4171710408105627, 2.1209061802 4629, -0.5813378580836922, -10.937177458423054], [-1.364096656841394, 0.7615384771783854, -0.8478301 558027015, -2.2327765088195446, -1.8080383964432944, 10.6844192 62939869, -1.8602724564093847, 1.3195984374207343, 0.050638164 673315424, 0.07882040214924643, -2.1706674236879295], [-6.013143734676788, -2.067581763652359, -8.6618954 95552908, 1.536019227651033, -1.222478374878116, 3.5553323688 38095,

109

0.6311249924674665, 4.147994058827936, 5.5402811175 658275, 5.212886055989511, 2.9354627708783942], ] for(j = 0; j < 11; j++) { escondidos[j] = 0; for(i = 0; i < 11; i++) { escondidos[j] += pesosHI[j][i] * entrad a[i]; } } escondidos[0] = 1; for(j = 1; j < 11; j++){ escondidos[j] = (1/(1 + Math.exp(-escondido s[j]))); } for(k = 0; k < 10; k++) { saida[k] = 0; for(j = 0; j < 11; j++){ saida[k] += pesosOH[k][j] * escondidos[ j]; } } for(k = 0; k < 10; k++){ saida[k] = (1/(1 + Math.exp(-saida[k]))); } for(k = 0; k < 10; k++){ saida[k] = saida[k] < 0.5 ? 0 : 1; } // --> O resultado é o vetor saida } function muda(obj) { if (obj.style.visibility == "hidden") { obj.style.visibility = ''; } else { obj.style.visibility = 'hidden'; } } function desliga() { iregiao8.style.visibility = 'hidden'; iregiao9.style.visibility = 'hidden'; iregiao10.style.visibility = 'hidden'; iregiao11.style.visibility = 'hidden'; iregiao12.style.visibility = 'hidden'; iregiao13.style.visibility = 'hidden'; iregiao14.style.visibility = 'hidden'; iregiao16.style.visibility = 'hidden'; iregiao17.style.visibility = 'hidden'; iregiao18.style.visibility = 'hidden'; } function liga() { iregiao8.style.visibility = ''; iregiao9.style.visibility = ''; iregiao10.style.visibility = ''; iregiao11.style.visibility = ''; iregiao12.style.visibility = ''; iregiao13.style.visibility = ''; iregiao14.style.visibility = ''; iregiao16.style.visibility = ''; iregiao17.style.visibility = ''; iregiao18.style.visibility = '';

110

} function elege() { return Math.floor(Math.random() * 10) } function corVerde(obj) { obj.bgColor = '#00FF00'; } function corVermelho(obj) { obj.bgColor = '#FF0000'; } function tiraCor() { L1.bgColor = '#FFFFFF'; L2.bgColor = '#FFFFFF'; L3.bgColor = '#FFFFFF'; L4.bgColor = '#FFFFFF'; L5.bgColor = '#FFFFFF'; L5.bgColor = '#FFFFFF'; L7.bgColor = '#FFFFFF'; L8.bgColor = '#FFFFFF'; L9.bgColor = '#FFFFFF'; L10.bgColor = '#FFFFFF'; L1B.style.visibility = 'hidden'; L2B.style.visibility = 'hidden'; } function entrada(n) { e[0] = 0; e[1] = 0; e[2] = 0; e[3] = 0; e[4] = 0; e[5] = 0; e[6] = 0; e[7] = 0; e[8] = 0; e[9] = 0; for(i = 0; i < n; i++) { switch(elege()) { case 0: e[0] = 1; break; case 1: e[1] = 1; break; case 2: e[2] = 1; break; case 3: e[3] = 1; break; case 4: e[4] = 1; break; case 5: e[5] = 1; break; case 6: e[6] = 1; break; case 7: e[7] = 1; break; case 8: e[8] = 1; break; case 9: e[9] = 1; break; } } for(i = 0; i < 10; i++) { if(e[i] == 1) { if(i == 0) iregiao8.style.visibility = ''; if(i == 1) iregiao9.style.visibility = ''; if(i == 2) iregiao10.style.visibility = ''; if(i == 3) iregiao11.style.visibility = ''; if(i == 4) iregiao12.style.visibility = '';

111

if(i == 5) iregiao13.style.visibility = ''; if(i == 6) iregiao14.style.visibility = ''; if(i == 7) iregiao16.style.visibility = ''; if(i == 8) iregiao17.style.visibility = ''; if(i == 9) iregiao18.style.visibility = ''; } } } </SCRIPT> </HEAD> <BODY> <IMG ID=Principal SRC="imagens/tratamentook.jpg" st yle="position: absolute; left: 10px; top: 15px"></IMG> <IMG ID=iregiao8 SRC="imagens/regiao8.gif" alt="fac e medial superior do giro pré-central" style="position: absolute; left: 9px; top; 7px; z-index: 1; filter: alpha(opacity=50, FinishOpacity=15, Styl e=0)"></IMG> <IMG ID=iregiao9 SRC="imagens/regiao9.gif" style="p osition: absolute; left: 9px; top; 7px; z-index: 1; filter: alpha(opacity=50 , FinishOpacity=15, Style=0)"></IMG> <IMG ID=iregiao10 SRC="imagens/regiao10.gif" style= "position: absolute; left: 9px; top; 7px; z-index: 2; filter: alpha(opac ity=50, FinishOpacity=15, Style=0)"></IMG> <IMG ID=iregiao11 SRC="imagens/regiao11.gif" style= "position: absolute; left: 9px; top; 7px; z-index: 3; filter: alpha(opac ity=50, FinishOpacity=15, Style=0)"></IMG> <IMG ID=iregiao12 SRC="imagens/regiao12.gif" style= "position: absolute; left: 9px; top; 7px; z-index: 4; filter: alpha(opac ity=50, FinishOpacity=15, Style=0)"></IMG> <IMG ID=iregiao13 SRC="imagens/regiao13.gif" style= "position: absolute; left: 9px; top; 7px; z-index: 5; filter: alpha(opac ity=50, FinishOpacity=15, Style=0)"></IMG> <IMG ID=iregiao14 SRC="imagens/regiao14.gif" style= "position: absolute; left: 9px; top; 7px; z-index: 2; filter: alpha(opac ity=50, FinishOpacity=15, Style=0)"></IMG> <IMG ID=iregiao16 SRC="imagens/regiao16.gif" style= "position: absolute; left: 9px; top; 7px; z-index: 3; filter: alpha(opac ity=50, FinishOpacity=15, Style=0)"></IMG> <IMG ID=iregiao17 SRC="imagens/regiao17.gif" style= "position: absolute; left: 9px; top; 7px; z-index: 4; filter: alpha(opac ity=50, FinishOpacity=15, Style=0)"></IMG> <IMG ID=iregiao18 SRC="imagens/regiao18.gif" style= "position: absolute; left: 9px; top; 7px; z-index: 5; filter: alpha(opac ity=50, FinishOpacity=15, Style=0)"></IMG> <SCRIPT> desliga(); entrada(5); </SCRIPT> <BR> <H3 style="font-family: Arial; font-size: 12pt; fon t-weight: bold; position: absolute; top: 325px">Indique os provávei s sintomas do paciente com lesões nas <BR>regiões apresentadas em destaque :</H3> <FORM name=form style="position: absolute; top: 363 px"> <TABLE CELLSPACING=0 CELLPADDING=0> <TR><TD ID=L1> <INPUT TYPE=CHECKBOX NAME=hemianopsia> Hemianopsia </TD> <TD ID=L1A WIDTH=100> </TD>

112

<TD ID=L1B BGCOLOR=#00FF00>CORRETO </TD> </TR> <TR><TD ID=L2> <INPUT TYPE=CHECKBOX NAME=dislexia> Dislexia </TD> <TD ID=L2A> </TD> <TD ID=L2B BGCOLOR=#FF0000 BORDER=1>INCORRETO </TD> </TR> <TR><TD ID=L3> <INPUT TYPE=CHECKBOX NAME=emocional> Alteração Emoc ional </TD> <TD ID=L3A> </TD> <TD ID=L3B BGCOLOR=#FFFFFF> </TD></TR> <TR><TD ID=L4> <INPUT TYPE=CHECKBOX NAME=memoria> Alteracão da Mem ória </TD> <TD ID=L4A> </TD> <TD ID=L4B BGCOLOR=#FFFFFF> </TD></TR> <TR><TD ID=L5> <INPUT TYPE=CHECKBOX NAME=esfincter> Mal Funcioname nto do Esfincter Anal/Vesical </TD> <TD ID=L5A> </TD> <TD ID=L5B BGCOLOR=#FFFFFF> </TD></TR> <TR><TD ID=L6> <INPUT TYPE=CHECKBOX NAME=personalidade> Personalid ade Alterada </TD> <TD ID=L6A> </TD> <TD ID=L6B BGCOLOR=#FFFFFF> </TD></TR> <TR><TD ID=L7> <INPUT TYPE=CHECKBOX NAME=olfacao> Alteracao da Olf ação </TD> <TD ID=L7A> </TD> <TD ID=L7B BGCOLOR=#FFFFFF> </TD></TR> <TR><TD ID=L8> <INPUT TYPE=CHECKBOX NAME=ataxia> Ataxia </TD> <TD ID=L8A> </TD> <TD ID=L8B BGCOLOR=#FFFFFF> </TD></TR> <TR><TD ID=L9> <INPUT TYPE=CHECKBOX NAME=hemiplegia> Hemiplegia do s Membros Inferiores </TD> <TD ID=L9A>

113

</TD> <TD ID=L9B BGCOLOR=#FFFFFF> </TD></TR> <TR><TD ID=L10> <INPUT TYPE=CHECKBOX NAME=parestesia> Alteração Sen sorial Superficial dos Membros Inferiores </TD> <TD ID=L10A> </TD> <TD ID=L10B BGCOLOR=#FFFFFF> </TD></TR> </TABLE> <BR> <INPUT TYPE=BUTTON NAME=bConfirma VALUE=CONFIRMA ONCLICK="confirma()"> <INPUT TYPE=BUTTON NAME=bRepete VALUE="TENTAR DE NOVO" ONCLICK="repete()"> </FORM> <SCRIPT> tiraCor(); function confirma() { RNAMLP(e[0], e[1], e[2], e[3], e[4], e[5], e[6], e [7], e[8], e[9]); if((form.hemianopsia.checked && saida[0] == 1) || (!form.hemianopsia.checked && saida[0] == 0) ) { corVerde(L1); } else { corVermelho(L1); } if((form.dislexia.checked && saida[1] == 1) || (!form.dislexia.checked && saida[1] == 0)) { corVerde(L2); } else { corVermelho(L2); } if((form.emocional.checked && saida[2] == 1) ||(!form.emocional.checked && saida[2] == 0)) { corVerde(L3); } else { corVermelho(L3); } if((form.memoria.checked && saida[3] == 1) ||(!for m.memoria.checked && saida[3] == 0)) { corVerde(L4); } else { corVermelho(L4); } if((form.esfincter.checked && saida[4] == 1) ||(!form.esfincter.checked && saida[4] == 0)) { corVerde(L5); } else { corVermelho(L5); } if((form.personalidade.checked && saida[5] == 1) ||(!form.personalidade.checked && saida[5] == 0)) { corVerde(L6); } else { corVermelho(L6); } if((form.olfacao.checked && saida[6] == 1) ||(!for m.olfacao.checked && saida[6] == 0)) {

114

corVerde(L7); } else { corVermelho(L7); } if((form.ataxia.checked && saida[7] == 1) || (!for m.ataxia.checked && saida[7] == 0)) { corVerde(L8); } else { corVermelho(L8); } if((form.hemiplegia.checked && saida[8] == 1) ||(!form.hemiplegia.checked && saida[8] == 0)) { corVerde(L9); } else { corVermelho(L9); } if((form.parestesia.checked && saida[9] == 1) ||(!form.parestesia.checked && saida[9] == 0)) { corVerde(L10); } else { corVermelho(L10); } L1B.style.visibility = ''; L2B.style.visibility = ''; } function repete() { location.reload(); } </SCRIPT> </BODY> </HTML>

115

ANEXO 6 – Questionário de uso do aplicativo HTML

Sete alunos do curso de Medicina responderam ao questionário, cujas respostas

estão agrupadas a seguir:

1 – Quanto a facilidade de uso do aplicativo, você achou:

Fácil Razoavelmente Fácil Difícil

7 0 0

2 – O que você acha de disponibilizar exercícios de neuroanatomia na internet?

Muito Útil Razoavelmente Útil Nada Útil

7 0 0

3 – Quanto a qualidade das respostas do aplicativo, classifique:

Ótima Boa Ruim

4 3 0

4 – Quanto ao estímulo de estudo de Neuroanatomia, o aplicativo proporciona:

Sim Um pouco Não

Flexibilidade no estudo prático 7 0 0

Condições de estudo individual 7 0 0

Conforto na utilização 7 0 0

Manutenção do interesse no estudo da disciplina 6 1 0

Relação do conteúdo teórico ao prático 6 0 0

116

ANEXO 7 – Código Fonte

Classe RedeNeural

package redeNeural; import funcoesSaida.*; /* * RedeNeural.java * * Created on 20 de Maio de 2005, 20:07 */ /** * Permite a criação de uma rede neural artificial para uso qualquer.<br> * A função de saída a ser usada na rede neural dev e ser do tipo FuncaoSaida, outra classe (interface) pertencente ao pacote rede neural. * @author João Carlos Testi Ferreira e Júnior Bar bosa Dymow * @version 1.0.0 */ public class RedeNeural implements java.io.Serializ able { private int nosEntrada; private int nosEscondidos; private int nosSaida; private FuncaoSaida funcao; private int bias; private double pesosHI[][]; private double pesosOH[][]; private int entradas[]; private double escondidos[]; private double saidas[]; private boolean estaTreinada; /** * Contrutor vazio<br> * Cria a rede com a seguinte característica:<b r> * - 2 nós de entrada<br> * - 1 nó de saída <br> * - 1 nó escondido<br> * - bias na camada de entrada e camada escondi da<br> * - executa inicializaDefaults **/ public RedeNeural() { nosEntrada = 2; nosSaida = 1; bias = 1; nosEscondidos = 1; inicializaDefaults(); } /** * Contrutor com parametros<br> * Cria a rede de acordo com os parâmetros info rmados. * @param nE quantidade de nós de entrada<br> * @param nS quantidade de nós de saída<br> * @param nBias uso do bias, se 0 não usa, se 1 usa.<br> * O número de nós escondidos será a média entr e os nós de entrada e nós de saída.<br> * O construtor executa inicializaDefaults **/ public RedeNeural(int nE, int nS, int nBias) {

117

nosEntrada = nE; nosSaida = nS; nosEscondidos = (int) (nosEntrada + nosSaid a) / 2; bias = nBias; inicializaDefaults(); } /** * Cria os arrays utilizados pela classe e defi ne a função de saída para sigmoidal.<br> * Executa reiniciaTreinamento. */ private void inicializaDefaults() { pesosHI = new double[nosEscondidos + bias][ nosEntrada + bias]; pesosOH = new double[nosSaida][nosEscondido s + bias]; entradas = new int[nosEntrada + bias]; escondidos = new double[nosEscondidos + bia s]; saidas = new double[nosSaida]; funcao = new FuncaoSigmoidal(); reiniciaTreinamento(); } /** * Setter da quantidade de nós de entrada.<br> * Redefine os arrays que dependem desta inform ação. * @param nE quantidade de nós de entrada * @throws Exception Lança exceção caso o númer o de nós de entrada seja inferior a 1. */ public void setNosEntrada(int nE) throws Except ion { if(nE < 1) throw new Exception("Número de nós de e ntradas deve ser maior que zero!"); nosEntrada = nE; pesosHI = new double[nosEscondidos + bias][ nosEntrada + bias]; entradas = new int[nosEntrada + bias]; reiniciaTreinamento(); } /** * Getter da quantidade de nós de entrada. * @return retorna o número de nós de entrada c omo um inteiro. */ public int getNosEntrada() { return nosEntrada; } /** * Setter da quantidade de nós escondidos<br> * Redefine os arrays que dependem desta inform ação * @param nE quantidade de nós escondidos * @throws Exception lança exceção caso o númer o de nós escondidos seja inferior a 1. */ public void setNosEscondidos(int nE) throws Exc eption { if(nE < 1) throw new Exception("Número de nós esco ndidos deve ser maior que zero!"); nosEscondidos = nE; pesosHI = new double[nosEscondidos + bias][ nosEntrada + bias]; pesosOH = new double[nosSaida][nosEscondido s + bias]; escondidos = new double[nosEscondidos + bia s]; reiniciaTreinamento(); }

118

/** * Getter da quantidade de nós escondidos * @return retorna a quantidade de nós escondid os como um inteiro. */ public int getNosEscondidos() { return nosEscondidos; } /** * Setter da quantidade de nós de saída<br> * Redefine os arrays que dependem desta inform ação * @param nS quantidade de nós de saída * @throws Exception lança exceção caso o númer o de nós de saída seja inferior a 1. */ public void setNosSaida(int nS) throws Exceptio n { if(nS < 1) throw new Exception("Número de nós de s aída deve ser maior que zero!"); nosSaida = nS; pesosOH = new double[nosSaida][nosEscondido s + bias]; saidas = new double[nosSaida]; reiniciaTreinamento(); } /** * Getter da quantidade de nós de saída * @return retorna a quantidade de nós de saída como um inteiro. */ public int getNosSaida() { return nosSaida; } /** * Getter da função de saída * @return retorna a função de saída como uma F uncaoSaida. */ public FuncaoSaida getFuncao() { return funcao; } /** * Setter da função de saída * @param pFuncao função de saída, do tipo Func aoSaida (interface) */ public void setFuncao(FuncaoSaida pFuncao) { funcao = pFuncao; reiniciaTreinamento(); } /** * Setter do bias * @param tB se 0 indica que não será usado bia s, se 1 é usado bias * @throws Exception lança exceção se o parâmet ro for diferente de 0 ou 1. */ public void setBias(int tB) throws Exception { if(tB != 0 && tB != 1) throw new Exception("Valor de bias deve ser zero ou um!"); bias = tB; pesosHI = new double[nosEscondidos + bias][ nosEntrada + bias]; pesosOH = new double[nosSaida][nosEscondido s + bias]; entradas = new int[nosEntrada + bias];

119

escondidos = new double[nosEscondidos + bia s]; reiniciaTreinamento(); } /** * Getter do Bias * @return retorna 1 se estiver usando bias e 0 se não estiver. */ public int getBias() { return bias; } /** * Setter para os valores de entrada da rede * @param vE vetor de entrada do tipo int * @throws Exception lança exceção se a quantid ade de entradas não for compatível * com tamanho do vetor. Se o tamanho for igual ao do vetor, o método insere, se * necessário, o bias. Se o tamanho do vetor fo r igual ao número de nós de entrada * mais o bias, a responsabilidade de deixar o bias na primeira posição é do usuário. */ public void setEntrada(int vE[]) throws Excepti on { int i, j; if(vE.length == (nosEntrada + bias)) { for(i = 0; i < nosEntrada + bias; i++) { entradas[i] = vE[i]; } } else if(vE.length == nosEntrada){ if(bias == 1) entradas[0] = 1; for(i = bias, j = 0; i < nosEntrada + b ias; i++, j++) { entradas[i] = vE[j]; } } else { throw new Exception("Tamanho do vetor r ecebido incompatível com vetor de entrada!"); } } /** * Getter para um valor da entrada * @param indice indica qual nó deve ser retorn ado * @return retorna o valor do nó referenciado p or indice como um inteiro */ public int getValorEntradas(int indice) { return entradas[indice]; } /** * Getter para um valor da camada escondida * @param indice indica qual nó deve ser retorn ado * @return retorna o valor do nó referenciado p or indice como um double */ public double getValorEscondidos(int indice) { return escondidos[indice]; } /** * Getter para um valor da saída * @param indice indica qual nó deve ser retorn ado * @return retorna o valor do nó referenciado p or indice como um double

120

*/ public double getValorSaidas(int indice) { return saidas[indice]; } /** * Getter para o vetor de saída * @return retorna o vetor de saída do tipo dou ble * @throws Exception lança exceção caso a rede não esteja treinada, pois não há como gerar saidas. */ public double[] getSaida() throws Exception { if(!estaTreinada) { throw new Exception("Não é possível ger ar saídas, pois a rede não está treinada!"); } return saidas; } /** * Getter para estaTreinada * @return retorna true se a rede estiver trein ada e false se não estiver. */ public boolean getEstaTreinada() { return estaTreinada; } /** * Setter para estaTreinada * @param et valor a ser atribuído a estaTreina da do tipo boolean */ public void setEstaTreinada(boolean et) { estaTreinada = et; } /** * Setter do array de pesos entre a camada de e ntrada e escondida * @param phi array de pesos do tipo double * @throws Exception lança exceção se o tamanho do array não for igual ao array com * os pesos entre a camada de entrada e escondi da */ public void setPesosHI(double phi[][]) throws E xception { if(phi.length != (nosEscondidos + bias) || phi[0].length != (nosEntrada + bias)) { throw new Exception("Tamanho da matriz recebida é inválido!"); } pesosHI = phi; } /** * Getter de um peso das camadas de entrada e e scondida * @param indiceJ índice do array referente a c amada escondida * @param indiceI índice do array referente a c amada de entrada * @return valor do peso referenciado pelos ind ices i e j */ public double getValorPesosHI(int indiceJ, int indiceI) { return pesosHI[indiceJ][indiceI]; } /** * Getter dos pesos entre a camada de entrada e escondida * @return retorna o array de pesos entre a cam ada de entrada e escondida

121

*/ public double[][] getPesosHI() { return pesosHI; } /** * Setter dos pesos entre as camadas escondida e saída * @param poh array com os pesos * @throws Exception lança exceção se o array p assado como parâmetro for de * tamanho diferente do array de pesos entre a camada escondida e saída */ public void setPesosOH(double poh[][]) throws E xception { if(poh.length != (nosSaida) || poh[0].lengt h != (nosEscondidos + bias)) { throw new Exception("Tamanho da matriz recebida é inválido!"); } pesosOH = poh; } /** * Getter de um dos pesos entre a camada escond ida e saída * @param indiceK índice que referencia o nó da saída * @param indiceJ índice que referencia o nó da camada escondida * @return retorna o valor do peso referenciado pelos índices j e k */ public double getValorPesosOH(int indiceK, int indiceJ) { return pesosOH[indiceK][indiceJ]; } /** * Getter do array de pesos entre a camada esco ndida e saída * @return retorna o array de pesos entre a cam ada escondida e saída */ public double[][] getPesosOH() { return pesosOH; } /** * Calcula os valores net da camada escondida e da camada de saída */ public void calculeNets() { int i, j, k; double temp; for(j = 0; j < nosEscondidos + bias; j++){ escondidos[j] = 0.0; for(i = 0; i < nosEntrada + bias; i++){ escondidos[j] += pesosHI[j][i] * en tradas[i]; } } for(k = 0; k < nosSaida; k++) { saidas[k] = 0.0; for(j = 0; j < nosEscondidos + bias; j+ +) { if(bias == 1 && j == 0) { temp = 1; } else { temp = funcao.calcFuncao(escond idos[j]); } saidas[k] += pesosOH[k][j] * temp; } } } /**

122

* Inicializa os pesos com valores aleatórios ***/ public void inicializaPesos() { int i, j, k; for(j = 0; j < (nosEscondidos + bias); j++) { for(i = 0; i < (nosEntrada + bias); i++ ){ pesosHI[j][i] = Math.random(); } } for(k = 0; k < nosSaida; k++) { for(j = 0; j < (nosEscondidos + bias); j++){ pesosOH[k][j] = Math.random(); } } } /** * Reinicia o treinamento da seguinte forma:<br > * - define estaTreinada para false<br> * - executa inicializaPesos */ public void reiniciaTreinamento() { estaTreinada = false; inicializaPesos(); } }

123

Classe TreinaRede

/* * TreinaRede.java * * Created on 18 de Junho de 2005, 21:47 */ package redeNeural; import funcoesSaida.*; import java.util.*; import javax.swing.JProgressBar; /** * Treinamento de uma rede neural artificial * @author João Carlos Testi Ferreira e Júnior Bar bosa Dymow */ public class TreinaRede { private RedeNeural rna; private double erroAceitavel; private int epocasMaximo; private double fatorAprendizagem; private int saidasEsperadas[]; private int entradasTreinamento[][ ]; private int saidasTreinamento[][]; private double fatoresCorrecaoH[]; private double fatoresCorrecaoO[]; private FuncaoSaida funcao; private double pesosOH[][]; private double pesosHI[][]; private int qtdEpocasAtual; private ArrayList<Double> errosMaximos; private double erroMaximo; private boolean vetorTreinamentoLido; /** * Construtor com parâmetros * @param rede rede a ser treinada * @param pT padrões de treinamento a serem usa dos no treinamento * @param pEpocasMaximo número máximo de épocas a ser treinada a rede * @param pFatorAprendizagem fator de aprendiza gem a ser aplicado no treinamento * @param pErroAceitavel maior valor de erro a ser usado como referência na saída */ public TreinaRede(RedeNeural rede, PadroesTrein amento pT, int pEpocasMaximo, double pFatorAprendizagem, double pE rroAceitavel) { rna = rede; entradasTreinamento = pT.getPadroesEntrada( ); saidasTreinamento = pT.getPadroesSaida(); epocasMaximo = pEpocasMaximo; fatorAprendizagem = pFatorAprendizagem; erroAceitavel = pErroAceitavel; errosMaximos = new ArrayList<Double>(); funcao = rna.getFuncao();

124

pesosHI = rna.getPesosHI(); pesosOH = rna.getPesosOH(); fatoresCorrecaoH = new double[rna.getNosEsc ondidos() + rna.getBias()]; fatoresCorrecaoO = new double[rna.getNosSai da()]; saidasEsperadas = new int[rna.getNosSaida() ]; vetorTreinamentoLido = true; } /** * Construtor vazio<br> * Usa os seguintes defaults:<br> * - rede criada com construtor vazio * - número máximo de épocas 1000 * - fator de aprendizagem 0.25 * - Erro máximo 0.1 */ public TreinaRede() { rna = new RedeNeural(); epocasMaximo = 1000; fatorAprendizagem = 0.25; erroAceitavel = 0.1; errosMaximos = new ArrayList<Double>(); funcao = rna.getFuncao(); pesosHI = rna.getPesosHI(); pesosOH = rna.getPesosOH(); fatoresCorrecaoH = new double[rna.getNosEsc ondidos() + rna.getBias()]; fatoresCorrecaoO = new double[rna.getNosSai da()]; saidasEsperadas = new int[rna.getNosSaida() ]; vetorTreinamentoLido = false; } /** * Getter dos erros máximos das épocas * @return Maiores valores de erro obtidos em c ada época em um ArrayList **/ public ArrayList getErrosMaximos() { return errosMaximos; } /** * Getter do maior erro obtido * @return retorna o maior erro obtido como dou ble */ public double getErroMaximo() { return erroMaximo; } /** * getter da quantidade de épocas atual * @return quantidade de épocas atual como um i nteiro */ public int getQtdEpocasAtual() { return qtdEpocasAtual; }

125

/** * Setter da rede **/ public void setRna(RedeNeural rede) { rna = rede; funcao = rna.getFuncao(); pesosHI = rna.getPesosHI(); pesosOH = rna.getPesosOH(); fatoresCorrecaoH = new double[rna.getNosEsc ondidos() + rna.getBias()]; fatoresCorrecaoO = new double[rna.getNosSai da()]; saidasEsperadas = new int[rna.getNosSaida() ]; } /** * Treina a Rede Neural * @return retorna true ou false se conseguiu t reinar ou não **/ public boolean treinar() throws Exception { int i, j, k, contadorModelo; boolean estaTreinado = false; qtdEpocasAtual = 0; double valorErroAtual; errosMaximos.clear(); if(!vetorTreinamentoLido) { throw new Exception("Padrões para trein amento não foram lidos!"); } contadorModelo = 0; while (!estaTreinado && (qtdEpocasAtual < e pocasMaximo)) { valorErroAtual = 0.0; estaTreinado = true; for(contadorModelo = 0; contadorModelo < entradasTreinamento.length; contadorModelo++){ rna.setEntrada(setEntradaSaidaDoPad rao(contadorModelo)); rna.calculeNets(); valorErroAtual += calculeErroGlobal (); calculeFatoresCorrecao(); corrigePesos(); } if(valorErroAtual > erroAceitavel) { estaTreinado = false; } errosMaximos.add(valorErroAtual); qtdEpocasAtual++; } return estaTreinado; } /** * Treina a Rede Neural * @param jpb barra de progresso do treinamento * @return retorna true ou false se conseguiu t reinar ou não **/ public boolean treinar(JProgressBar jpb) throws Exception { int i, j, k, contadorModelo; boolean estaTreinado = false; errosMaximos.clear();

126

qtdEpocasAtual = 0; double valorErroAtual; if(!vetorTreinamentoLido) { throw new Exception("Padrões para trein amento não foram lidos!"); } contadorModelo = 0; jpb.setMaximum(epocasMaximo); jpb.setString(null); while (!estaTreinado && (qtdEpocasAtual < e pocasMaximo)) { valorErroAtual = 0.0; estaTreinado = true; for(contadorModelo = 0; contadorModelo < entradasTreinamento.length; contadorModelo++){ rna.setEntrada(setEntradaSaidaDoPad rao(contadorModelo)); rna.calculeNets(); valorErroAtual += calculeErroGlobal (); calculeFatoresCorrecao(); corrigePesos(); } if(valorErroAtual > erroAceitavel) { estaTreinado = false; } errosMaximos.add(valorErroAtual); qtdEpocasAtual++; jpb.setValue(qtdEpocasAtual); } return estaTreinado; } /** * Setter dos arrays de valores padrão (entrada e saída) * @param padrao índice do padrão a ser aplicad o nos vetores de entrada e saída esperada * @return retorna o vetor de entrada **/ public int[] setEntradaSaidaDoPadrao(int padrao ) { int i, k; int bias = rna.getBias(); int entradas[] = new int[rna.getNosEntrada( ) + bias]; if(bias == 1){ entradas[0] = 1; } for(i = bias; i < entradas.length; i++) { entradas[i] = entradasTreinamento[padra o][i - bias]; } for(k = 0; k < saidasEsperadas.length; k++) { saidasEsperadas[k] = saidasTreinamento[ padrao][k]; } return entradas; } /** * Calcula o erro global da época * @return retorna o valor do erro global como um double */ public double calculeErroGlobal() { double valorErro = 0.0;

127

for(int k = 0; k < rna.getNosSaida(); k++){ valorErro += Math.pow((saidasEsperadas[ k] - funcao.calcFuncao(rna.getValorSaidas(k))),2); //valorErro += Math.pow(Math.pow((saida sEsperadas[k] - funcao.calcFuncao(rna.getValorSaidas(k))),2),0.5); } return valorErro /= 2.0; } /** * Calcula os fatores de correção * @param padrao indice que identifica o padrão utilizado no treinamento */ public void calculeFatoresCorrecao(int padrao){ int j, k; for (k = 0; k < rna.getNosSaida(); k++) { fatoresCorrecaoO[k] = funcao.calcDerivada(rna.getValorSaidas(k)) * (saida sTreinamento[padrao][k] - funcao.calcFuncao(rna.getValorSaidas(k))); } for (j = 0; j < (rna.getNosEscondidos() + r na.getBias()); j++) { fatoresCorrecaoH[j] = 0.0; for (k = 0; k < rna.getNosSaida(); k++) { fatoresCorrecaoH[j] += fatoresCorrecao O[k] * pesosOH[k][j]; } fatoresCorrecaoH[j] *= funcao.calcDerivada(rna.getValorEscondidos(j)); } } /** * Calcula os fatores de correção<br> * Para seu uso, o array saidasEsperadas deve t er sido inicializado com a saida do treinamento */ public void calculeFatoresCorrecao(){ int j, k; for (k = 0; k < rna.getNosSaida(); k++) { fatoresCorrecaoO[k] = funcao.calcDerivada(rna.getValorSaidas(k)) * (saida sEsperadas[k] - funcao.calcFuncao(rna.getValorSaidas(k))); } for (j = 0; j < (rna.getNosEscondidos() + r na.getBias()); j++) { fatoresCorrecaoH[j] = 0.0; for (k = 0; k < rna.getNosSaida(); k++) { fatoresCorrecaoH[j] += fatoresCorrecao O[k] * pesosOH[k][j]; } fatoresCorrecaoH[j] *= funcao.calcDerivada(rna.getValorEscondidos(j)); } } /** * Corrige os pesos entre as conexões

128

* @throws Exception lança exceção se ocorrer e rro na redefinição dos pesos */ public void corrigePesos() throws Exception { int i, j, k; for (k = 0; k < rna.getNosSaida(); k++){ for (j = 0; j < rna.getNosEscondidos() + rna.getBias(); j++){ pesosOH[k][j] += fatorAprendizagem * fatoresCorrecaoO[k] * funcao.calcFuncao(rna.getValorEscondidos(j)); } } for (j = 0; j < rna.getNosEscondidos() + rn a.getBias(); j++){ for (i = 0; i < rna.getNosEntrada() + r na.getBias(); i++){ pesosHI[j][i] += fatorAprendizagem * fatoresCorrecaoH[j] * rna.getValorEntradas(i); } } try { rna.setPesosHI(pesosHI); rna.setPesosOH(pesosOH); } catch (Exception e) { throw e; } } /** * Setter do erro aceitavel * @param eA valor do erro aceitável do tipo do uble */ public void setErroAceitavell(double eA) { erroAceitavel = eA; } /** * Getter do erro aceitável * @return retorna o erro aceitável como double */ public double getErroAceitavel() { return erroAceitavel; } /** * Setter da quantidade máxima de épocas * @param eM quantidade máxima de épocas do tip o inteiro */ public void setEpocasMaximo(int eM) { epocasMaximo = eM; } /** * Getter da quantidade máxima de épocas * @return retorna o número máximo de épocas co mo inteiro */ public int getEpocasMaximo() { return epocasMaximo; } /**

129

* Setter do fator de aprendizagem * @param fA valor do fator de aprendizagem com o double */ public void setFatorAprendizagem(double fA) { fatorAprendizagem = fA; } /** * Getter do fator de aprendizagem * @return retorna o valor do fator de aprendiz agem como double */ public double getFatorAprendizagem() { return fatorAprendizagem; } /** * Setter dos padroes de treinamento * @param pT padroes de treinamento como Padroe sTreinamento */ public void setPadroesTreinamento(PadroesTreina mento pT) { entradasTreinamento = pT.getPadroesEntrada( ); saidasTreinamento = pT.getPadroesSaida(); vetorTreinamentoLido = true; } }

130

Classe PadroesTreinamento

/* * PadroesTreinamento.java * * Created on 19 de Junho de 2005, 16:34 */ package redeNeural; import java.io.Serializable; /** * Padrões de treinamento para serem usados no trei namento da rede * @author João Carlos Testi Ferreira e Júnior Bar bosa Dymow */ public class PadroesTreinamento implements Serializ able { private int padroesEntrada[][]; private int padroesSaida[][]; /** * Construtor vazio<br> * Inicializa com tamanho 1x1 os arrays de padr ões de entrada e saída */ public PadroesTreinamento() { padroesEntrada = new int[1][1]; padroesSaida = new int[1][1]; } /** * Construtor com parâmetros<br> * Inicia os arrays com os arrays passados por parâmetro * @param pE array com os parâmetros de entrada * @param pS array com os parâmetros de saída */ public PadroesTreinamento(int pE[][], int pS[][ ]) { padroesEntrada = pE; padroesSaida = pS; } /** * Setter dos arrays de padrões de entrada e sa ída * @param pE array com os padrões de entrada * @param pS array com os padrões de saída */ public void setPadroesTreinamento(int pE[][], i nt pS[][]) { padroesEntrada = pE; padroesSaida = pS; } /** * Getter dos padrões de entrada * @return retorna o array de padrões de entrad a */ public int[][] getPadroesEntrada() { return padroesEntrada;

131

} /** * Getter dos padrões de saída * @return retorna o array de padrões de saída */ public int[][] getPadroesSaida() { return padroesSaida; } }

132

Classe FuncaoSaida

/* * funcaoSaida.java * * Created on 17 de Junho de 2005, 23:39 */ package funcoesSaida; /** * Interface que define a função de saída * @author João Carlos Testi Ferreira e Júnior Bar bosa Dymow */ public interface FuncaoSaida { /** * Método que deve ser implementado para calcular o valor de saída da função * @param valor valor a ser aplicado na função com o double * @return retorna a saída da função como double */ public double calcFuncao(double valor); /** * Método que deve se implementado para calcula r o valor de saída da derivada da função * @param valor a ser aplicado na derivada da f unção como double * @return retorna a saída da derivada da funçã o como double */ public double calcDerivada(double valor); /** * Método a ser implementado para informar o no me da função * @return retorna o nome da função como String */ public String getNome(); }

133

Classe FuncaoSigmoidal

/* * funcaoSigmoidal.java * * Created on 17 de Junho de 2005, 23:36 */ package funcoesSaida; import java.io.Serializable; /** * Implementação da função de saída do tipo sigmoid al * @author João Carlos Testi Ferreira e Júnior Bar bosa Dymow */ public class FuncaoSigmoidal implements FuncaoSaida , Serializable { /** * construtor vazio */ public FuncaoSigmoidal() { } /** * Calcula o resultado da função sigmoidal * @param valor valor a ser aplicado na função do tipo double * @return retorna o resultado da função com ti po double */ public double calcFuncao(double valor) { return (1.0 / (1.0 + Math.exp(-valor))); } /** * Calcula o resultado da derivada da função si gmoidal * @param valor valor a ser aplicado na derivad a da função como double * @return retorna o resultado da de derivada d a função como double */ public double calcDerivada(double valor) { return ((1.0 / (1.0 + Math.exp(-valor))) * (1.0 - (1.0 / (1.0 + Math.exp(-valor))))); } /** * Informa o nome da função de saída * @return retorna o nome da função como String */ public String getNome() { return "Sigmoidal"; } }

134

Classe FuncaoTangHiperb

/* * FuncaoTangHiperb.java * * Created on 18 de Junho de 2005, 21:27 */ package funcoesSaida; import java.io.Serializable; /** * Implementação da função de saída do tipo tangent e hiperbólica * @author João Carlos Testi Ferreira e Júnior Bar bosa Dymow */ public class FuncaoTangHiperb implements FuncaoSaid a, Serializable { /** * construtor vazio */ public FuncaoTangHiperb() { } /** * Calcula o resultado da função tangente hiper bólica * @param valor valor a ser aplicado na função do tipo double * @return retorna o resultado da função com ti po double */ public double calcFuncao(double valor) { return ((Math.exp(valor) - Math.exp(-valor) )/(Math.exp(valor) + Math.exp(-valor))); } /** * Calcula o resultado da derivada da função ta ngente hiperbólica * @param valor valor a ser aplicado na derivad a da função como double * @return retorna o resultado da derivada da f unção como double */ public double calcDerivada(double valor) { return ( 1.0 - Math.pow(((Math.exp(valor) - Math.exp(-valor))/(Math.exp(valor) + Math.exp(-valor))), 2.0) ); } /** * Informa o nome da função de saída * @return retorna o nome da função como String */ public String getNome() { return "Tangente Hiperbólica"; } }

135

Classe LeitorPadroes

/* * LeitorPadroes.java * * Created on 19 de Junho de 2005, 16:07 */ package manipulacaoArquivos; import redeNeural.*; /** * Le arquivo com os padrões de treinamento * @author João Carlos Testi Ferreira e Júnior Bar bosa Dymow */ public class LeitorPadroes { private String nomeArquivo; /** * Construtor vazio */ public LeitorPadroes() { } /** * Construtor com parâmetro * @param pNomeArquivo nome do arquivo que cont ém os padrões */ public LeitorPadroes(String pNomeArquivo) { nomeArquivo = pNomeArquivo; } /** * Leitor dos padrões para treinamento * @return quantidade de registros lidos * @throws lança exceção de I/O ou erro de leit ura no formato do arquivo **/ public PadroesTreinamento lerDadosTreinamento() throws Exception { final int estadoDigito = 1; final int estadoSeparador = 2; final int estadoBranco = 3; int entradasTreinamento[][]; int saidasTreinamento[][]; int ind = 0; int nEntrada = 0, nSaida = 0, nBias = 0, re gistros = 0; int dado, contaLinha = 0, estado, estadoAnt erior; int i, j; StringBuffer buf; java.io.DataInputStream arquivoEntrada = ne w java.io.DataInputStream(new java.io.BufferedInputSt ream(new java.io.FileInputStream(nomeArquivo))); buf = new StringBuffer(); estadoAnterior = 0; estado = 0; while(((dado = arquivoEntrada.read()) != 13 ) && (dado > 0)) {

136

if(dado == 10) continue; if("0123456789".indexOf((char)dado) != -1) { estado = estadoDigito; } else { if((char)dado == ';') { estado = estadoSeparador; } else { if((char)dado == ' ') { estado = estadoBranco; } else { estado = 0; } } } switch(estado) { case estadoDigito: buf.append((char)dado); estadoAnterior = estado; break; case estadoSeparador: switch(ind) { case 0: nEntrada = Integer.pars eInt(buf.toString()); ind++; break; case 1: nSaida = Integer.parseI nt(buf.toString()); ind++; break; default: throw new Exception("Re gistro: " + (contaLinha + 1) + " Separador não esperado!"); } buf.delete(0, buf.length()); case estadoBranco: estadoAnterior = estado; break; default: throw new Exception("Registro: " + (contaLinha + 1) + " Valor lido inválido!"); } } contaLinha++; registros = Integer.parseInt(buf.toString() ); if(dado < 0){ throw new Exception("Registro: " + cont aLinha + " Final de arquivo inesperado!"); } if(ind != 2) { throw new Exception("Registro: " + cont aLinha + " Quantidade de parametros invalido!"); } buf.delete(0, buf.length()); entradasTreinamento = new int[registros][nE ntrada]; saidasTreinamento = new int[registros][nSai da]; i = 0; j = 0; while((dado = arquivoEntrada.read()) > 0) {

137

if(dado == 10) continue; if(dado == 13){ i = 0; if (++j > registros) { throw new Exception("Registro: " + (contaLinha + 1) + " Quantidade de registros invalido!"); } contaLinha++; continue; } if("01".indexOf((char)dado) == -1){ throw new Exception("Registro: " + contaLinha + " Valor lido invalido!"); } if(i < nEntrada) { entradasTreinamento[j][i] = dado == 48 ? 0 : 1; } else { if(i < (nEntrada + nSaida)){ saidasTreinamento[j][i-nEntrada ] = dado == 48 ? 0 : 1; } else { throw new Exception("Registro: " + contaLinha + " tamanho de linha lida invalida!"); } } i++; } if(j >= registros) { throw new Exception("Registro: " + (con taLinha + 1) + " Quantidade de registros invalido!"); } return new PadroesTreinamento(entradasTrein amento, saidasTreinamento); } /** * Leitor dos padrões para treinamento * @param jpb barra de progresso de leitura do arquivo * @return quantidade de registros lidos * @throws lança exceção de I/O ou erro de leit ura no formato do arquivo **/ public PadroesTreinamento lerDadosTreinamento(j avax.swing.JProgressBar jpb) throws Exception { final int estadoDigito = 1; final int estadoSeparador = 2; final int estadoBranco = 3; int entradasTreinamento[][]; int saidasTreinamento[][]; int ind = 0; int nEntrada = 0, nSaida = 0, nBias = 0, re gistros = 0; int dado, contaLinha = 0, estado, estadoAnt erior; int i, j; StringBuffer buf; java.io.DataInputStream arquivoEntrada = ne w java.io.DataInputStream(new java.io.BufferedInputSt ream(new java.io.FileInputStream(nomeArquivo))); buf = new StringBuffer(); estadoAnterior = 0;

138

estado = 0; while(((dado = arquivoEntrada.read()) != 13 ) && (dado > 0)) { if(dado == 10) continue; if("0123456789".indexOf((char)dado) != -1) { estado = estadoDigito; } else { if((char)dado == ';') { estado = estadoSeparador; } else { if((char)dado == ' ') { estado = estadoBranco; } else { estado = 0; } } } switch(estado) { case estadoDigito: buf.append((char)dado); estadoAnterior = estado; break; case estadoSeparador: switch(ind) { case 0: nEntrada = Integer.pars eInt(buf.toString()); ind++; break; case 1: nSaida = Integer.parseI nt(buf.toString()); ind++; break; default: throw new Exception("Re gistro: " + (contaLinha + 1) + " Separador não esperado!"); } buf.delete(0, buf.length()); case estadoBranco: estadoAnterior = estado; break; default: throw new Exception("Registro: " + (contaLinha + 1) + " Valor lido inválido!"); } } contaLinha++; registros = Integer.parseInt(buf.toString() ); jpb.setMaximum(registros); jpb.setIndeterminate(false); if(dado < 0){ throw new Exception("Registro: " + cont aLinha + " Final de arquivo inesperado!"); } if(ind != 2) { throw new Exception("Registro: " + cont aLinha + " Quantidade de parametros invalido!"); } buf.delete(0, buf.length()); entradasTreinamento = new int[registros][nE ntrada];

139

saidasTreinamento = new int[registros][nSai da]; i = 0; j = 0; while((dado = arquivoEntrada.read()) > 0) { if(dado == 10) continue; if(dado == 13){ i = 0; if (++j > registros) { throw new Exception("Registro: " + (contaLinha + 1) + " Quantidade de registros invalido!"); } contaLinha++; continue; } if("01".indexOf((char)dado) == -1){ throw new Exception("Registro: " + contaLinha + " Valor lido invalido!"); } if(i < nEntrada) { entradasTreinamento[j][i] = dado == 48 ? 0 : 1; } else { if(i < (nEntrada + nSaida)){ saidasTreinamento[j][i-nEntrada ] = dado == 48 ? 0 : 1; } else { throw new Exception("Registro: " + contaLinha + " tamanho de linha lida invalida!"); } } i++; jpb.setValue(j+1); } if(j >= registros) { throw new Exception("Registro: " + (con taLinha + 1) + " Quantidade de registros invalido!"); } return new PadroesTreinamento(entradasTrein amento, saidasTreinamento); } }

140

Classe GravadorArquivoPesos

/* * GravadorArquivoPesos.java * * Created on 21 de Junho de 2005, 21:10 */ package manipulacaoArquivos; import redeNeural.*; /** * Grava arquivo de pesos de uma rede neural artifi cial * @author João Carlos Testi Ferreira e Júnior Bar bosa Dymow */ public class GravadorArquivoPesos { private String nomeArquivo; /** * Construtor vazio */ public GravadorArquivoPesos() { } /** * Construtor com parâmetros * @param nArquivo nome do arquivo onde serão g ravados os pesos */ public GravadorArquivoPesos(String nArquivo) { nomeArquivo = nArquivo; } /** * Gera o arquivo de pesos * @param nomeArquivo nome do arquivo onde serã o gravados os pesos * @param rna rede neural da qual ser~ao gravad os os pesos * @return retorna true se conseguiu gravar * @throws Exception lan'ca exce'c~ao se n~ao c onseguir criar ou escrever no arquivo */ public boolean gerarArquivoPesos(String nomeArq uivo, RedeNeural rna) throws Exception { int i, j, k; java.io.BufferedWriter arquivo; try { arquivo = new java.io.BufferedWriter(ne w java.io.FileWriter(nomeArquivo)); } catch (Exception e) { throw new Exception("Não foi possível c riar o arquivo - " + e.getMessage()); } try { arquivo.write("------------------------ ------------------------------------------------------------------"); arquivo.newLine(); arquivo.write(" UNIVERSIDADE FEDERAL DE SANTA CATARINA"); arquivo.newLine();

141

arquivo.write(" CENTRO TECNOLÓGICO"); arquivo.newLine(); arquivo.write(" CURSO DE SISTEMAS DE IN FORMAÇÃO"); arquivo.newLine(); arquivo.write(" ----------------------- -----------------------------------------------------------------"); arquivo.newLine(); arquivo.write(" Arquivo gerado pelo pro grama RedeNeural, criado como parte de um trabalho de TCC, por"); arquivo.newLine(); arquivo.write(" João Carlos Testi Ferre ira - Matrícula 0123825-6"); arquivo.newLine(); arquivo.write(" ----------------------- -----------------------------------------------------------------"); arquivo.newLine(); arquivo.write(" Arquivo com pesos para uma Rede Neural Artificial do tipo Multi-Layer Perceptron"); arquivo.newLine(); arquivo.write(" Dados da rede Treinada: "); arquivo.newLine(); arquivo.write(" Quantidade de nós de en trada: " + rna.getNosEntrada()); arquivo.newLine(); arquivo.write(" Quantidade de nós escon didos: " + rna.getNosEscondidos()); arquivo.newLine(); arquivo.write(" Quantidade de nós de sa ída: " + rna.getNosSaida()); arquivo.newLine(); arquivo.write(" Detalhes da rede: "); arquivo.newLine(); arquivo.write(" 1. Utiliza bias tanto n a camada de entrada como na escondida"); arquivo.newLine(); arquivo.write(" 2. Sua função de saída é " + rna.getFuncao().getNome()); arquivo.newLine(); arquivo.write(" Informações adicionais: "); arquivo.newLine(); arquivo.write(" Nomenclatura das três c amadas: I(entrada), H(escondida) e O(saída)"); arquivo.newLine(); arquivo.write(" Os pesos estão assim ap resentados: PHI[j][i]"); arquivo.newLine(); arquivo.write(" Onde PHI é o peso entre a camada H e I, j é o índice do nó da camada H e i da camada I."); arquivo.newLine(); arquivo.write(" De forma análoga temos POH para os pesos entre a camada O e H"); arquivo.newLine(); arquivo.write("------------------------ ------------------------------------------------------------------"); arquivo.newLine(); for(j = 0; j < (rna.getNosEscondidos() + rna.getBias()); j++){ for(i = 0; i < (rna.getNosEntrada() + rna.getBias()); i++){ arquivo.write("PHI[" + j + "][" + i + "] = " + rna.getValorPesosHI(j, i));

142

arquivo.newLine(); } } for(k = 0; k < rna.getNosSaida(); k++){ for(j = 0; j < (rna.getNosEscondido s() + rna.getBias()); j++){ arquivo.write("POH[" + k + "][" + j + "] = " + rna.getValorPesosOH(k, j)); arquivo.newLine(); } } arquivo.write("------------------------ --------------( FIM )--------------------------------------------"); arquivo.close(); } catch (Exception er) { throw new Exception("Não foi possível e screver no arquivo - " + er.getMessage()); } return true; } }

143

Classe PersistenciaRede

/* * Created on 25/06/2005 * * TODO To change the template for this generated f ile go to * Window - Preferences - Java - Code Style - Code Templates */ package manipulacaoArquivos; import java.io.FileInputStream; import redeNeural.*; import funcoesSaida.*; /** * Persistência de rede neural artificial em arquiv o texto * @author João Carlos Testi Ferreira e Júnior Barb osa Dymow */ public class PersistenciaRede { private String nomeArquivo; /** * Construtor vazio */ public PersistenciaRede() { } /** * Construtor com parâmetro * @param nArquivo nome do arquivo onde será gr avada a rede */ public PersistenciaRede(String nArquivo) { nomeArquivo = nArquivo; } /** * Cria o arquivo da rede * @param nomeArquivo nome do arquivo que conte rá a rede * @param rna rede a ser gravada * @throws Exception Lança exceção se não for p ossível criar o arquivo ou escrever nele */ /*public void gerarArquivoRede(String nomeArqui vo, RedeNeural rna) throws Exception { int i, j, k; java.io.BufferedWriter arquivo; try { arquivo = new java.io.BufferedWriter(ne w java.io.FileWriter(nomeArquivo)); } catch (Exception e) { throw new Exception("Não foi possível c riar o arquivo - " + e.getMessage()); } try { arquivo.write(rna.getNosEntrada() + ";" + rna.getNosEscondidos() + ";" + rna.getNosSaida() + ";");

144

arquivo.write(rna.getBias() + ";" + rna.ge tFuncao().getNome() + ";" + (rna.getEstaTreinada() ? 1 : 0)); arquivo.write(";x"); arquivo.newLine(); for(j = 0; j < rna.getNosEscondidos() + rna.getBias(); j++) for(i = 0; i < rna.getNosEntrada() + r na.getBias(); i++) arquivo.write(rna.getValorPesosHI(j, i) + ";"); arquivo.write("x"); arquivo.newLine(); for(k = 0; k < rna.getNosSaida(); k++) for(j = 0; j < rna.getNosEscondidos() + rna.getBias(); j++) arquivo.write(rna.getValorPesosOH(k, j) + ";"); arquivo.write("x"); arquivo.newLine(); arquivo.write("-x-"); arquivo.close(); } catch (Exception er) { throw new Exception("Não foi possível e screver no arquivo - " + er.getMessage()); } }*/ public void gerarArquivoRede(String nomeArquivo , RedeNeural rna) throws Exception { java.io.FileOutputStream saida; java.io.ObjectOutputStream os; try { saida = new java.io.FileOutputStream(nomeArqu ivo); os = new java.io.ObjectOutputStream(saida); os.writeObject(rna); os.close(); saida.close(); } catch (Exception er) { throw new Exception("Não foi possível escreve r no arquivo - " + er.getMessage()); } } /** * Leitor de rede neural artificial * @param nomeArquivo nome do arquivo que conté m a rede * @return retorna a rede neural lida como Rede Neural * @throws Exception Lança exceção se não for p ossível ler o arquivo, * tiver nome de função inválida, número de cam pos inválido no registro, * não conseguir criar a rede lida. */ /*public RedeNeural lerArquivoRede(String nomeA rquivo) throws Exception { int i, j, k, controle, qtde; java.io.BufferedReader arquivo; RedeNeural rna; String registro; String[] campos; try { arquivo = new java.io.BufferedReader(ne w java.io.FileReader(nomeArquivo)); } catch (Exception e) {

145

throw new Exception("Não foi possível l er o arquivo - " + e.getMessage()); } rna = new RedeNeural(); try { registro = arquivo.readLine(); campos = registro.split(";"); controle = 0; while(!campos[controle].equals("x")) { switch (controle) { case 0: rna.setNosEntrada(Integer.parseInt(campos[controle] )); break; case 1: rna.setNosEscondidos(Integer.parseInt(campos[contro le])); break; case 2: rna.setNosSaida(Integer.parseInt(campos[controle])) ; break; case 3: rna.setBias(Integer.parseInt(campos[controle])); break; case 4: if(campos[controle].equals("Sigm oidal")) { rna.setFuncao(new FuncaoSigmoidal()); } else if(campos[controle].equals("Tangente Hiperbólica")) { rna.setFuncao(new FuncaoTangHiperb()); } else { throw new Exception(campos[controle] + ": Função inválida"); } break; case 5: rna.setEstaTreinada((Integer.parseInt(campos[contro le]) == 1 ? true : false)); break; } controle++; if(controle > 5 && (!campos[controle].equ als("x"))) { throw new Exception("Número de campos in válido no registro\nna primeira linha!"); } } if(controle != 6) { throw new Exception("Número de campos inv álido no registro\nna primeira linha!"); } registro = arquivo.readLine(); campos = registro.split(";"); qtde = campos.length; controle = 0; double phi[][] = new double[rna.getNosEsco ndidos() + rna.getBias()][rna.getNosEntrada() + rna.getBias()] ; double poh[][] = new double[rna.getNosSaida()][rna.getNosEscondidos() + rna.getBias()]; for(j = 0; j < rna.getNosEscondidos() + rn a.getBias(); j++){

146

for(i = 0; i < rna.getNosEntrada() + rna. getBias(); i++){ if(!campos[controle].equals("x")){ phi[j][i] = Double.parseDouble(campos[controle++]); } else { throw new Exception("Número de campos i nválido no registro\nna segunda linha!"); } } } if(!campos[controle].equals("x")){ throw new Exception("Número de campos inv álido no registro\nna segunda linha!"); } rna.setPesosHI(phi); registro = arquivo.readLine(); campos = registro.split(";"); qtde = campos.length; controle = 0; for(j = 0; j < rna.getNosSaida(); j++){ for(i = 0; i < rna.getNosEscondidos() + r na.getBias(); i++){ if(!campos[controle].equals("x")){ poh[j][i] = Double.parseDouble(campos[controle++]); } else { throw new Exception("Número de campos i nválido no registro\nna terceira linha!"); } } } if(!campos[controle].equals("x")){ throw new Exception("Número de campos inv álido no registro\nna terceira linha!"); } rna.setPesosOH(poh); } catch(Exception e) { throw new Exception("Não foi possível cria r a rede - " + e.getMessage()); } return rna; }*/ public RedeNeural lerArquivoRede(String nomeArq uivo) throws Exception { java.io.FileInputStream entrada; java.io.ObjectInputStream oi; redeNeural.RedeNeural rna; try { entrada = new java.io.FileInputStream(nomeArq uivo); oi = new java.io.ObjectInputStream(entrada); rna = (redeNeural.RedeNeural) oi.readObject() ; oi.close(); entrada.close(); return rna; } catch (Exception e) { e.printStackTrace(); throw new Exception("Não foi possível criar a rede - " + e.getMessage()); }

147

} }

148

Classe GeradorCodigo

/** * GeradorCodigo.java * * Created on 26 de Maio de 2005, 18:59 */ package geradoresCodigo; import redeNeural.RedeNeural; /** * Classe abstrata para geração do arquivo de códig o fonte de uma rna * @author João Carlos Testi Ferreira e Júnior Barb osa Dymow */ public abstract class GeradorCodigo { private static final int JAVASCRIPT = 0; private static final int JAVA = 1; private static final int CPP = 2; private static final int OBJ_PASCAL = 3; private static final int VBSCRIPT = 4; private static final int VB = 5; protected java.io.BufferedWriter arquivo; protected String inicioComentarioBloco, fimCome ntarioBloco; protected String inicioComentarioLinha; protected String extensaoArquivo; /** * Construtor vazio */ public GeradorCodigo() { } /** * Gera em disco um arquivo vazio com o nome pa ssado como parâmetro * @param nomeArquivo nome do arquivo a ser cri ado como String * @throws Exception Lança exceção se não for p ossível criar o arquivo */ public void gerarArquivoEmDisco(String nomeArqu ivo) throws Exception { try { arquivo = new java.io.BufferedWriter(ne w java.io.FileWriter(nomeArquivo + extensaoArquivo)); } catch (Exception e) { throw new Exception(e.getMessage()); } } /** * Escrever comentário de uma única linha * @param comentario comentário a ser escrito c omo String * @throws Exception Lança exceção se não conse guir escrever no arquivo */ public void escrvComentLinha(String comentario) throws Exception { try { arquivo.write(inicioComentarioLinha + comenta rio);

149

arquivo.newLine(); } catch (Exception e) { throw new Exception(e.getMessage()); } } /** * Inserir caracter(es) de início de comentário de bloco * @throws Exception Lança exceção se não conse guir escrever no arquivo */ public void iniComentBloco() throws Exception { try { arquivo.write(inicioComentarioBloco); } catch (Exception e) { throw new Exception(e.getMessage()); } } /** * Escrever uma linha em um bloco de comentário * @param comentario comentário a ser escrito c omo String * @throws Exception Lança exceção se não conse guir escrever no arquivo */ public void escrvLnhComentBlco(String comentari o) throws Exception{ try { arquivo.write(comentario); arquivo.newLine(); } catch (Exception e) { throw new Exception(e.getMessage()); } } /** * Inserir caracter(es) de final de comentário de bloco * @throws Exception Lança exceção se não conse guir escrever no arquivo */ public void finalizarComentarioBloco() throws E xception { try { arquivo.write(fimComentarioBloco); arquivo.newLine(); } catch (Exception e) { throw new Exception(e.getMessage()); } } /** * Método abstrato que escreve a função com os dados da * rede treinada no arquivo do tipo selecionado * */ public abstract void gerarFuncaoRNAMLP(RedeNeur al rna, double limiar) throws Exception; }

150

Classe GeradorCodigoJava

/* * GeradorCodigoJava.java * * Created on 26 de Maio de 2005, 19:00 */ package geradoresCodigo; import redeNeural.RedeNeural; /** * Gera arquivo fonte em linguagem Java * @author João Carlos Testi Ferreira e Júnior Barb osa Dymow */ public class GeradorCodigoJava extends GeradorCodig o { /** * Construtor vazio * Gera as variáveis relacionadas aos comentári os e extensão de arquivo */ public GeradorCodigoJava() { inicioComentarioBloco = "/*"; fimComentarioBloco = "*/"; inicioComentarioLinha = "//"; extensaoArquivo = ".java"; } /** * Implementação da função abstrata * @param rna Rede neural com a qual será gerad o o código fonte * @param limiar limite entre o valor 0 e 1 da saída * @throws Exception lança exceção se não conse guir escrever no arquivo */ public void gerarFuncaoRNAMLP(RedeNeural rna, d ouble limiar) throws Exception{ int i, j, k; int bias = rna.getBias(); int nosEntrada = rna.getNosEntrada(); int nosEscondidos = rna.getNosEscondidos(); int nosSaida = rna.getNosSaida(); double pesosHI[][] = rna.getPesosHI(); double pesosOH[][] = rna.getPesosOH(); try { arquivo.write("public void RNAMLP("); String virgula = ""; for(i = 1; i <= nosEntrada; i++){ arquivo.write(virgula); arquivo.write(" double valor" + i); virgula = ","; } virgula = ""; arquivo.write(" ) {"); //Criação dos arrays arquivo.newLine(); arquivo.write(" double entrada[] = {");

151

if(bias == 1){ arquivo.write("1.0, "); } for(i = 1; i <= nosEntrada; i++){ arquivo.write(virgula); arquivo.write(" valor" + i); virgula = ","; } virgula = ""; arquivo.write("};"); arquivo.newLine(); arquivo.write(" double escondidos[] = n ew double [" + (nosEscondidos + bias) + "];"); arquivo.newLine(); arquivo.write(" double saida[] = new do uble [" + (nosSaida) + "];"); arquivo.newLine(); arquivo.write(" double pesosHI[][] = {" ); arquivo.newLine(); for(j = 0; j < (nosEscondidos + bias); j++ ){ arquivo.write(" {"); virgula = ""; for(i = 0; i < (nosEntrada + bias); i++) { arquivo.write(virgula); arquivo.write("" + pesosHI[j][i]); virgula = ", "; } arquivo.write("}, "); arquivo.newLine(); } arquivo.write("};"); virgula = ""; arquivo.newLine(); arquivo.write(" double pesosOH[][] = {"); arquivo.newLine(); for(k = 0; k < (nosSaida); k++){ arquivo.write(" {"); virgula = ""; for(j = 0; j < (nosEscondidos + bias); j+ +){ arquivo.write(virgula); arquivo.write("" + pesosHI[k][j]); virgula = ", "; } arquivo.write("}, "); arquivo.newLine(); } arquivo.write("};"); virgula = ""; //calculo dos netH arquivo.newLine(); arquivo.write(" for(int j = 0; j < " + (nosEscondidos + bias) + "; j++) {"); arquivo.newLine(); arquivo.write(" escondidos[j] = 0;" );

152

arquivo.newLine(); arquivo.write(" for(i = 0; i < " + (nosEntrada + bias) + "; i++) {"); arquivo.newLine(); arquivo.write(" escondidos[j] + = pesosHI[j][i] * entrada[i];" ); arquivo.newLine(); arquivo.write(" }"); arquivo.newLine(); arquivo.write(" }"); arquivo.newLine(); if(bias == 1){ arquivo.write(" escondidos[0] = 1;" ); } arquivo.newLine(); //aplicação da funcao de saída na camada H arquivo.write(" for(j = " + bias + "; j < " + (nosEscondidos + bias) + "; j++){"); arquivo.newLine(); arquivo.write(" escondidos[j] = (1/ (1 + exp(-escondidos[j])));");//ver metodo funcao arquivo.newLine(); arquivo.write(" }"); arquivo.newLine(); //calculo dos netO arquivo.write(" for(k = 0; k < " + (nos Saida) + "; k++) {"); arquivo.newLine(); arquivo.write(" saida[k] = 0;"); arquivo.newLine(); arquivo.write(" for(j = 0; j < " + (nosEscondidos + bias) + "; j++){"); arquivo.newLine(); arquivo.write(" saida[k] += pes osOH[k][j] * escondidos[j];"); arquivo.newLine(); arquivo.write(" }"); arquivo.newLine(); arquivo.write(" }"); arquivo.newLine(); //aplicação da funcao de saída na camada O arquivo.newLine(); arquivo.write(" for(k = 0; k < " + nosS aida + "; k++){"); arquivo.newLine(); arquivo.write(" saida[k] = (1/(1 + exp(-saida[k])));");//ver metodo funcao arquivo.newLine(); arquivo.write(" }"); //aplicacao da funcao de limiar arquivo.newLine(); arquivo.write(" for(k = 0; k < " + nosS aida + "; k++){"); arquivo.newLine(); arquivo.write(" saida[k] = saida[k] < " + limiar + " ? 0 : 1;");//ver metodo funcao arquivo.newLine(); arquivo.write(" }"); arquivo.newLine();

153

arquivo.write(inicioComentarioLinha + " -- > O resultado é o vetor saida"); arquivo.newLine(); arquivo.write("}"); arquivo.close(); } catch (Exception e) { throw new Exception(e.getMessage()); } } }

154

Classe GeraCodigoOP

/* * GeradorCodigoOP.java * * Created on 26 de Maio de 2005, 19:44 */ package geradoresCodigo; import redeNeural.RedeNeural; /** * Gera arquivo fonte em linguagem Object Pascal * @author João Carlos Testi Ferreira e Júnior Barb osa Dymow */ public class GeradorCodigoOP extends GeradorCodigo { /** * Construtor vazio * Gera as variáveis relacionadas aos comentári os e extensão de arquivo */ public GeradorCodigoOP() { inicioComentarioBloco = "{"; fimComentarioBloco = "}"; inicioComentarioLinha = "//"; extensaoArquivo = ".pas"; } /** * Implementação da função abstrata * @param rna Rede neural com a qual será gerad o o código fonte * @param limiar limite entre o valor 0 e 1 da saída * @throws Exception lança exceção se não conse guir escrever no arquivo */ public void gerarFuncaoRNAMLP(RedeNeural rna, d ouble limiar) throws Exception { int i, j, k; int bias = rna.getBias(); int nosEntrada = rna.getNosEntrada(); int nosEscondidos = rna.getNosEscondidos(); int nosSaida = rna.getNosSaida(); double pesosHI[][] = rna.getPesosHI(); double pesosOH[][] = rna.getPesosOH(); try { arquivo.write("procedure RNAMLP("); String virgula = ""; for(i = 1; i <= nosEntrada; i++){ arquivo.write(virgula); arquivo.write(" var valor" + i + ": do uble"); virgula = ";"; } virgula = ""; arquivo.write(" );"); //Criação dos arrays arquivo.newLine(); arquivo.write("begin");

155

arquivo.write(" double entrada[] = {"); if(bias == 1){ arquivo.write("1.0, "); } for(i = bias; i < (nosEntrada + bias); i++ ){ arquivo.write(virgula); arquivo.write(" valor" + i); virgula = ","; } virgula = ""; arquivo.write("};"); arquivo.newLine(); arquivo.write(" double escondidos[] = n ew double [" + (nosEscondidos + bias) + "];"); arquivo.newLine(); arquivo.write(" double saida[] = new do uble [" + (nosSaida) + "];"); arquivo.newLine(); arquivo.write(" double pesosHI[][] = {" ); arquivo.newLine(); for(j = 0; j < (nosEscondidos + bias); j++ ){ arquivo.write(" {"); virgula = ""; for(i = 0; i < (nosEntrada + bias); i+ +) { arquivo.write(virgula); arquivo.write("" + pesosHI[j][i]); virgula = ", "; } arquivo.write("}, "); arquivo.newLine(); } arquivo.write("};"); virgula = ""; arquivo.newLine(); arquivo.write(" double pesosOH[][] = {" ); arquivo.newLine(); for(k = 0; k < (nosSaida); k++){ arquivo.write(" {"); virgula = ""; for(j = 0; j < (nosEscondidos + bias); j++){ arquivo.write(virgula); arquivo.write("" + pesosHI[k][j]); virgula = ", "; } arquivo.write("}, "); arquivo.newLine(); } arquivo.write("};"); virgula = ""; //calculo dos netH arquivo.newLine();

156

arquivo.write(" for(int j = 0; j < " + (nosEscondidos + bias) + "; j++) {"); arquivo.newLine(); arquivo.write(" escondidos[j] = 0;" ); arquivo.newLine(); arquivo.write(" for(i = 0; i < " + (nosEntrada + bias) + "; i++) {"); arquivo.newLine(); arquivo.write(" escondidos[j] + = pesosHI[j][i] * entrada[i];" ); arquivo.newLine(); arquivo.write(" }"); arquivo.newLine(); arquivo.write(" }"); arquivo.newLine(); if(bias == 1){ arquivo.write(" escondidos[0] = 1;" ); } arquivo.newLine(); //aplicação da funcao de saída na camada H arquivo.write(" for(j = " + bias + "; j < " + (nosEscondidos + bias) + "; j++){"); arquivo.newLine(); arquivo.write(" escondidos[j] = (1/ (1 + exp(-escondidos[j])));");//ver metodo funcao arquivo.newLine(); arquivo.write(" }"); arquivo.newLine(); //calculo dos netO arquivo.write(" for(k = 0; k < " + (nos Saida) + "; k++) {"); arquivo.newLine(); arquivo.write(" saida[k] = 0;"); arquivo.newLine(); arquivo.write(" for(j = 0; j < " + (nosEscondidos + bias) + "; j++){"); arquivo.newLine(); arquivo.write(" saida[k] += pes osOH[k][j] * escondidos[j];"); arquivo.newLine(); arquivo.write(" }"); arquivo.newLine(); arquivo.write(" }"); arquivo.newLine(); //aplicação da funcao de saída na camada O arquivo.newLine(); arquivo.write(" for(k = 0; k < " + nosS aida + "; k++){"); arquivo.newLine(); arquivo.write(" saida[k] = (1/(1 + exp(-saida[k])));");//ver metodo funcao arquivo.newLine(); arquivo.write(" }"); //aplicacao da funcao de limiar arquivo.newLine(); arquivo.write(" for(k = 0; k < " + nosS aida + "; k++){"); arquivo.newLine(); arquivo.write(" saida[k] = saida[k] < " + limiar + " ? 0 : 1;");//ver metodo funcao

157

arquivo.newLine(); arquivo.write(" }"); arquivo.newLine(); arquivo.write(inicioComentarioLinha + " -- > O resultado é o vetor saida"); arquivo.newLine(); arquivo.write("}"); arquivo.close(); } catch (Exception e) { throw new Exception(e.getMessage()); } } }

158

Classe GeraCodigoCPP

/* * GeradorCodigoCPP.java * * Created on 26 de Maio de 2005, 19:44 */ package geradoresCodigo; import redeNeural.RedeNeural; /** * Gera arquivo fonte em linguagem C++ * @author João Carlos Testi Ferreira e Júnior Barb osa Dymow */ public class GeradorCodigoCPP extends GeradorCodigo { /** * Construtor vazio * Gera as variáveis relacionadas aos comentári os e extensão de arquivo */ public GeradorCodigoCPP() { inicioComentarioBloco = "/*"; fimComentarioBloco = "*/"; inicioComentarioLinha = "//"; extensaoArquivo = ".h"; } /** * Implementação da função abstrata * @param rna Rede neural com a qual será gerad o o código fonte * @param limiar limite entre o valor 0 e 1 da saída * @throws Exception lança exceção se não conse guir escrever no arquivo */ public void gerarFuncaoRNAMLP(RedeNeural rna, d ouble limiar) throws Exception { int i, j, k; int bias = rna.getBias(); int nosEntrada = rna.getNosEntrada(); int nosEscondidos = rna.getNosEscondidos(); int nosSaida = rna.getNosSaida(); double pesosHI[][] = rna.getPesosHI(); double pesosOH[][] = rna.getPesosOH(); try { arquivo.write("void RNAMLP("); String virgula = ""; for(i = 1; i <= nosEntrada; i++){ arquivo.write(virgula); arquivo.write(" double valor" + i); virgula = ","; } virgula = ""; arquivo.write(" ) {"); //Criação dos arrays arquivo.newLine();

159

arquivo.write(" double entrada[] = {"); if(bias == 1){ arquivo.write("1.0, "); } for(i = bias; i < (nosEntrada + bias); i++ ){ arquivo.write(virgula); arquivo.write(" valor" + i); virgula = ","; } virgula = ""; arquivo.write("};"); arquivo.newLine(); arquivo.write(" double escondidos[" + ( nosEscondidos + bias) + "];"); arquivo.newLine(); arquivo.write(" double saida[" + (nosSa ida) + "];"); arquivo.newLine(); arquivo.write(" double pesosHI["+ nosEs condidos +"][" + nosEntrada + "] = {"); arquivo.newLine(); for(j = 0; j < (nosEscondidos + bias); j++ ){ arquivo.write(" {"); virgula = ""; for(i = 0; i < (nosEntrada + bias); i+ +) { arquivo.write(virgula); arquivo.write("" + pesosHI[j][i]); virgula = ", "; } arquivo.write("}, "); arquivo.newLine(); } arquivo.write("};"); virgula = ""; arquivo.newLine(); arquivo.write(" double pesosOH[" + nosS aida + "][" + nosEscondidos + "] = {"); arquivo.newLine(); for(k = 0; k < (nosSaida); k++){ arquivo.write(" {"); virgula = ""; for(j = 0; j < (nosEscondidos + bias); j++){ arquivo.write(virgula); arquivo.write("" + pesosHI[k][j]); virgula = ", "; } arquivo.write("}, "); arquivo.newLine(); } arquivo.write("};"); virgula = ""; //calculo dos netH arquivo.write(" for(int j = 0; j < " + (nosEscondidos + bias) + "; j++) {"); arquivo.newLine(); arquivo.write(" escondidos[j] = 0;" ); arquivo.newLine(); arquivo.write(" for(i = 0; i < " + (nosEntrada + bias) + "; i++) {");

160

arquivo.newLine(); arquivo.write(" escondidos[j] + = pesosHI[j][i] * entrada[i];" ); arquivo.newLine(); arquivo.write(" }"); arquivo.newLine(); arquivo.write(" }"); arquivo.newLine(); if(bias == 1){ arquivo.write(" escondidos[0] = 1;" ); } arquivo.newLine(); //aplicação da funcao de saída na camada H arquivo.write(" for(j = " + bias + "; j < " + (nosEscondidos + bias) + "; j++){"); arquivo.newLine(); arquivo.write(" escondidos[j] = (1/ (1 + exp(-escondidos[j])));");//ver metodo funcao arquivo.newLine(); arquivo.write(" }"); arquivo.newLine(); //calculo dos netO arquivo.write(" for(k = 0; k < " + (nos Saida) + "; k++) {"); arquivo.newLine(); arquivo.write(" saida[k] = 0;"); arquivo.newLine(); arquivo.write(" for(j = 0; j < " + (nosEscondidos + bias) + "; j++){"); arquivo.newLine(); arquivo.write(" saida[k] += pes osOH[k][j] * escondidos[j];"); arquivo.newLine(); arquivo.write(" }"); arquivo.newLine(); arquivo.write(" }"); arquivo.newLine(); //aplicação da funcao de saída na camada O arquivo.newLine(); arquivo.write(" for(k = 0; k < " + nosS aida + "; k++){"); arquivo.newLine(); arquivo.write(" saida[k] = (1/(1 + exp(-saida[k])));");//ver metodo funcao arquivo.newLine(); arquivo.write(" }"); //aplicacao da funcao de limiar arquivo.newLine(); arquivo.write(" for(k = 0; k < " + nosS aida + "; k++){"); arquivo.newLine(); arquivo.write(" saida[k] = saida[k] < " + limiar + " ? 0 : 1;");//ver metodo funcao arquivo.newLine(); arquivo.write(" }"); arquivo.newLine(); arquivo.write(inicioComentarioLinha + " -- > O resultado é o vetor saida"); arquivo.newLine(); arquivo.write("}");

161

arquivo.close(); } catch (Exception e) { throw new Exception(e.getMessage()); } } }

162

Classe GeraCodigoJS

/* * geradorCodigoJS.java * * Created on 26 de Maio de 2005, 19:01 */ package geradoresCodigo; import redeNeural.RedeNeural; /** * Gera arquivo fonte em linguagem JavaScript * @author João Carlos Testi Ferreira e Júnior Barb osa Dymow */ public class GeradorCodigoJS extends GeradorCodigo { /** * Construtor vazio * Gera as variáveis relacionadas aos comentári os e extensão de arquivo */ public GeradorCodigoJS() { inicioComentarioBloco = "/*"; fimComentarioBloco = "*/"; inicioComentarioLinha = "//"; extensaoArquivo = ".js"; } /** * Implementação da função abstrata * @param rna Rede neural com a qual será gerad o o código fonte * @param limiar limite entre o valor 0 e 1 da saída * @throws Exception lança exceção se não conse guir escrever no arquivo */ public void gerarFuncaoRNAMLP(RedeNeural rna, d ouble limiar) throws Exception{ int i, j, k; int bias = rna.getBias(); int nosEntrada = rna.getNosEntrada(); int nosEscondidos = rna.getNosEscondidos(); int nosSaida = rna.getNosSaida(); double pesosHI[][] = rna.getPesosHI(); double pesosOH[][] = rna.getPesosOH(); try { arquivo.write("function RNAMLP("); String virgula = ""; for(i = 1; i <= nosEntrada; i++){ arquivo.write(virgula); arquivo.write(" valor" + i); virgula = ","; } virgula = ""; arquivo.write(" ) {"); //Criação dos arrays arquivo.newLine();

163

arquivo.write(" var entrada = ["); if(bias == 1){ arquivo.write("1, "); } for(i = 1; i < nosEntrada + bias; i++){ arquivo.write(virgula); arquivo.write(" valor" + i); virgula = ","; } virgula = ""; arquivo.write("];"); arquivo.newLine(); arquivo.write(" var escondidos = new Ar ray(" + (nosEscondidos + bias) + ");"); arquivo.newLine(); arquivo.write(" var saida = new Array(" + (nosSaida) + ");"); arquivo.newLine(); arquivo.write(" var pesosHI = ["); arquivo.newLine(); for(j = 0; j < (nosEscondidos + bias); j++ ){ arquivo.write("["); virgula = ""; for(i = 0; i < (nosEntrada + bias); i+ +) { arquivo.write(virgula); arquivo.write("" + pesosHI[j][i]); virgula = ", "; } arquivo.write("], "); arquivo.newLine(); } arquivo.write("]"); virgula = ""; arquivo.newLine(); arquivo.write(" var pesosOH = ["); for(k = 0; k < nosSaida; k++){ arquivo.write("["); virgula = ""; for(j = 0; j < (nosEscondidos + bias); j++) { arquivo.write(virgula); arquivo.write("" + pesosOH[k][j]); virgula = ", "; } arquivo.write("], "); arquivo.newLine(); } arquivo.write("] "); arquivo.newLine(); //calculo dos netH arquivo.write(" for(j = 0; j < " + (nos Escondidos + bias) + "; j++) {"); arquivo.newLine(); arquivo.write(" escondidos[j] = 0;" ); arquivo.newLine(); arquivo.write(" for(i = 0; i < " + (nosEntrada + bias) + "; i++) {");

164

arquivo.newLine(); arquivo.write(" escondidos[j] + = pesosHI[j][i] * entrada[i];" ); arquivo.newLine(); arquivo.write(" }"); arquivo.newLine(); arquivo.write(" }"); arquivo.newLine(); if(bias == 1){ arquivo.write(" escondidos[0] = 1;" ); } arquivo.newLine(); //aplicação da funcao de saída na camada H arquivo.write(" for(j = " + bias + "; j < " + (nosEscondidos + bias) + "; j++){"); arquivo.newLine(); arquivo.write(" escondidos[j] = (1/ (1 + Math.exp(-escondidos[j])));");//ver metodo funcao arquivo.newLine(); arquivo.write(" }"); arquivo.newLine(); //calculo dos netO arquivo.write(" for(k = 0; k < " + (nos Saida) + "; k++) {"); arquivo.newLine(); arquivo.write(" saida[k] = 0;"); arquivo.newLine(); arquivo.write(" for(j = 0; j < " + (nosEscondidos + bias) + "; j++){"); arquivo.newLine(); arquivo.write(" saida[k] += pes osOH[k][j] * escondidos[j];"); arquivo.newLine(); arquivo.write(" }"); arquivo.newLine(); arquivo.write(" }"); arquivo.newLine(); //aplicação da funcao de saída na camada O arquivo.newLine(); arquivo.write(" for(k = 0; k < " + nosS aida + "; k++){"); arquivo.newLine(); arquivo.write(" saida[k] = (1/(1 + Math.exp(-saida[k])));");//ver metodo funcao arquivo.newLine(); arquivo.write(" }"); //aplicacao da funcao de limiar arquivo.newLine(); arquivo.write(" for(k = 0; k < " + nosS aida + "; k++){"); arquivo.newLine(); arquivo.write(" saida[k] = saida[k] < " + limiar + " ? 0 : 1;");//ver metodo funcao arquivo.newLine(); arquivo.write(" }"); arquivo.newLine(); arquivo.write(inicioComentarioLinha + " -- > O resultado é o vetor saida"); arquivo.newLine(); arquivo.write("}");

165

arquivo.close(); } catch (Exception e) { throw new Exception(e.getMessage()); } } }

166

Classe Principal (Interface gráfica da aplicação)

public Principal() { try { javax.swing.UIManager.setLookAndFeel(javax.swing.UI Manager.getSystemLookAndFeelClassName()); } catch (Exception e) {} initComponents(); redeSalva = true; java.awt.Dimension screenSize = java.awt.Toolkit.getDefaultToolkit().getScreenSize( ); setBounds((screenSize.width-600)/2, (screen Size.height-400)/2, 600, 400); rna = new redeNeural.RedeNeural(); //this.setSize(600,400); treinador = new redeNeural.TreinaRede(); lm = (java.awt.CardLayout)painelPrincipal.g etLayout(); lm.show(painelPrincipal, "cardInicio"); Treinar.setEnabled(false); treinamento.setEnabled(false); this.desabilitaSalvarCodigo(); jLStatus.setText("Selecione um dos itens de menu"); } /** This method is called from within the const ructor to * initialize the form. * WARNING: Do NOT modify this code. The conten t of this method is * always regenerated by the Form Editor. */ // <editor-fold defaultstate="collapsed" desc=" Generated Code ">//GEN-BEGIN:initComponents private void initComponents() { jPanelMenu = new javax.swing.JPanel(); barraFerramentas = new javax.swing.JToolBar (); jButtonNovo = new javax.swing.JButton(); jButtonAbrir = new javax.swing.JButton(); jButtonSalvar = new javax.swing.JButton(); jButtonConfiguracao = new javax.swing.JButt on(); jButtonTreinar = new javax.swing.JButton(); barraStatus = new javax.swing.JPanel(); jLStatus = new javax.swing.JLabel(); painelPrincipal = new javax.swing.JPanel(); jPanelRede = new javax.swing.JPanel(); jLabel1 = new javax.swing.JLabel(); jPanelRedeInterno = new javax.swing.JPanel( ); jLabel2 = new javax.swing.JLabel(); jTFNosEntrada = new javax.swing.JTextField( ); jLabel3 = new javax.swing.JLabel(); jTFNosSaida = new javax.swing.JTextField(); jLabel4 = new javax.swing.JLabel(); jTFNosEscondidos = new javax.swing.JTextFie ld(); jComboBox1 = new javax.swing.JComboBox(); jLabel5 = new javax.swing.JLabel(); jButton1 = new javax.swing.JButton(); jButton2 = new javax.swing.JButton();

167

jButton3 = new javax.swing.JButton(); jButton4 = new javax.swing.JButton(); jButtonConfigurar = new javax.swing.JButton (); jButtonCancelar = new javax.swing.JButton() ; jLabel6 = new javax.swing.JLabel(); jRadioButton1 = new javax.swing.JRadioButto n(); jRadioButton2 = new javax.swing.JRadioButto n(); jButton5 = new javax.swing.JButton(); jPanelTreina = new javax.swing.JPanel(); jLabel7 = new javax.swing.JLabel(); jLabel8 = new javax.swing.JLabel(); jTFErro = new javax.swing.JTextField(); jButton6 = new javax.swing.JButton(); jLabel9 = new javax.swing.JLabel(); jLabel10 = new javax.swing.JLabel(); jTFEpocas = new javax.swing.JTextField(); jTFFator = new javax.swing.JTextField(); jButton7 = new javax.swing.JButton(); jButton8 = new javax.swing.JButton(); jBConfiguraT = new javax.swing.JButton(); jBCancelaT = new javax.swing.JButton(); jPanelVazio = new javax.swing.JPanel(); jPanelRTreina = new javax.swing.JPanel(); jPanelRTreinaSuperior = new javax.swing.JPa nel(); jLabel12 = new javax.swing.JLabel(); jLabel13 = new javax.swing.JLabel(); jLabel14 = new javax.swing.JLabel(); jLabel15 = new javax.swing.JLabel(); jLSituacao = new javax.swing.JLabel(); jLErroMax = new javax.swing.JLabel(); jLabel17 = new javax.swing.JLabel(); jLQtdEpocas = new javax.swing.JLabel(); jPanelRTreinaInferior = new javax.swing.JPa nel(); barraMenu = new javax.swing.JMenuBar(); menuArquivo = new javax.swing.JMenu(); abrir = new javax.swing.JMenu(); abrirRede = new javax.swing.JMenuItem(); abrirPadroes = new javax.swing.JMenuItem(); Salvar = new javax.swing.JMenu(); salvarRede = new javax.swing.JMenuItem(); salvarPesos = new javax.swing.JMenuItem(); salvarCodigo = new javax.swing.JMenu(); codigoJava = new javax.swing.JMenuItem(); codigoC = new javax.swing.JMenuItem(); codigoOP = new javax.swing.JMenuItem(); codigoJS = new javax.swing.JMenuItem(); jSeparator1 = new javax.swing.JSeparator(); Sair = new javax.swing.JMenuItem(); menuRede = new javax.swing.JMenu(); Treinar = new javax.swing.JMenuItem(); menuConfiguraRede = new javax.swing.JMenu() ; rede = new javax.swing.JMenuItem(); treinamento = new javax.swing.JMenuItem(); menuAjuda = new javax.swing.JMenu(); como = new javax.swing.JMenuItem(); sobre = new javax.swing.JMenuItem();

168

setDefaultCloseOperation(javax.swing.WindowConstant s.DO_NOTHING_ON_CLOSE); setTitle("Gerador de Redes Neurais"); setLocationByPlatform(true); addWindowListener(new java.awt.event.Window Adapter() { public void windowClosing(java.awt.even t.WindowEvent evt) { saindo(evt); } }); jPanelMenu.setLayout(new java.awt.FlowLayout(java.awt.FlowLayout.LEFT)); jPanelMenu.setBorder(new javax.swing.border.BevelBorder(javax.swing.border.B evelBorder.RAISED)); jPanelMenu.setMinimumSize(new java.awt.Dime nsion(148, 38)); jPanelMenu.setPreferredSize(new java.awt.Di mension(148, 38)); jButtonNovo.setIcon(new javax.swing.ImageIcon("C:\\rnaInter\\novo.gif")); jButtonNovo.setToolTipText("Rede nova"); jButtonNovo.addActionListener(new java.awt. event.ActionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) { jButtonNovoActionPerformed(evt); } }); barraFerramentas.add(jButtonNovo); jButtonAbrir.setIcon(new javax.swing.ImageIcon("C:\\rnaInter\\abrir.gif")); jButtonAbrir.setToolTipText("Abrir rede"); jButtonAbrir.addActionListener(new java.awt .event.ActionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) { jButtonAbrirActionPerformed(evt); } }); barraFerramentas.add(jButtonAbrir); jButtonSalvar.setIcon(new javax.swing.ImageIcon("C:\\rnaInter\\gravar.jpg")); jButtonSalvar.setToolTipText("Salvar rede") ; jButtonSalvar.addActionListener(new java.aw t.event.ActionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) { jButtonSalvarActionPerformed(evt); } }); barraFerramentas.add(jButtonSalvar); jButtonConfiguracao.setIcon(new javax.swing.ImageIcon("C:\\rnaInter\\ferramenta.gif ")); jButtonConfiguracao.setToolTipText("Configu rar Treinamento"); jButtonConfiguracao.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) {

169

jButtonConfiguracaoActionPerformed( evt); } }); barraFerramentas.add(jButtonConfiguracao); jButtonTreinar.setIcon(new javax.swing.ImageIcon("C:\\rnaInter\\treinar.gif")) ; jButtonTreinar.setToolTipText("Treinar"); jButtonTreinar.setMaximumSize(new java.awt. Dimension(23, 23)); jButtonTreinar.setMinimumSize(new java.awt. Dimension(23, 23)); jButtonTreinar.setPreferredSize(new java.aw t.Dimension(23, 23)); jButtonTreinar.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) { jButtonTreinarActionPerformed(evt); } }); barraFerramentas.add(jButtonTreinar); jPanelMenu.add(barraFerramentas); getContentPane().add(jPanelMenu, java.awt.B orderLayout.NORTH); barraStatus.setLayout(new java.awt.FlowLayout(java.awt.FlowLayout.LEFT)); barraStatus.setBackground(new java.awt.Colo r(235, 235, 242)); jLStatus.setHorizontalAlignment(javax.swing .SwingConstants.LEFT); barraStatus.add(jLStatus); getContentPane().add(barraStatus, java.awt. BorderLayout.SOUTH); painelPrincipal.setLayout(new java.awt.Card Layout()); painelPrincipal.setMinimumSize(new java.awt .Dimension(200, 200)); painelPrincipal.setName("painelRede"); jPanelRede.setLayout(new java.awt.BorderLay out()); jPanelRede.setName("confRede"); jLabel1.setFont(new java.awt.Font("Arial", 1, 12)); jLabel1.setHorizontalAlignment(javax.swing. SwingConstants.CENTER); jLabel1.setText("Configura\u00e7\u00f5es da Rede"); jPanelRede.add(jLabel1, java.awt.BorderLayo ut.NORTH); jPanelRedeInterno.setLayout(null); jLabel2.setText("Quantidade N\u00f3s de Ent rada"); jPanelRedeInterno.add(jLabel2); jLabel2.setBounds(10, 20, 200, 14); jTFNosEntrada.addFocusListener(new java.awt .event.FocusAdapter() { public void focusGained(java.awt.event. FocusEvent evt) { jTFNosEntradaFocusGained(evt); } public void focusLost(java.awt.event.Fo cusEvent evt) { jTFNosEntradaFocusLost(evt);

170

} }); jPanelRedeInterno.add(jTFNosEntrada); jTFNosEntrada.setBounds(220, 20, 40, 19); jLabel3.setText("Quantidade de N\u00f3s de Sa\u00edda"); jPanelRedeInterno.add(jLabel3); jLabel3.setBounds(10, 50, 200, 14); jTFNosSaida.addFocusListener(new java.awt.e vent.FocusAdapter() { public void focusGained(java.awt.event. FocusEvent evt) { jTFNosSaidaFocusGained(evt); } public void focusLost(java.awt.event.Fo cusEvent evt) { jTFNosSaidaFocusLost(evt); } }); jPanelRedeInterno.add(jTFNosSaida); jTFNosSaida.setBounds(220, 50, 40, 19); jLabel4.setText("Quantidade de N\u00f3s Esc ondidos"); jPanelRedeInterno.add(jLabel4); jLabel4.setBounds(10, 80, 200, 14); jTFNosEscondidos.addFocusListener(new java. awt.event.FocusAdapter() { public void focusGained(java.awt.event. FocusEvent evt) { jTFNosEscondidosFocusGained(evt); } public void focusLost(java.awt.event.Fo cusEvent evt) { jTFNosEscondidosFocusLost(evt); } }); jPanelRedeInterno.add(jTFNosEscondidos); jTFNosEscondidos.setBounds(220, 80, 40, 19) ; jComboBox1.setModel(new javax.swing.Default ComboBoxModel(new String[] { "Sigmoidal", "Tg hiperbólica" })); jComboBox1.addFocusListener(new java.awt.ev ent.FocusAdapter() { public void focusGained(java.awt.event. FocusEvent evt) { jComboBox1FocusGained(evt); } }); jPanelRedeInterno.add(jComboBox1); jComboBox1.setBounds(200, 140, 130, 22); jLabel5.setText("Fun\u00e7\u00e3o de Ativa\ u00e7\u00e3o"); jPanelRedeInterno.add(jLabel5); jLabel5.setBounds(10, 140, 160, 14); jButton1.setIcon(new javax.swing.ImageIcon( "duvida.gif")); jButton1.setMaximumSize(new java.awt.Dimens ion(9, 9)); jButton1.addActionListener(new java.awt.eve nt.ActionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) {

171

jButton1ActionPerformed(evt); } }); jButton1.addFocusListener(new java.awt.even t.FocusAdapter() { public void focusGained(java.awt.event. FocusEvent evt) { jButton1FocusGained(evt); } }); jPanelRedeInterno.add(jButton1); jButton1.setBounds(270, 20, 20, 20); jButton2.setIcon(new javax.swing.ImageIcon( "duvida.gif")); jButton2.addActionListener(new java.awt.eve nt.ActionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) { jButton2ActionPerformed(evt); } }); jButton2.addFocusListener(new java.awt.even t.FocusAdapter() { public void focusGained(java.awt.event. FocusEvent evt) { jButton2FocusGained(evt); } }); jPanelRedeInterno.add(jButton2); jButton2.setBounds(270, 50, 20, 20); jButton3.setIcon(new javax.swing.ImageIcon( "duvida.gif")); jButton3.addActionListener(new java.awt.eve nt.ActionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) { jButton3ActionPerformed(evt); } }); jButton3.addFocusListener(new java.awt.even t.FocusAdapter() { public void focusGained(java.awt.event. FocusEvent evt) { jButton3FocusGained(evt); } }); jPanelRedeInterno.add(jButton3); jButton3.setBounds(270, 80, 20, 20); jButton4.setIcon(new javax.swing.ImageIcon( "duvida.gif")); jButton4.addFocusListener(new java.awt.even t.FocusAdapter() { public void focusGained(java.awt.event. FocusEvent evt) { jButton4FocusGained(evt); } }); jPanelRedeInterno.add(jButton4); jButton4.setBounds(340, 140, 20, 20); jButtonConfigurar.setText("Configurar"); jButtonConfigurar.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) { jButtonConfigurarActionPerformed(ev t); }

172

}); jButtonConfigurar.addFocusListener(new java.awt.event.FocusAdapter() { public void focusGained(java.awt.event. FocusEvent evt) { jButtonConfigurarFocusGained(evt); } }); jPanelRedeInterno.add(jButtonConfigurar); jButtonConfigurar.setBounds(50, 190, 110, 2 3); jButtonCancelar.setText("Cancelar"); jButtonCancelar.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) { jButtonCancelarActionPerformed(evt) ; } }); jButtonCancelar.addFocusListener(new java.a wt.event.FocusAdapter() { public void focusGained(java.awt.event. FocusEvent evt) { jButtonCancelarFocusGained(evt); } }); jPanelRedeInterno.add(jButtonCancelar); jButtonCancelar.setBounds(260, 190, 110, 23 ); jLabel6.setText("Usar\u00e1 Bias?"); jPanelRedeInterno.add(jLabel6); jLabel6.setBounds(10, 110, 190, 14); jRadioButton1.setSelected(true); jRadioButton1.setText("Sim"); jRadioButton1.addFocusListener(new java.awt .event.FocusAdapter() { public void focusGained(java.awt.event. FocusEvent evt) { jRadioButton1FocusGained(evt); } }); jPanelRedeInterno.add(jRadioButton1); jRadioButton1.setBounds(150, 110, 60, 23); jRadioButton2.setText("N\u00e3o"); jRadioButton2.addFocusListener(new java.awt .event.FocusAdapter() { public void focusGained(java.awt.event. FocusEvent evt) { jRadioButton2FocusGained(evt); } }); jPanelRedeInterno.add(jRadioButton2); jRadioButton2.setBounds(210, 110, 60, 23); jButton5.setIcon(new javax.swing.ImageIcon( "duvida.gif")); jButton5.addActionListener(new java.awt.eve nt.ActionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) { jButton5ActionPerformed(evt); }

173

}); jButton5.addFocusListener(new java.awt.even t.FocusAdapter() { public void focusGained(java.awt.event. FocusEvent evt) { jButton5FocusGained(evt); } }); jPanelRedeInterno.add(jButton5); jButton5.setBounds(270, 110, 20, 20); jPanelRede.add(jPanelRedeInterno, java.awt. BorderLayout.CENTER); painelPrincipal.add(jPanelRede, "cardRede") ; jPanelTreina.setLayout(null); jLabel7.setFont(new java.awt.Font("Arial", 1, 12)); jLabel7.setHorizontalAlignment(javax.swing. SwingConstants.CENTER); jLabel7.setText("Configura\u00e7\u00e3o do Treinamento"); jPanelTreina.add(jLabel7); jLabel7.setBounds(126, 5, 170, 15); jLabel8.setText("Erro M\u00e1ximo"); jPanelTreina.add(jLabel8); jLabel8.setBounds(24, 60, 160, 14); jTFErro.addFocusListener(new java.awt.event .FocusAdapter() { public void focusGained(java.awt.event. FocusEvent evt) { jTFErroFocusGained(evt); } public void focusLost(java.awt.event.Fo cusEvent evt) { jTFErroFocusLost(evt); } }); jPanelTreina.add(jTFErro); jTFErro.setBounds(200, 60, 50, 19); jButton6.setIcon(new javax.swing.ImageIcon( "duvida.gif")); jButton6.addActionListener(new java.awt.eve nt.ActionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) { jButton6ActionPerformed(evt); } }); jPanelTreina.add(jButton6); jButton6.setBounds(260, 60, 20, 20); jLabel9.setText("N\u00famero de \u00e9pocas M\u00e1ximo"); jPanelTreina.add(jLabel9); jLabel9.setBounds(20, 100, 160, 14); jLabel10.setText("Fator de Aprendizagem"); jPanelTreina.add(jLabel10); jLabel10.setBounds(20, 140, 160, 14); jTFEpocas.addFocusListener(new java.awt.eve nt.FocusAdapter() { public void focusGained(java.awt.event. FocusEvent evt) {

174

jTFEpocasFocusGained(evt); } public void focusLost(java.awt.event.Fo cusEvent evt) { jTFEpocasFocusLost(evt); } }); jPanelTreina.add(jTFEpocas); jTFEpocas.setBounds(200, 100, 50, 19); jTFFator.addFocusListener(new java.awt.even t.FocusAdapter() { public void focusGained(java.awt.event. FocusEvent evt) { jTFFatorFocusGained(evt); } public void focusLost(java.awt.event.Fo cusEvent evt) { jTFFatorFocusLost(evt); } }); jPanelTreina.add(jTFFator); jTFFator.setBounds(200, 140, 50, 19); jButton7.setIcon(new javax.swing.ImageIcon( "duvida.gif")); jButton7.addActionListener(new java.awt.eve nt.ActionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) { jButton7ActionPerformed(evt); } }); jPanelTreina.add(jButton7); jButton7.setBounds(260, 100, 20, 20); jButton8.setIcon(new javax.swing.ImageIcon( "duvida.gif")); jButton8.addActionListener(new java.awt.eve nt.ActionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) { jButton8ActionPerformed(evt); } }); jPanelTreina.add(jButton8); jButton8.setBounds(260, 140, 20, 20); jBConfiguraT.setText("Configurar"); jBConfiguraT.addActionListener(new java.awt .event.ActionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) { jBConfiguraTActionPerformed(evt); } }); jBConfiguraT.addFocusListener(new java.awt. event.FocusAdapter() { public void focusGained(java.awt.event. FocusEvent evt) { jBConfiguraTFocusGained(evt); } }); jPanelTreina.add(jBConfiguraT); jBConfiguraT.setBounds(91, 200, 100, 23);

175

jBCancelaT.setText("Cancelar"); jBCancelaT.addActionListener(new java.awt.e vent.ActionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) { jBCancelaTActionPerformed(evt); } }); jBCancelaT.addFocusListener(new java.awt.ev ent.FocusAdapter() { public void focusGained(java.awt.event. FocusEvent evt) { jBCancelaTFocusGained(evt); } }); jPanelTreina.add(jBCancelaT); jBCancelaT.setBounds(225, 200, 100, 23); painelPrincipal.add(jPanelTreina, "cardTrei na"); painelPrincipal.add(jPanelVazio, "cardInici o"); jPanelRTreina.setLayout(new java.awt.FlowLayout(java.awt.FlowLayout.CENTER, 0, 2)); jPanelRTreinaSuperior.setLayout(null); jLabel12.setFont(new java.awt.Font("Arial", 1, 12)); jLabel12.setHorizontalAlignment(javax.swing .SwingConstants.CENTER); jLabel12.setText("Resultado do Treinamento" ); jPanelRTreinaSuperior.add(jLabel12); jLabel12.setBounds(129, 5, 180, 15); jLabel13.setText("Quantidade de \u00c9pocas :"); jPanelRTreinaSuperior.add(jLabel13); jLabel13.setBounds(20, 40, 140, 14); jLabel14.setText("Erro M\u00e1ximo: "); jPanelRTreinaSuperior.add(jLabel14); jLabel14.setBounds(20, 70, 150, 14); jLabel15.setText("Situa\u00e7\u00e3o:"); jPanelRTreinaSuperior.add(jLabel15); jLabel15.setBounds(20, 100, 130, 14); jLSituacao.setMaximumSize(new java.awt.Dime nsion(160, 14)); jLSituacao.setMinimumSize(new java.awt.Dime nsion(80, 14)); jLSituacao.setPreferredSize(new java.awt.Di mension(80, 14)); jPanelRTreinaSuperior.add(jLSituacao); jLSituacao.setBounds(160, 100, 80, 14); jLErroMax.setMaximumSize(new java.awt.Dimen sion(300, 14)); jLErroMax.setMinimumSize(new java.awt.Dimen sion(180, 14)); jLErroMax.setPreferredSize(new java.awt.Dim ension(180, 14)); jPanelRTreinaSuperior.add(jLErroMax); jLErroMax.setBounds(170, 70, 180, 14); jLabel17.setMaximumSize(new java.awt.Dimens ion(160, 14)); jLabel17.setMinimumSize(new java.awt.Dimens ion(80, 14)); jLabel17.setPreferredSize(new java.awt.Dime nsion(80, 14)); jPanelRTreinaSuperior.add(jLabel17);

176

jLabel17.setBounds(180, 100, 80, 14); jLQtdEpocas.setMaximumSize(new java.awt.Dim ension(200, 14)); jLQtdEpocas.setMinimumSize(new java.awt.Dim ension(80, 14)); jLQtdEpocas.setPreferredSize(new java.awt.D imension(80, 14)); jPanelRTreinaSuperior.add(jLQtdEpocas); jLQtdEpocas.setBounds(170, 40, 40, 14); jPanelRTreina.add(jPanelRTreinaSuperior); jPanelRTreina.add(jPanelRTreinaInferior); painelPrincipal.add(jPanelRTreina, "cardRTr eina"); getContentPane().add(painelPrincipal, java.awt.BorderLayout.CENTER); menuArquivo.setMnemonic('A'); menuArquivo.setText("Arquivo"); menuArquivo.setToolTipText("Inicie por aqui "); menuArquivo.addFocusListener(new java.awt.e vent.FocusAdapter() { public void focusGained(java.awt.event. FocusEvent evt) { menuArquivoFocusGained(evt); } }); abrir.setText("Abrir"); abrirRede.setMnemonic('R'); abrirRede.setText("Configura\u00e7\u00e3o d e rede"); abrirRede.addActionListener(new java.awt.ev ent.ActionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) { abrirRedeActionPerformed(evt); } }); abrir.add(abrirRede); abrirPadroes.setMnemonic('A'); abrirPadroes.setText("Arquivo de padr\u00f5 es"); abrirPadroes.addActionListener(new java.awt .event.ActionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) { abrirPadroesActionPerformed(evt); } }); abrir.add(abrirPadroes); menuArquivo.add(abrir); Salvar.setText("Salvar"); salvarRede.setMnemonic('G'); salvarRede.setText("Configura\u00e7\u00e3o de rede"); salvarRede.addActionListener(new java.awt.e vent.ActionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) { salvarRedeActionPerformed(evt); } });

177

Salvar.add(salvarRede); salvarPesos.setText("Arquivo de Pesos"); salvarPesos.addActionListener(new java.awt. event.ActionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) { salvarPesosActionPerformed(evt); } }); Salvar.add(salvarPesos); salvarCodigo.setText("C\u00f3digo Fonte"); salvarCodigo.setActionCommand("C\u00f3digo Fonte da rede Treinada"); codigoJava.setText("Fonte em JAVA"); codigoJava.addActionListener(new java.awt.e vent.ActionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) { codigoJavaActionPerformed(evt); } }); salvarCodigo.add(codigoJava); codigoC.setText("Fonte em C++"); codigoC.addActionListener(new java.awt.even t.ActionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) { codigoCActionPerformed(evt); } }); salvarCodigo.add(codigoC); codigoOP.setText("Fonte em Object Pascal"); codigoOP.addActionListener(new java.awt.eve nt.ActionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) { codigoOPActionPerformed(evt); } }); salvarCodigo.add(codigoOP); codigoJS.setText("Fonte em JavaScript"); codigoJS.addActionListener(new java.awt.eve nt.ActionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) { codigoJSActionPerformed(evt); } }); salvarCodigo.add(codigoJS); Salvar.add(salvarCodigo); menuArquivo.add(Salvar); menuArquivo.add(jSeparator1); Sair.setMnemonic('r');

178

Sair.setText("Sair"); Sair.addActionListener(new java.awt.event.A ctionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) { SairActionPerformed(evt); } }); menuArquivo.add(Sair); barraMenu.add(menuArquivo); menuArquivo.getAccessibleContext().setAcces sibleParent(barraMenu); menuRede.setText("Rede"); Treinar.setMnemonic('T'); Treinar.setText("Treinar"); Treinar.addActionListener(new java.awt.even t.ActionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) { TreinarActionPerformed(evt); } }); menuRede.add(Treinar); menuConfiguraRede.setText("Configurar"); rede.setText("Rede"); rede.setToolTipText(""); rede.addActionListener(new java.awt.event.A ctionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) { redeActionPerformed(evt); } }); menuConfiguraRede.add(rede); treinamento.setText("Aspectos de treinament o"); treinamento.addActionListener(new java.awt. event.ActionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) { treinamentoActionPerformed(evt); } }); menuConfiguraRede.add(treinamento); menuRede.add(menuConfiguraRede); barraMenu.add(menuRede); menuAjuda.setMnemonic('j'); menuAjuda.setText("Ajuda"); menuAjuda.addFocusListener(new java.awt.eve nt.FocusAdapter() { public void focusGained(java.awt.event. FocusEvent evt) { menuAjudaFocusGained(evt); } }); como.setText("Como usar"); menuAjuda.add(como);

179

sobre.setText("Sobre"); menuAjuda.add(sobre); barraMenu.add(menuAjuda); menuAjuda.getAccessibleContext().setAccessi bleParent(jPanelMenu); setJMenuBar(barraMenu); barraMenu.getAccessibleContext().setAccessi bleParent(jPanelMenu); } // </editor-fold>//GEN-END:initComponents private void salvarPesosActionPerformed(java.aw t.event.ActionEvent evt) {//GEN-FIRST:event_salvarPesosActionPerformed if (!rna.getEstaTreinada()) { javax.swing.JOptionPane.showMessageDial og(this, "Não há uma rede treinada para gerar código!", "Aviso!", javax.swing.JOptionPane.WARNING_MESSAGE); return; } manipulacaoArquivos.GravadorArquivoPesos gr avaPesos; boolean invalido = true; gravaPesos = new manipulacaoArquivos.Gravad orArquivoPesos(); String nomeArq; javax.swing.JFileChooser jfc = new javax.sw ing.JFileChooser(); jfc.setApproveButtonMnemonic('S'); jfc.setApproveButtonText("Salvar"); jfc.setDialogTitle("Arquivo de Pesos da Red e"); while(invalido) { if(jfc.showSaveDialog(this) == jfc.APPR OVE_OPTION){ java.io.File file = jfc.getSelected File(); nomeArq = file.getName(); if(nomeArq.indexOf('.') > 0) { if(!nomeArq.substring(nomeArq.indexOf('.')).equals( ".js")) { javax.swing.JOptionPane.sho wMessageDialog(this, "Nome de arquivo inválido.\nO nome não deve conter '.'", "Aviso de Erro!", javax.swing.JOptionPane.ERROR_MESSAGE); } else { invalido = false; } } else { invalido = false; } if(!invalido) { if(nomeArq.indexOf('.') <= 0) { try { nomeArq = file.getAbsol utePath().concat(".js"); file = new java.io.File (nomeArq); } catch (Exception e) { javax.swing.JOptionPane.showMessageDialog(this,e.ge tMessage()); } } else { nomeArq = file.getAbsoluteP ath(); file = new java.io.File(nom eArq); } int resposta = javax.swing.JOpt ionPane.YES_OPTION;

180

try { if(file.exists()) { resposta = javax.swing.JOptionPane.showConfirmDialog(this, "Ar quivo já existe, sobrescrever?", "Atenção", javax.swing.JOptionPane. YES_NO_OPTION, javax.swing.JOptionPane.WARNING_MESSAGE); } if(javax.swing.JOptionPane. YES_OPTION != resposta) { javax.swing.JOptionPane .showMessageDialog(this, "O arquivo não foi gravado!"); } else { nomeArq = nomeArq.subst ring(0, nomeArq.length()-3); gravaPesos.gerarArquivo Pesos(nomeArq, rna); javax.swing.JOptionPane .showMessageDialog(this, "Arquivo gerado com sucesso!"); } } catch (Exception e) { javax.swing.JOptionPane.sho wMessageDialog(this, "Não foi possível gravar o arquivo!\nErro: " + e.ge tMessage()); return; } } } else { invalido = false; } } }//GEN-LAST:event_salvarPesosActionPerformed private void jButtonTreinarActionPerformed(java .awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonTreinarActionPerform ed TreinarActionPerformed(null); }//GEN-LAST:event_jButtonTreinarActionPerformed private void jButtonConfiguracaoActionPerformed(java.awt.event.A ctionEvent evt) {//GEN-FIRST:event_jButtonConfiguracaoActionPerformed treinamentoActionPerformed(null); }//GEN-LAST:event_jButtonConfiguracaoActionPerf ormed private void jButtonSalvarActionPerformed(java. awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonSalvarActionPerforme d salvarRedeActionPerformed(null); }//GEN-LAST:event_jButtonSalvarActionPerformed private void jButtonAbrirActionPerformed(java.a wt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonAbrirActionPerformed abrirRedeActionPerformed(null); }//GEN-LAST:event_jButtonAbrirActionPerformed private void jButtonNovoActionPerformed(java.aw t.event.ActionEvent evt) {//GEN-FIRST:event_jButtonNovoActionPerformed redeActionPerformed(null); }//GEN-LAST:event_jButtonNovoActionPerformed private void codigoJSActionPerformed(java.awt.e vent.ActionEvent evt) {//GEN-FIRST:event_codigoJSActionPerformed

181

if (!rna.getEstaTreinada()) { javax.swing.JOptionPane.showMessageDial og(this, "Não há uma rede treinada para gerar código!", "Aviso!", javax.swing.JOptionPane.WARNING_MESSAGE); return; } boolean invalido = true; geraCodigo = new geradoresCodigo.GeradorCod igoJS(); String nomeArq; String limiar; limiar = javax.swing.JOptionPane.showInputD ialog(this, "Informe o valor de limiar de saída.\nEste valor será o limite com o\nqual o programa interpretará uma\nsaída como 0 ou 1.", "0.5"); javax.swing.JFileChooser jfc = new javax.sw ing.JFileChooser(); jfc.setApproveButtonMnemonic('S'); jfc.setApproveButtonText("Salvar"); jfc.setDialogTitle("Código fonte em JavaScr ipt"); while(invalido) { if(jfc.showSaveDialog(this) == jfc.APPR OVE_OPTION){ java.io.File file = jfc.getSelected File(); nomeArq = file.getName(); if(nomeArq.indexOf('.') > 0) { if(!nomeArq.substring(nomeArq.indexOf('.')).equals( ".js")) { javax.swing.JOptionPane.sho wMessageDialog(this, "Nome de arquivo inválido.\nO nome não deve conter '.'", "Aviso de Erro!", javax.swing.JOptionPane.ERROR_MESSAGE); } else { invalido = false; } } else { invalido = false; } if(!invalido) { if(nomeArq.indexOf('.') <= 0) { try { nomeArq = file.getAbsol utePath().concat(".js"); file = new java.io.File (nomeArq); } catch (Exception e) { javax.swing.JOptionPane.showMessageDialog(this,e.ge tMessage()); } } else { nomeArq = file.getAbsoluteP ath(); file = new java.io.File(nom eArq); } int resposta = javax.swing.JOpt ionPane.YES_OPTION; try { if(file.exists()) { resposta = javax.swing.JOptionPane.showConfirmDialog(this, "Ar quivo já existe, sobrescrever?", "Atenção", javax.swing.JOptionPane. YES_NO_OPTION, javax.swing.JOptionPane.WARNING_MESSAGE); } if(javax.swing.JOptionPane. YES_OPTION != resposta) { javax.swing.JOptionPane .showMessageDialog(this, "O arquivo não foi gravado!");

182

} else { nomeArq = nomeArq.subst ring(0, nomeArq.length()-3); geraCodigo.gerarArquivo EmDisco(nomeArq); geraCodigo.gerarFuncaoR NAMLP(rna, Double.parseDouble(limiar)); javax.swing.JOptionPane .showMessageDialog(this, "Arquivo gerado com sucesso!"); } } catch (Exception e) { javax.swing.JOptionPane.sho wMessageDialog(this, "Não foi possível gravar o arquivo!\nErro: " + e.ge tMessage()); return; } } } else { invalido = false; } } }//GEN-LAST:event_codigoJSActionPerformed private void codigoOPActionPerformed(java.awt.e vent.ActionEvent evt) {//GEN-FIRST:event_codigoOPActionPerformed if (!rna.getEstaTreinada()) { javax.swing.JOptionPane.showMessageDial og(this, "Não há uma rede treinada para gerar código!", "Aviso!", javax.swing.JOptionPane.WARNING_MESSAGE); return; } boolean invalido = true; geraCodigo = new geradoresCodigo.GeradorCod igoOP(); String nomeArq; String limiar; limiar = javax.swing.JOptionPane.showInputD ialog(this, "Informe o valor de limiar de saída.\nEste valor será o limite com o\nqual o programa interpretará uma\nsaída como 0 ou 1.", "0.5"); javax.swing.JFileChooser jfc = new javax.sw ing.JFileChooser(); jfc.setApproveButtonMnemonic('S'); jfc.setApproveButtonText("Salvar"); jfc.setDialogTitle("Código fonte em Object Pascal"); while(invalido) { if(jfc.showSaveDialog(this) == jfc.APPR OVE_OPTION){ java.io.File file = jfc.getSelected File(); nomeArq = file.getName(); if(nomeArq.indexOf('.') > 0) { if(!nomeArq.substring(nomeArq.indexOf('.')).equals( ".pas")) { javax.swing.JOptionPane.sho wMessageDialog(this, "Nome de arquivo inválido.\nO nome não deve conter '.'", "Aviso de Erro!", javax.swing.JOptionPane.ERROR_MESSAGE); } else { invalido = false; } } else { invalido = false; } if(!invalido) { if(nomeArq.indexOf('.') <= 0) {

183

try { nomeArq = file.getAbsolutePath().concat(".pas"); file = new java.io.File (nomeArq); } catch (Exception e) { javax.swing.JOptionPane.showMessageDialog(this,e.ge tMessage()); } } else { nomeArq = file.getAbsoluteP ath(); file = new java.io.File(nom eArq); } int resposta = javax.swing.JOpt ionPane.YES_OPTION; try { if(file.exists()) { resposta = javax.swing.JOptionPane.showConfirmDialog(this, "Ar quivo já existe, sobrescrever?", "Atenção", javax.swing.JOptionPane. YES_NO_OPTION, javax.swing.JOptionPane.WARNING_MESSAGE); } if(javax.swing.JOptionPane. YES_OPTION != resposta) { javax.swing.JOptionPane .showMessageDialog(this, "O arquivo não foi gravado!"); } else { nomeArq = nomeArq.subst ring(0, nomeArq.length()-4); geraCodigo.gerarArquivo EmDisco(nomeArq); geraCodigo.gerarFuncaoR NAMLP(rna, Double.parseDouble(limiar)); javax.swing.JOptionPane .showMessageDialog(this, "Arquivo gerado com sucesso!"); } } catch (Exception e) { javax.swing.JOptionPane.sho wMessageDialog(this, "Não foi possível gravar o arquivo!\nErro: " + e.ge tMessage()); return; } } } else { invalido = false; } } }//GEN-LAST:event_codigoOPActionPerformed private void codigoCActionPerformed(java.awt.ev ent.ActionEvent evt) {//GEN-FIRST:event_codigoCActionPerformed if (!rna.getEstaTreinada()) { javax.swing.JOptionPane.showMessageDial og(this, "Não há uma rede treinada para gerar código!", "Aviso!", javax.swing.JOptionPane.WARNING_MESSAGE); return; } boolean invalido = true; geraCodigo = new geradoresCodigo.GeradorCod igoCPP(); String nomeArq; String limiar;

184

limiar = javax.swing.JOptionPane.showInputD ialog(this, "Informe o valor de limiar de saída.\nEste valor será o limite com o\nqual o programa interpretará uma\nsaída como 0 ou 1.", "0.5"); javax.swing.JFileChooser jfc = new javax.sw ing.JFileChooser(); jfc.setApproveButtonMnemonic('S'); jfc.setApproveButtonText("Salvar"); jfc.setDialogTitle("Código fonte em C++"); while(invalido) { if(jfc.showSaveDialog(this) == jfc.APPR OVE_OPTION){ java.io.File file = jfc.getSelected File(); nomeArq = file.getName(); if(nomeArq.indexOf('.') > 0) { if(!nomeArq.substring(nomeArq.indexOf('.')).equals( ".h")) { javax.swing.JOptionPane.sho wMessageDialog(this, "Nome de arquivo inválido.\nO nome não deve conter '.'", "Aviso de Erro!", javax.swing.JOptionPane.ERROR_MESSAGE); } else { invalido = false; } } else { invalido = false; } if(!invalido) { if(nomeArq.indexOf('.') <= 0) { try { nomeArq = file.getAbsol utePath().concat(".h"); file = new java.io.File (nomeArq); } catch (Exception e) { javax.swing.JOptionPane.showMessageDialog(this,e.ge tMessage()); } } else { nomeArq = file.getAbsoluteP ath(); file = new java.io.File(nom eArq); } int resposta = javax.swing.JOpt ionPane.YES_OPTION; try { if(file.exists()) { resposta = javax.swing.JOptionPane.showConfirmDialog(this, "Ar quivo já existe, sobrescrever?", "Atenção", javax.swing.JOptionPane. YES_NO_OPTION, javax.swing.JOptionPane.WARNING_MESSAGE); } if(javax.swing.JOptionPane. YES_OPTION != resposta) { javax.swing.JOptionPane .showMessageDialog(this, "O arquivo não foi gravado!"); } else { nomeArq = nomeArq.subst ring(0, nomeArq.length()-2); geraCodigo.gerarArquivo EmDisco(nomeArq); geraCodigo.gerarFuncaoR NAMLP(rna, Double.parseDouble(limiar)); javax.swing.JOptionPane .showMessageDialog(this, "Arquivo gerado com sucesso!"); } } catch (Exception e) {

185

javax.swing.JOptionPane.sho wMessageDialog(this, "Não foi possível gravar o arquivo!\nErro: " + e.ge tMessage()); return; } } } else { invalido = false; } } }//GEN-LAST:event_codigoCActionPerformed private void codigoJavaActionPerformed(java.awt .event.ActionEvent evt) {//GEN-FIRST:event_codigoJavaActionPerformed if (!rna.getEstaTreinada()) { javax.swing.JOptionPane.showMessageDial og(this, "Não há uma rede treinada para gerar código!", "Aviso!", javax.swing.JOptionPane.WARNING_MESSAGE); return; } boolean invalido = true; geraCodigo = new geradoresCodigo.GeradorCod igoJava(); String nomeArq; String limiar; limiar = javax.swing.JOptionPane.showInputD ialog(this, "Informe o valor de limiar de saída.\nEste valor será o limite com o\nqual o programa interpretará uma\nsaída como 0 ou 1.", "0.5"); javax.swing.JFileChooser jfc = new javax.sw ing.JFileChooser(); jfc.setApproveButtonMnemonic('S'); jfc.setApproveButtonText("Salvar"); jfc.setDialogTitle("Código fonte em JAVA"); while(invalido) { if(jfc.showSaveDialog(this) == jfc.APPR OVE_OPTION){ java.io.File file = jfc.getSelected File(); nomeArq = file.getName(); if(nomeArq.indexOf('.') > 0) { if(!nomeArq.substring(nomeArq.indexOf('.')).equals( ".java")) { javax.swing.JOptionPane.sho wMessageDialog(this, "Nome de arquivo inválido.\nO nome não deve conter '.'", "Aviso de Erro!", javax.swing.JOptionPane.ERROR_MESSAGE); } else { invalido = false; } } else { invalido = false; } if(!invalido) { if(nomeArq.indexOf('.') <= 0) { try { nomeArq = file.getAbsolutePath().concat(".java"); file = new java.io.File (nomeArq); } catch (Exception e) { javax.swing.JOptionPane.showMessageDialog(this,e.ge tMessage()); } } else { nomeArq = file.getAbsoluteP ath();

186

file = new java.io.File(nom eArq); } int resposta = javax.swing.JOpt ionPane.YES_OPTION; try { if(file.exists()) { resposta = javax.swing.JOptionPane.showConfirmDialog(this, "Ar quivo já existe, sobrescrever?", "Atenção", javax.swing.JOptionPane. YES_NO_OPTION, javax.swing.JOptionPane.WARNING_MESSAGE); } if(javax.swing.JOptionPane. YES_OPTION != resposta) { javax.swing.JOptionPane .showMessageDialog(this, "O arquivo não foi gravado!"); } else { nomeArq = nomeArq.subst ring(0, nomeArq.length()-5); geraCodigo.gerarArquivo EmDisco(nomeArq); geraCodigo.gerarFuncaoR NAMLP(rna, Double.parseDouble(limiar)); javax.swing.JOptionPane .showMessageDialog(this, "Arquivo gerado com sucesso!"); } } catch (Exception e) { javax.swing.JOptionPane.sho wMessageDialog(this, "Não foi possível gravar o arquivo!\nErro: " + e.ge tMessage()); return; } } } else { invalido = false; } } }//GEN-LAST:event_codigoJavaActionPerformed private void TreinarActionPerformed(java.awt.ev ent.ActionEvent evt) {//GEN-FIRST:event_TreinarActionPerformed jLStatus.setText(""); janelaProgresso = new Progresso(this, "Trei namento da rede", "Rede sendo treinada ...", "Fechar", "Treinar"); janelaProgresso.getFrame().setVisible(true) ; janelaProgresso.getBarraProgresso().setInde terminate(true); Thread processo = new Treino(this, rna, tre inador, janelaProgresso); janelaProgresso.setProcesso(processo); jLStatus.setText(""); this.desabilitaSalvarCodigo(); redeSalva = false; processo.start(); }//GEN-LAST:event_TreinarActionPerformed private void jBCancelaTFocusGained(java.awt.eve nt.FocusEvent evt) {//GEN-FIRST:event_jBCancelaTFocusGained jLStatus.setText("Abandonar a configuração do treinamento"); }//GEN-LAST:event_jBCancelaTFocusGained private void jBConfiguraTActionPerformed(java.a wt.event.ActionEvent evt) {//GEN-FIRST:event_jBConfiguraTActionPerformed

187

double erro, fator; int epocas; if(jTFErro.getText().length() == 0) { jTFErro.requestFocus(); return; } if(jTFEpocas.getText().length() == 0) { jTFEpocas.requestFocus(); return; } if(jTFFator.getText().length() == 0) { jTFFator.requestFocus(); return; } erro = Double.parseDouble(jTFErro.getText() ); epocas = Integer.parseInt(jTFEpocas.getText ()); fator = Double.parseDouble(jTFFator.getText ()); treinador.setErroAceitavell(erro); treinador.setEpocasMaximo(epocas); treinador.setFatorAprendizagem(fator); javax.swing.JOptionPane.showMessageDialog(t his, "Treinamento configurado!", "Resultado", javax.swing.JOptionPane .INFORMATION_MESSAGE); lm.show(painelPrincipal, "cardInicio"); jLStatus.setText("Selecione um dos ítens de menu"); }//GEN-LAST:event_jBConfiguraTActionPerformed private void jBConfiguraTFocusGained(java.awt.e vent.FocusEvent evt) {//GEN-FIRST:event_jBConfiguraTFocusGained jLStatus.setText("Configura o treinamento") ; }//GEN-LAST:event_jBConfiguraTFocusGained private void jBCancelaTActionPerformed(java.awt .event.ActionEvent evt) {//GEN-FIRST:event_jBCancelaTActionPerformed lm.show(painelPrincipal, "cardInicio"); jLStatus.setText("Selecione um dos ítens de menu"); }//GEN-LAST:event_jBCancelaTActionPerformed private void jButton8ActionPerformed(java.awt.e vent.ActionEvent evt) {//GEN-FIRST:event_jButton8ActionPerformed javax.swing.JOptionPane.showMessageDialog(t his, "Este campo deve ser preenchido\ncom valor maior que 0\n e menor que 1. Quanto maior\no valor, mais rápido será\no treinamento. Entretanto, \nmaior a chance da rede não\nconseguir ser treinada.\nValores indicados par a este\ncampo ficam entre 0.05 e 0.25.", "Ajuda!", javax.swing.JOptionPane.INFORMATION_MESSAGE); }//GEN-LAST:event_jButton8ActionPerformed private void jButton7ActionPerformed(java.awt.e vent.ActionEvent evt) {//GEN-FIRST:event_jButton7ActionPerformed javax.swing.JOptionPane.showMessageDialog(t his, "Este campo deve ser preenchido\ncom o número máximo de épocas\nque a rede deve ser treinada.\nSe ao final destas épocas\na rede não es tiver treinada\no treinamento encerra informando\nnão ter conseguido treinar.", "Ajuda!", javax.swing.JOptionPane.INFORMATION_MESSAGE); }//GEN-LAST:event_jButton7ActionPerformed private void jButton6ActionPerformed(java.awt.e vent.ActionEvent evt) {//GEN-FIRST:event_jButton6ActionPerformed

188

javax.swing.JOptionPane.showMessageDialog(t his, "Este campo deve ser preenchido\ncom o valor máximo admissível \nde erro na saída. Os valores de\nsaída são normalmente 0 ou 1.\nUm erro de 0.1, por exemplo\nadmitiria como 1 valores entre\n0.9 ou 1.1 .", "Ajuda!", javax.swing.JOptionPane.INFORMATION_MESSAGE); }//GEN-LAST:event_jButton6ActionPerformed private void jTFFatorFocusGained(java.awt.event .FocusEvent evt) {//GEN-FIRST:event_jTFFatorFocusGained jLStatus.setText("Informe o o fator de apre ndizagem, maior que 0 e menor que 1."); }//GEN-LAST:event_jTFFatorFocusGained private void jTFEpocasFocusGained(java.awt.even t.FocusEvent evt) {//GEN-FIRST:event_jTFEpocasFocusGained jLStatus.setText("Informe a quantidade máxi ma de épocas."); }//GEN-LAST:event_jTFEpocasFocusGained private void jTFErroFocusGained(java.awt.event. FocusEvent evt) {//GEN-FIRST:event_jTFErroFocusGained jLStatus.setText("Informe o erro máximo ace itável, maior que 0 e menor que 1."); }//GEN-LAST:event_jTFErroFocusGained private void jTFFatorFocusLost(java.awt.event.F ocusEvent evt) {//GEN-FIRST:event_jTFFatorFocusLost double fator; if((jTFFator.getText().length() == 0) || (jTFErro.getText().length() == 0) || (jTFEpocas.get Text().length() == 0)) { jBConfiguraT.setEnabled(false); } else { jBConfiguraT.setEnabled(true); } if (jTFFator.getText().length() != 0) { try { fator = Double.parseDouble(jTFFator .getText()); if (fator > 0 && fator < 1) { treinador.setFatorAprendizagem( fator); } else { javax.swing.JOptionPane.showMes sageDialog(this, "Valor inválido!\nEste campo exige um número maior que zer o e menor que um.", "Erro!", javax.swing.JOptionPane.ERROR_MESSAGE); jTFFator.setText(""); jTFFator.requestFocus(); } } catch (Exception e) { javax.swing.JOptionPane.showMessage Dialog(this,"Valor inválido!\nEste campo exige um número maior que zer o e menor que um.", "Erro!", javax.swing.JOptionPane.ERROR_MESSAGE); jTFFator.setText(""); jTFFator.requestFocus(); } } }//GEN-LAST:event_jTFFatorFocusLost private void jTFEpocasFocusLost(java.awt.event. FocusEvent evt) {//GEN-FIRST:event_jTFEpocasFocusLost int epocas;

189

if((jTFFator.getText().length() == 0) || (jTFErro.getText().length() == 0) || (jTFEpocas.get Text().length() == 0)) { jBConfiguraT.setEnabled(false); } else { jBConfiguraT.setEnabled(true); } if (jTFEpocas.getText().length() != 0) { try { epocas = Integer.parseInt(jTFEpocas .getText()); if (epocas > 0) { treinador.setEpocasMaximo(epoca s); } else { javax.swing.JOptionPane.showMes sageDialog(this, "Valor inválido!\nEste campo exige um número inteiro maior que zero.", "Erro!", javax.swing.JOptionPane.ERROR_MESSAGE); jTFEpocas.setText(""); jTFEpocas.requestFocus(); } } catch (Exception e) { javax.swing.JOptionPane.showMessage Dialog(this,"Valor inválido!\nEste campo exige um número inteiro maior que zero.", "Erro!", javax.swing.JOptionPane.ERROR_MESSAGE); jTFEpocas.setText(""); jTFEpocas.requestFocus(); } } }//GEN-LAST:event_jTFEpocasFocusLost private void jTFErroFocusLost(java.awt.event.Fo cusEvent evt) {//GEN-FIRST:event_jTFErroFocusLost double erro; if((jTFFator.getText().length() == 0) || (jTFErro.getText().length() == 0) || (jTFEpocas.get Text().length() == 0)) { jBConfiguraT.setEnabled(false); } else { jBConfiguraT.setEnabled(true); } if (jTFErro.getText().length() != 0) { try { erro = Double.parseDouble(jTFErro.g etText()); if (erro > 0 && erro < 1) { treinador.setErroAceitavell(err o); } else { javax.swing.JOptionPane.showMes sageDialog(this, "Valor inválido!\nEste campo exige um número maior que zer o e menor que um.", "Erro!", javax.swing.JOptionPane.ERROR_MESSAGE); jTFErro.setText(""); jTFErro.requestFocus(); } } catch (Exception e) { javax.swing.JOptionPane.showMessage Dialog(this,"Valor inválido!\nEste campo exige um número maior que zer o e menor que um.", "Erro!", javax.swing.JOptionPane.ERROR_MESSAGE); jTFErro.setText(""); jTFErro.requestFocus(); } } }//GEN-LAST:event_jTFErroFocusLost

190

private void treinamentoActionPerformed(java.aw t.event.ActionEvent evt) {//GEN-FIRST:event_treinamentoActionPerformed lm.show(painelPrincipal, "cardTreina"); jPanelRedeInterno.setFocusCycleRoot(true); jTFErro.setText(Double.toString(treinador.g etErroAceitavel())); jTFEpocas.setText(Integer.toString(treinado r.getEpocasMaximo())); jTFFator.setText(Double.toString(treinador.getFator Aprendizagem())); if((jTFFator.getText().length() == 0) || (jTFErro.getText().length() == 0) || (jTFEpocas.get Text().length() == 0)) { jBConfiguraT.setEnabled(false); } jLStatus.setText("Configuração do treinamen to"); }//GEN-LAST:event_treinamentoActionPerformed private void redeActionPerformed(java.awt.event .ActionEvent evt) {//GEN-FIRST:event_redeActionPerformed lm.show(painelPrincipal, "cardRede"); jPanelRedeInterno.setFocusCycleRoot(true); jLStatus.setText("Configuração da rede"); jTFNosEntrada.setText(Integer.toString(rna. getNosEntrada())); jTFNosSaida.setText(Integer.toString(rna.ge tNosSaida())); jTFNosEscondidos.setText(Integer.toString(r na.getNosEscondidos())); if(rna.getBias() == 1) { jRadioButton1.setSelected(true); } else { jRadioButton2.setSelected(true); } if(rna.getFuncao().getNome().equals("Sigmoi dal")) { jComboBox1.setSelectedIndex(0); } else { jComboBox1.setSelectedIndex(1); } if((jTFNosEntrada.getText().length() == 0) || (jTFNosSaida.getText().length() == 0) || (jTFNosEscondidos.getText().length() == 0)) { jButtonConfigurar.setEnabled(false); } else { jButtonConfigurar.setEnabled(true); } }//GEN-LAST:event_redeActionPerformed private void jButtonCancelarActionPerformed(jav a.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButtonCancelarActionPerfor med lm.show(painelPrincipal, "cardInicio"); jLStatus.setText("Selecione um dos ítens de menu"); }//GEN-LAST:event_jButtonCancelarActionPerforme d private void menuAjudaFocusGained(java.awt.even t.FocusEvent evt) {//GEN-FIRST:event_menuAjudaFocusGained jLStatus.setText(""); }//GEN-LAST:event_menuAjudaFocusGained private void menuArquivoFocusGained(java.awt.ev ent.FocusEvent evt) {//GEN-FIRST:event_menuArquivoFocusGained jLStatus.setText(""); }//GEN-LAST:event_menuArquivoFocusGained

191

private void jButtonCancelarFocusGained(java.aw t.event.FocusEvent evt) {//GEN-FIRST:event_jButtonCancelarFocusGained jLStatus.setText("Abandonar a configuração da rede."); }//GEN-LAST:event_jButtonCancelarFocusGained private void jButtonConfigurarFocusGained(java. awt.event.FocusEvent evt) {//GEN-FIRST:event_jButtonConfigurarFocusGaine d jLStatus.setText("Configurar a rede."); }//GEN-LAST:event_jButtonConfigurarFocusGained private void jButton4FocusGained(java.awt.event .FocusEvent evt) {//GEN-FIRST:event_jButton4FocusGained jLStatus.setText("Ajuda contextual."); }//GEN-LAST:event_jButton4FocusGained private void jButton5FocusGained(java.awt.event .FocusEvent evt) {//GEN-FIRST:event_jButton5FocusGained jLStatus.setText("Ajuda contextual."); }//GEN-LAST:event_jButton5FocusGained private void jButton3FocusGained(java.awt.event .FocusEvent evt) {//GEN-FIRST:event_jButton3FocusGained jLStatus.setText("Ajuda contextual."); }//GEN-LAST:event_jButton3FocusGained private void jButton2FocusGained(java.awt.event .FocusEvent evt) {//GEN-FIRST:event_jButton2FocusGained jLStatus.setText("Ajuda contextual."); }//GEN-LAST:event_jButton2FocusGained private void jButton1FocusGained(java.awt.event .FocusEvent evt) {//GEN-FIRST:event_jButton1FocusGained jLStatus.setText("Ajuda contextual."); }//GEN-LAST:event_jButton1FocusGained private void jComboBox1FocusGained(java.awt.eve nt.FocusEvent evt) {//GEN-FIRST:event_jComboBox1FocusGained jLStatus.setText("Selecione a função que se rá utilizada para saída."); }//GEN-LAST:event_jComboBox1FocusGained private void jRadioButton2FocusGained(java.awt. event.FocusEvent evt) {//GEN-FIRST:event_jRadioButton2FocusGained jLStatus.setText("Nesta opção não será util izado o nó de Bias."); }//GEN-LAST:event_jRadioButton2FocusGained private void jRadioButton1FocusGained(java.awt. event.FocusEvent evt) {//GEN-FIRST:event_jRadioButton1FocusGained jLStatus.setText("Nesta opção será utilizad o um nó a mais como Bias na entrada e camada escondida."); }//GEN-LAST:event_jRadioButton1FocusGained private void jTFNosEscondidosFocusGained(java.a wt.event.FocusEvent evt) {//GEN-FIRST:event_jTFNosEscondidosFocusGained jLStatus.setText("Este valor pode ser preen chido automaticamente, basta preencher os demais campos."); }//GEN-LAST:event_jTFNosEscondidosFocusGained

192

private void jTFNosSaidaFocusGained(java.awt.ev ent.FocusEvent evt) {//GEN-FIRST:event_jTFNosSaidaFocusGained jLStatus.setText("Informe um número inteiro maior que zero para Nós de Saída"); }//GEN-LAST:event_jTFNosSaidaFocusGained private void jTFNosEntradaFocusGained(java.awt. event.FocusEvent evt) {//GEN-FIRST:event_jTFNosEntradaFocusGained jLStatus.setText("Informe um número inteiro maior que zero para Nós de Entrada"); }//GEN-LAST:event_jTFNosEntradaFocusGained private void jButton5ActionPerformed(java.awt.e vent.ActionEvent evt) {//GEN-FIRST:event_jButton5ActionPerformed javax.swing.JOptionPane.showMessageDialog(t his, "Escolha se deseja usar um\nnó como Bias. Normalmante\no uso do Bias m elhora a\napendizagem da rede.\nSugerimos escolher Sim.", "Ajuda!", javax.swing.JOptionPane.INFORMATION_MESSAGE); }//GEN-LAST:event_jButton5ActionPerformed private void jButtonConfigurarActionPerformed(java.awt.event.Act ionEvent evt) {//GEN-FIRST:event_jButtonConfigurarActionPerformed int entrada, saida, escondido, bias; int esc, sai, ent; redeSalva = false; funcoesSaida.FuncaoSaida fa; if(jTFNosEntrada.getText().length() == 0) { jTFNosEntrada.requestFocus(); return; } if(jTFNosSaida.getText().length() == 0) { jTFNosSaida.requestFocus(); return; } try { ent = Integer.parseInt(jTFNosEntrada.ge tText()); sai = Integer.parseInt(jTFNosSaida.getT ext()); esc = (ent + sai)/2; if (Integer.parseInt(jTFNosEscondidos.g etText()) != esc) { if(javax.swing.JOptionPane.showConf irmDialog(this, "O campo Nós Escondidos está \npreenchido com valor diferent e\ndo sugerido (" + esc + ").\nRecomendamos aceitar o valor\nsugerido. Cliq ue em Yes para\nalterá-lo ou No para mantê-lo!", "Ajuda!", javax.swing.JOp tionPane.YES_NO_OPTION) == javax.swing.JOptionPane.OK_OPTION) { jTFNosEscondidos.setText(Integer.toString(esc)); } } } catch (Exception e) {} if(jTFNosEscondidos.getText().length() == 0 ) { jTFNosEscondidos.requestFocus(); return; } if(jComboBox1.getSelectedIndex() < 0) { jComboBox1.requestFocus(); return; }

193

entrada = Integer.parseInt(jTFNosEntrada.ge tText()); saida = Integer.parseInt(jTFNosSaida.getTex t()); escondido = Integer.parseInt(jTFNosEscondid os.getText()); bias = jRadioButton1.isSelected() ? 1 : 0; if(jComboBox1.getSelectedIndex() == 0){ fa = new funcoesSaida.FuncaoSigmoidal() ; } else { fa = new funcoesSaida.FuncaoTangHiperb( ); } rna.setFuncao(fa); try { rna.setNosEntrada(entrada); rna.setNosEscondidos(escondido); rna.setNosSaida(saida); rna.setBias(bias); treinador.setRna(rna); } catch (Exception e) { javax.swing.JOptionPane.showMessageDial og(this, "Erro na configuração da rede!\n" + e.getMessage(), "Aviso d e Erro", javax.swing.JOptionPane.ERROR_MESSAGE); leuPadroes = false; Treinar.setEnabled(false); treinamento.setEnabled(false); return; } javax.swing.JOptionPane.showMessageDialog(t his, "Rede configurada!", "Resultado", javax.swing.JOptionPane .INFORMATION_MESSAGE); lm.show(painelPrincipal, "cardInicio"); Treinar.setEnabled(leuPadroes); treinamento.setEnabled(leuPadroes); jLStatus.setText("Selecione um dos Itens de menu"); }//GEN-LAST:event_jButtonConfigurarActionPerfor med private void jTFNosEscondidosFocusLost(java.awt .event.FocusEvent evt) {//GEN-FIRST:event_jTFNosEscondidosFocusLost int esc; try { esc = Integer.parseInt(jTFNosEscondidos .getText()); if(esc < 1) { javax.swing.JOptionPane.showMessage Dialog(this, "Valor inválido!\nEste campo exige um número inteiro maior que zero.", "Erro!", javax.swing.JOptionPane.ERROR_MESSAGE); jTFNosEscondidos.setText(""); jTFNosEscondidos.requestFocus(); } } catch (Exception e) { javax.swing.JOptionPane.showMessageDial og(this, "Valor inválido!\nEste campo exige um número inteiro maior que zero.", "Erro!", javax.swing.JOptionPane.ERROR_MESSAGE); jTFNosEscondidos.setText(""); jTFNosEscondidos.requestFocus(); } if((jTFNosEntrada.getText().length() == 0) || (jTFNosSaida.getText().length() == 0) || (jTFNosEscondidos.getText().length() == 0)) { jButtonConfigurar.setEnabled(false); } else { jButtonConfigurar.setEnabled(true);

194

} }//GEN-LAST:event_jTFNosEscondidosFocusLost private void jTFNosSaidaFocusLost(java.awt.even t.FocusEvent evt) {//GEN-FIRST:event_jTFNosSaidaFocusLost int ent, sai; try { sai = Integer.parseInt(jTFNosSaida.getT ext()); if(sai < 1) { javax.swing.JOptionPane.showMessage Dialog(this, "Valor inválido!\nEste campo exige um número inteiro maior que zero.", "Erro!", javax.swing.JOptionPane.ERROR_MESSAGE); jTFNosSaida.setText(""); jTFNosSaida.requestFocus(); } } catch (Exception e) { javax.swing.JOptionPane.showMessageDial og(this, "Valor inválido!\nEste campo exige um número inteiro maior que zero.", "Erro!", javax.swing.JOptionPane.ERROR_MESSAGE); jTFNosSaida.setText(""); jTFNosSaida.requestFocus(); } ent = Integer.parseInt(jTFNosEntrada.getTex t()); sai = Integer.parseInt(jTFNosSaida.getText( )); if(jTFNosEntrada.getText().length()>0 && jTFNosSaida.getText().length()>0 && jTFNosEscondido s.getText().length() == 0) { jTFNosEscondidos.setText(Integer.toStri ng((ent + sai)/2)); } if((jTFNosEntrada.getText().length() == 0) || (jTFNosSaida.getText().length() == 0) || (jTFNosEscondidos.getText().length() == 0)) { jButtonConfigurar.setEnabled(false); } else { jButtonConfigurar.setEnabled(true); } }//GEN-LAST:event_jTFNosSaidaFocusLost private void jTFNosEntradaFocusLost(java.awt.ev ent.FocusEvent evt) {//GEN-FIRST:event_jTFNosEntradaFocusLost int ent, sai, esc; try { ent = Integer.parseInt(jTFNosEntrada.ge tText()); if(ent < 1) { javax.swing.JOptionPane.showMessage Dialog(this, "Valor inválido!\nEste campo exige um número inteiro maior que zero.", "Erro!", javax.swing.JOptionPane.ERROR_MESSAGE); jTFNosEntrada.setText(""); jTFNosEntrada.requestFocus(); } } catch (Exception e) { javax.swing.JOptionPane.showMessageDial og(this, "Valor inválido!\nEste campo exige um número inteiro maior que zero.", "Erro!", javax.swing.JOptionPane.ERROR_MESSAGE); jTFNosEntrada.setText(""); jTFNosEntrada.requestFocus(); } ent = Integer.parseInt(jTFNosEntrada.getTex t());

195

sai = Integer.parseInt(jTFNosSaida.getText( )); if(jTFNosEntrada.getText().length()>0 && jTFNosSaida.getText().length()>0 && jTFNosEscondido s.getText().length() == 0) { jTFNosEscondidos.setText(Integer.toStri ng((ent + sai)/2)); } if((jTFNosEntrada.getText().length() == 0) || (jTFNosSaida.getText().length() == 0) || (jTFNosEscondidos.getText().length() == 0)) { jButtonConfigurar.setEnabled(false); } else { jButtonConfigurar.setEnabled(true); } }//GEN-LAST:event_jTFNosEntradaFocusLost private void jButton3ActionPerformed(java.awt.e vent.ActionEvent evt) {//GEN-FIRST:event_jButton3ActionPerformed javax.swing.JOptionPane.showMessageDialog(t his, "Este campo deve ser preenchido \ncom a quantidade de nós \nintermed iários que a rede terá.\nO melhor valor para este campo\ndepende de m uitos fatores.\nSugerimos aceitar o valor\nindicado pelo programa", "juda!", javax.swing.JOptionPane.INFORMATION_MESSAGE); }//GEN-LAST:event_jButton3ActionPerformed private void jButton2ActionPerformed(java.awt.e vent.ActionEvent evt) {//GEN-FIRST:event_jButton2ActionPerformed javax.swing.JOptionPane.showMessageDialog(t his, "Este campo deve ser preenchido \ncom a quantidade de saídas que \na rede terá.\nSaídas são, portanto, os dados que\nobteremos como resultado de um\ndado problema.", "Ajuda!", javax.swing.JOptionPane.INFORMATION_MESSA GE); }//GEN-LAST:event_jButton2ActionPerformed private void jButton1ActionPerformed(java.awt.e vent.ActionEvent evt) {//GEN-FIRST:event_jButton1ActionPerformed javax.swing.JOptionPane.showMessageDialog(t his, "Este campo deve ser preenchido \ncom a quantidade de entradas que \ na rede terá.\nEntradas são, portanto, os dados \nconhecidos de um dado pro blema.", "Ajuda!", javax.swing.JOptionPane.INFORMATION_MESSAGE); }//GEN-LAST:event_jButton1ActionPerformed private void salvarRedeActionPerformed(java.awt .event.ActionEvent evt) {//GEN-FIRST:event_salvarRedeActionPerformed javax.swing.JFileChooser jfc = new javax.sw ing.JFileChooser(); jfc.setApproveButtonMnemonic('S'); jfc.setApproveButtonText("Salvar"); jfc.setDialogTitle("Arquivo com os dados da rede"); if(jfc.showSaveDialog(this) == jfc.APPROVE_ OPTION){ java.io.File file = jfc.getSelectedFile (); int resposta = javax.swing.JOptionPane. YES_OPTION; manipulacaoArquivos.PersistenciaRede gr avador = new manipulacaoArquivos.PersistenciaRede(); try { if(file.exists()) { resposta = javax.swing.JOptionPane.showConfirmDialog(this, "Ar quivo já existe, sobrescrever?", "Atenção", javax.swing.JOptionPane. YES_NO_OPTION, javax.swing.JOptionPane.WARNING_MESSAGE); }

196

if(javax.swing.JOptionPane.YES_OPTI ON != resposta) { javax.swing.JOptionPane.showMes sageDialog(this, "O arquivo não foi gravado!"); } else { gravador.gerarArquivoRede(file. getAbsolutePath(), rna); javax.swing.JOptionPane.showMessageDialog(this,"Con figurações gravadas com sucesso!"); } } catch (Exception e) { javax.swing.JOptionPane.showMessage Dialog(this, "Não foi possível gravar o arquivo!\nErro: " + e.getMessage( )); } redeSalva = true; } }//GEN-LAST:event_salvarRedeActionPerformed private void saindo(java.awt.event.WindowEvent evt) {//GEN-FIRST:event_saindo this.trataSaida(); System.exit(0); }//GEN-LAST:event_saindo private void SairActionPerformed(java.awt.event .ActionEvent evt) {//GEN-FIRST:event_SairActionPerformed this.trataSaida(); System.exit(0); }//GEN-LAST:event_SairActionPerformed private void abrirPadroesActionPerformed(java.a wt.event.ActionEvent evt) {//GEN-FIRST:event_abrirPadroesActionPerformed String nomeArquivo; LeArquivo leitor; boolean compativel = false; javax.swing.JFileChooser jFC = new javax.sw ing.JFileChooser(); jFC.setApproveButtonMnemonic('A'); jFC.setApproveButtonText("Abrir"); jFC.setDialogTitle("Arquivo com os padrões para treinamento"); if(jFC.showOpenDialog(this) == jFC.APPROVE_ OPTION){ nomeArquivo = jFC.getSelectedFile().get Path(); janelaProgresso = new Progresso(this, " Leitura do arquivo de padrões", "Arquivo sendo lido ...", "Fechar", "Ler" ); janelaProgresso.getFrame().setVisible(t rue); janelaProgresso.getBarraProgresso().set Indeterminate(true); jLStatus.setText("Arquivo sendo lido .. ."); leitor = new LeArquivo(this, rna, trein ador, janelaProgresso, nomeArquivo); janelaProgresso.setProcesso(leitor); leitor.start(); } }//GEN-LAST:event_abrirPadroesActionPerformed private void abrirRedeActionPerformed(java.awt. event.ActionEvent evt) {//GEN-FIRST:event_abrirRedeActionPerformed String nomeArquivo; javax.swing.JFileChooser jFC = new javax.sw ing.JFileChooser(); jFC.setApproveButtonMnemonic('A'); jFC.setApproveButtonText("Abrir");

197

jFC.setDialogTitle("Arquivo com os dados pa ra criação da rede"); if(jFC.showOpenDialog(this) == jFC.APPROVE_ OPTION){ nomeArquivo = jFC.getSelectedFile().get Path(); manipulacaoArquivos.PersistenciaRede le itor = new manipulacaoArquivos.PersistenciaRede(); try { rna = leitor.lerArquivoRede(nomeArq uivo); javax.swing.JOptionPane.showMessage Dialog(this, "Arquivo de configurações lido com sucesso!", "Aviso!", javax.swing.JOptionPane.INFORMATION_MESSAGE); } catch (Exception e) { javax.swing.JOptionPane.showMessage Dialog(this, "Erro na leitura do arquivo: " + e.getMessage(), "Aviso de E rro!", javax.swing.JOptionPane.ERROR_MESSAGE); } } }//GEN-LAST:event_abrirRedeActionPerformed public void resultadoTreino() { jLStatus.setText("Selecione um dos ítens de menu"); lm.show(painelPrincipal, "cardRTreina"); jLQtdEpocas.setText(Integer.toString(treinador.getQ tdEpocasAtual())); jLErroMax.setText(Double.toString(treinador .getErroMaximo())); jLSituacao.setText(rna.getEstaTreinada() ? "Treinou" : "Não Treinou"); ArrayList <Double> ae = treinador.getErrosM aximos(); int qt = ae.size(); int ad; int qtd; if(qt > 10){ ad = qt / 10; qtd = qt / ad; } else { qtd = qt; ad = 1; } String cat1 = "Erros"; String cat2 = "Limite"; DefaultCategoryDataset ds = new DefaultCate goryDataset(); int i; for(i = 0; i < qt; i+=ad) { ds.setValue(ae.get(i), cat1, ""+i); ds.setValue(treinador.getErroAceitavel( ), cat2, ""+i); } ds.setValue(ae.get(qt-1), cat1, ""+qt); ds.setValue(treinador.getErroAceitavel(), c at2, ""+qt); JFreeChart graf = ChartFactory.createLineCh art("Gráfico de Evolução do Treinamento", "Épocas", "Erro", ds, PlotOrientat ion.VERTICAL, true, false, false); jPanelRTreinaInferior.removeAll(); jPanelRTreinaInferior.add(new ChartPanel(gr af)); } public void completaLeitura() { leuPadroes = true; Treinar.setEnabled(true); treinamento.setEnabled(true);

198

jLStatus.setText("Selecione um dos itens de menu"); } private void trataSaida() { //javax.swing.JOptionPane.showMessageDialog (this, "Confirma a saída?"); } public void habilitaTreinar() { Treinar.setEnabled(true); } public void desabilitaTreinar() { Treinar.setEnabled(false); } public void desabilitaSalvarCodigo() { salvarCodigo.setEnabled(false); } public void habilitaSalvarCodigo() { salvarCodigo.setEnabled(true); } public void adequaSalvarCodigo() { salvarCodigo.setEnabled(rna.getEstaTreinada ()); } /** * @param args the command line arguments */ public static void main(String args[]) { java.awt.EventQueue.invokeLater(new Runnabl e() { public void run() { new Principal().setVisible(true); } }); } // Variables declaration - do not modify//GEN-B EGIN:variables private javax.swing.JMenuItem Sair; private javax.swing.JMenu Salvar; private javax.swing.JMenuItem Treinar; private javax.swing.JMenu abrir; private javax.swing.JMenuItem abrirPadroes; private javax.swing.JMenuItem abrirRede; private javax.swing.JToolBar barraFerramentas; private javax.swing.JMenuBar barraMenu; private javax.swing.JPanel barraStatus; private javax.swing.JMenuItem codigoC; private javax.swing.JMenuItem codigoJS; private javax.swing.JMenuItem codigoJava; private javax.swing.JMenuItem codigoOP; private javax.swing.JMenuItem como; private javax.swing.JButton jBCancelaT; private javax.swing.JButton jBConfiguraT; private javax.swing.JButton jButton1; private javax.swing.JButton jButton2; private javax.swing.JButton jButton3;

199

private javax.swing.JButton jButton4; private javax.swing.JButton jButton5; private javax.swing.JButton jButton6; private javax.swing.JButton jButton7; private javax.swing.JButton jButton8; private javax.swing.JButton jButtonAbrir; private javax.swing.JButton jButtonCancelar; private javax.swing.JButton jButtonConfiguracao ; private javax.swing.JButton jButtonConfigurar; private javax.swing.JButton jButtonNovo; private javax.swing.JButton jButtonSalvar; private javax.swing.JButton jButtonTreinar; private javax.swing.JComboBox jComboBox1; private javax.swing.JLabel jLErroMax; private javax.swing.JLabel jLQtdEpocas; private javax.swing.JLabel jLSituacao; private javax.swing.JLabel jLStatus; private javax.swing.JLabel jLabel1; private javax.swing.JLabel jLabel10; private javax.swing.JLabel jLabel12; private javax.swing.JLabel jLabel13; private javax.swing.JLabel jLabel14; private javax.swing.JLabel jLabel15; private javax.swing.JLabel jLabel17; private javax.swing.JLabel jLabel2; private javax.swing.JLabel jLabel3; private javax.swing.JLabel jLabel4; private javax.swing.JLabel jLabel5; private javax.swing.JLabel jLabel6; private javax.swing.JLabel jLabel7; private javax.swing.JLabel jLabel8; private javax.swing.JLabel jLabel9; private javax.swing.JPanel jPanelMenu; private javax.swing.JPanel jPanelRTreina; private javax.swing.JPanel jPanelRTreinaInferio r; private javax.swing.JPanel jPanelRTreinaSuperio r; private javax.swing.JPanel jPanelRede; private javax.swing.JPanel jPanelRedeInterno; private javax.swing.JPanel jPanelTreina; private javax.swing.JPanel jPanelVazio; private javax.swing.JRadioButton jRadioButton1; private javax.swing.JRadioButton jRadioButton2; private javax.swing.JSeparator jSeparator1; private javax.swing.JTextField jTFEpocas; private javax.swing.JTextField jTFErro; private javax.swing.JTextField jTFFator; private javax.swing.JTextField jTFNosEntrada; private javax.swing.JTextField jTFNosEscondidos ; private javax.swing.JTextField jTFNosSaida; private javax.swing.JMenu menuAjuda; private javax.swing.JMenu menuArquivo; private javax.swing.JMenu menuConfiguraRede; private javax.swing.JMenu menuRede; private javax.swing.JPanel painelPrincipal; private javax.swing.JMenuItem rede; private javax.swing.JMenu salvarCodigo; private javax.swing.JMenuItem salvarPesos; private javax.swing.JMenuItem salvarRede;

200

private javax.swing.JMenuItem sobre; private javax.swing.JMenuItem treinamento; // End of variables declaration//GEN-END:variab les public redeNeural.RedeNeural rna; public redeNeural.TreinaRede treinador; public java.awt.CardLayout lm; public boolean leuPadroes = false; geradoresCodigo.GeradorCodigo geraCodigo; public Progresso janelaProgresso; public boolean redeSalva; } class Progresso extends javax.swing.JFrame { private Principal principal; private javax.swing.JLabel mensagem; private javax.swing.JProgressBar barraProgresso ; private javax.swing.JPanel setorNorte; private javax.swing.JPanel setorSul; private javax.swing.JPanel setorCentro; private javax.swing.JButton botao; private Thread processoAtivo; private String origem; public Progresso(Principal princ, String titulo , String msg, String rotuloBotao, String or) { principal = princ; origem = or; java.awt.Dimension screenSize = java.awt.Toolkit.getDefaultToolkit().getScreenSize( ); setBounds((screenSize.width-280)/2, (screen Size.height-120)/2, 280, 120); this.setTitle(titulo); this.setSize(280, 120); this.setLayout(new java.awt.BorderLayout()) ; setorNorte = new javax.swing.JPanel(); setorSul = new javax.swing.JPanel(); setorCentro = new javax.swing.JPanel(); mensagem = new javax.swing.JLabel(msg); botao = new javax.swing.JButton(rotuloBotao ); barraProgresso = new javax.swing.JProgressB ar(); barraProgresso.setBounds(5, 5, 15, 50); this.add(setorNorte, java.awt.BorderLayout. NORTH); this.add(setorCentro, java.awt.BorderLayout .CENTER); this.add(setorSul, java.awt.BorderLayout.SO UTH); setorNorte.add(mensagem); setorCentro.add(barraProgresso); setorSul.add(botao); botao.addActionListener(new java.awt.event. ActionListener() { public void actionPerformed(java.awt.ev ent.ActionEvent evt) { botaoActionPerformed(evt); } }); } public void setRotuloBotao(String rb) { botao.setText(rb); } public void setMensagem(String msg) { mensagem.setText(msg); }

201

public void setProcesso(Thread processo) { processoAtivo = processo; } public javax.swing.JProgressBar getBarraProgres so() { return barraProgresso; } public javax.swing.JFrame getFrame() { return this; } public void botaoActionPerformed(java.awt.event .ActionEvent evt) { if(botao.getText() == "Cancelar") { processoAtivo.stop(); } if(botao.getText() == "Fechar") { if(origem.equals("Ler")) { principal.completaLeitura(); } } if(botao.getText() == "Resultado") { principal.resultadoTreino(); } this.dispose(); } } class Treino extends Thread { private redeNeural.TreinaRede treinador; private redeNeural.RedeNeural rna; private Progresso jpro; private Principal principal; public Treino(Principal princ, redeNeural.RedeN eural r, redeNeural.TreinaRede tr, Progresso pr) { rna = r; treinador = tr; jpro = pr; principal = princ; } public void run() { try { principal.desabilitaSalvarCodigo(); rna.setEstaTreinada(treinador.treinar(jpro.getBarra Progresso())); jpro.setRotuloBotao("Cancelar"); } catch (Exception e) { javax.swing.JOptionPane.showMessageDial og(null, "Erro no treinamento!\n" + e.getMessage(), "Erro!", javax.swing.JOptionPane.ERROR_MESSAGE); jpro.setRotuloBotao("Fechar"); return; } if(rna.getEstaTreinada()) { jpro.setRotuloBotao("Resultado"); jpro.getBarraProgresso().setIndetermina te(false); jpro.getBarraProgresso().setValue(trein ador.getEpocasMaximo()); jpro.setMensagem("Rede treinada com suc esso!"); principal.habilitaSalvarCodigo(); } else if (treinador.getEpocasMaximo() <= treinador.getQtdEpocasAtual()) {

202

jpro.getBarraProgresso().setIndetermina te(false); jpro.setMensagem("Não foi possível trei nar a rede!"); jpro.setRotuloBotao("Fechar"); } } } class LeArquivo extends Thread { redeNeural.PadroesTreinamento pt; manipulacaoArquivos.LeitorPadroes leitor; redeNeural.RedeNeural rna; redeNeural.TreinaRede treinador; Progresso jp; Principal principal; boolean compativel = false; public LeArquivo(Principal pr, redeNeural.RedeN eural r, redeNeural.TreinaRede tr, Progresso janela, String nomeArquivo) { leitor = new manipulacaoArquivos.LeitorPadr oes(nomeArquivo); rna = r; treinador = tr; jp = janela; principal = pr; } public void run() { try { principal.desabilitaTreinar(); jp.getBarraProgresso().setStringPainted (true); pt = leitor.lerDadosTreinamento(jp.getB arraProgresso()); if(pt.getPadroesEntrada()[0].length == rna.getNosEntrada()) { if(pt.getPadroesSaida()[0].length = = rna.getNosSaida()) { treinador.setPadroesTreinamento (pt); compativel = true; jp.setMensagem("Arquivo lido co m sucesso"); jp.setRotuloBotao("Fechar"); } } if(!compativel) { jp.setMensagem("Erro na leitura do arquivo"); jp.setRotuloBotao("Fechar"); javax.swing.JOptionPane.showMessage Dialog(null, "Arquivo de padrões incompatível com a rede configurada. ", "Av iso de Erro!", javax.swing.JOptionPane.ERROR_MESSAGE); } else { principal.completaLeitura(); } } catch (Exception e) { javax.swing.JOptionPane.showMessageDial og(null, "Erro na leitura do arquivo: " + e.getMessage(), "Aviso de E rro!", javax.swing.JOptionPane.ERROR_MESSAGE); } } }

redes neurais artificiais aplicadas na construção de ... joão carlos testi ferreira júnior...

Documents