Área de inteligência artificial por marlos roberto de ...siaibib01.univali.br/pdf/marlos roberto...

UNIVERSIDADE DO VALE DO ITAJAÍ CENTRO DE CIÊNCIAS TECNOLÓGICAS DA TERRA E DO MAR

CURSO DE CIÊNCIA DA COMPUTAÇÃO

REDE NEURAL ARTIFICIAL PARA O DESLOCAMENTO DE UM ROBÔ AUTÔNOMO

Área de Inteligência Artificial

por

Marlos Roberto de Souza Filho

Rudimar Luiz Scaranto Dazzi, Dr. Orientador

Itajaí (SC), novembro de 2009

UNIVERSIDADE DO VALE DO ITAJAÍ CENTRO DE CIÊNCIAS TECNOLÓGICAS DA TERRA E DO MAR

CURSO DE CIÊNCIA DA COMPUTAÇÃO

REDE NEURAL ARTIFICIAL PARA O DESLOCAMENTO DE UM ROBÔ AUTÔNOMO

Área de Inteligência Artificial

por

Marlos Roberto de Souza Filho Relatório apresentado à Banca Examinadora do Trabalho de Conclusão do Curso de Ciência da Computação para análise e aprovação. Orientador: Rudimar Luiz Scaranto Dazzi, Dr.

Itajaí (SC), novembro de 2009

ii

"A luta pela verdade deve ter precedência sobre todas as outras." Albert Einstein

"Possuímos em nós mesmos, pelo pensamento e a vontade, um poder de ação que se estende muito além dos limites de nossa esfera corpórea."

Allan Kardec

"A compaixão para com os animais é das mais nobres virtudes da natureza humana." Charles Darwin

"Embora ninguém possa voltar atrás e fazer um novo começo, qualquer um pode começar agora e fazer um novo fim."

Francisco Cândido Xavier

“Há mais ventura em dar, que em receber.” Jesus Cristo

"Não me sinto obrigado a acreditar que o mesmo Deus que nos dotou de sentidos, razão e intelecto, pretenda que não os utilizemos."

Galileu Galilei

"A liberdade não é somente um direito que se reclama para si próprio: ela é também um dever que se assume em relação aos outros."

João Paulo II

"Todos gostamos de belas palavras, porém poucos de nós as transformam em atos." Sun Tzu

"Nossas dúvidas são traidoras e nos fazem perder o bem que, com freqüência, poderíamos ganhar, por simples medo de arriscar."

William Shakespeare

"Não é o destino que importa, mas sim a viagem." Autor Desconhecido

"Faça o bem a todas as criaturas em todos os locais da Terra, faça sem esperar nada em troca." Autor Desconhecido

iii

DEDICATÓRIA

A Deus. Aos Bons Espíritos.

Aos meus amados pais (Claudete e Enoir) por toda educação, carinho e amor que sempre me deram,

e ao meu amado irmãozinho (Christian) pelo carinho.

iv

AGRADECIMENTOS

A Deus, por tudo; Aos Bons Espíritos, pelo auxílio; A minha amada mãe Claudete, que sempre reza e torce por mim; Ao meu amado pai Enoir, que sempre acreditou em mim; Ao meu amado irmãozinho Christian, pelo enorme carinho e companheirismo; A minha família que sempre me apoiou e incentivou muito e por ser a minha maior fonte de referência; Ao meu amigo Nilson Debatin, pelo interesse e auxílio nos testes do ambiente de simulação Khepera e no desenvolvimento do código construído em linguagem C utilizado no software de testes da RNA; Ao meu amigo Ricardo Erick Rebelo, pela ajuda no desenvolvimento do código na linguagem C utilizado no software de testes da RNA; Ao meu amigo Fábio Coelho, pelo apoio e ajuda na fase de implementação do ambiente virtual desenvolvido em Java, construído sobre o software Simbad 3D. Ao meu amigo Emerson Del Sent pelo auxílio no desenvolvimento do abstract deste projeto; Ao meu orientador, professor Rudimar, pelo conhecimento passado, pelo incentivo, pela confiança e principalmente pela paciência; À Banca Examinadora, pelas sugestões e críticas que auxiliaram na elaboração final de um documento maduro e consistente em relação à natureza do projeto; Enfim, a todos que direta ou indiretamente auxiliaram na execução desse projeto.

v

SOUZA FILHO, Marlos Roberto de. Rede Neural Artificial para o deslocamento de um Robô

Autônomo. 2009. 210 f. Trabalho de Conclusão de Curso (Bacharel) - Curso de Ciência da

Computação, Univali, Itajaí, 2009.

vi

SUMÁRIO

LISTA DE ABREVIATURAS ................................................................. ix

LISTA DE FIGURAS ................................................................................ x

LISTA DE TABELAS ............................................................................ xiii RESULMO............................................................................................... xiv

ABSTRACT .............................................................................................. xv

1 Introdução .............................................................................................. 1 1.1 INTELIGÊNCIA E AUTONOMIA................................................................... 1 1.2 NAVEGAÇÃO AUTÔNOMA DE ROBÔS E APRENDIZAGEM................ 2 1.3 ABORDAGENS PARA SISTEMAS AUTÔNOMOS INTELIGENTES ...... 4 1.4 PROBLEMATIZAÇÃO ..................................................................................... 7 1.4.1 Formulação do Problema ................................................................................. 7 1.4.2 Solução Proposta ............................................................................................... 8 1.5 OBJETIVOS ........................................................................................................ 8 1.5.1 Objetivo Geral ................................................................................................... 8 1.5.2 Objetivos Específicos ........................................................................................ 8 1.6 METODOLOGIA................................................................................................ 9 1.7 ESTRUTURA DO TRABALHO...................................................................... 10

2 Fundamentação Teórica ..................................................................... 11 2.1 ROBÔS ............................................................................................................... 11 2.1.1 Breve histórico dos robôs móveis................................................................... 11 2.1.2 Definições de robôs móveis............................................................................. 13 2.1.3 Robôs Inteligentes ........................................................................................... 13 2.2 INTELIGÊNCIA ARTIFICIAL ...................................................................... 13 2.3 REDES NEURAIS ARTIFICIAIS................................................................... 14 2.3.1 Neurônios Artificiais: Modelo MCP.............................................................. 15 2.3.2 Função de Ativação......................................................................................... 16 2.3.3 Topologias de Redes Neurais Artificiais ....................................................... 16 2.3.4 Principais Arquiteturas de Redes Neurais Artificiais ................................. 17 2.3.5 Aprendizado..................................................................................................... 19 2.3.5.1 Aprendizado Supervisionado ......................................................................... 20 2.3.5.2 Aprendizado Não-supervisionado .................................................................. 21 2.3.5.3 O Algoritmo Backpropagation ....................................................................... 21 2.4 SENSORES ........................................................................................................ 25 2.5 ATUADORES .................................................................................................... 26 2.6 CONTROLADORES ........................................................................................ 27 2.7 FERRAMENTAS PARA CRIAÇÃO DE RNAS ........................................... 28 2.7.1 Java Object Oriented Neural Engine – Joone.............................................. 28

vii

2.7.2 Stuttgart Neural Network Simulator – SNNS.............................................. 29 2.7.3 Java Neural Network Simulator – JavaNNS................................................ 31 2.8 SIMULADORES DE ROBÔS.......................................................................... 33 2.8.1 Robocode.......................................................................................................... 33 2.8.2 Khepera Simulator.......................................................................................... 36 2.8.3 Simbad 3D........................................................................................................ 38 2.9 FERRAMENTAS SIMILARES....................................................................... 40 2.9.1 Utilizando RNAs no Controle de Robôs Moveis Aplicados ao Combate de Incêndios Florestais ................................................................................................... 40 2.9.2 Estacionamento de um Veículo de Forma Autônoma Utilizando RNAs... 41 2.9.3 Dirigibilidade de Mini-Robôs com RNAs: Uma Experiência Acadêmica . 41

3 Projeto................................................................................................... 42 3.1 METODOLOGIA.............................................................................................. 44 3.2 REQUISITOS FUNCIONAIS.......................................................................... 46 3.3 REQUISITOS NÃO FUNCIONAIS................................................................ 46 3.4 REGRAS DE DECISÃO DA REDE NEURAL ARTIFICIAL..................... 47 3.5 FUNCIONAMENTO DA RNA E DO VEÍCULO.......................................... 49

4 Implementação..................................................................................... 53 4.1 DEFINIÇÃO DO AMBIENTE DE MANIPULAÇÃO DA RNA ................. 53 4.1.1 Criação dos Arquivos de Padrões.................................................................. 55 4.1.2 Instalação e Detalhamento da Ferramenta JavaNNS ................................. 56 4.1.2.1 Criando a Rede Neural Artificial.................................................................... 56 4.1.2.2 Manipulando a Rede Neural Artificial ........................................................... 59 4.1.3 As Redes Neurais Artificiais Criadas no JavaNNS...................................... 61 4.1.3.1 Primeira RNA apresentada – GSC200901-A................................................. 62 4.1.3.2 Segunda RNA Apresentada – GSC200901-B................................................ 64 4.1.3.3 Terceira RNA Apresentada – GSC200901-C ................................................ 66 4.1.3.4 Quarta RNA Apresentada – GSC200901-D................................................... 70 4.1.4 Convertendo o Arquivo da RNA para a Linguagem C............................... 72 4.1.5 Analisando o Arquivo de Resultado da RNA............................................... 74 4.1.6 Comparando as RNAs apresentadas............................................................. 76 4.1.7 Utilizando a RNA em um aplicativo.............................................................. 77 4.2 DYNAMIC LINK LIBRARY – DLL. ............................................................. 80 4.2.1 Verificando o cabeçalho das DLLs criadas .................................................. 80 4.2.2 Validando as DLLs desenvolvidas................................................................. 81 4.3 DEFINIÇÃO DO AMBIENTE DE SIMULAÇÃO DO ROBÔ.................... 82 4.3.1 A Biblioteca JNA............................................................................................. 83 4.3.2 Criação dos Mundos Virtuais e dos Robôs Virtuais.................................... 85 4.3.3 Chamada e Utilização da Biblioteca RNA.................................................... 87

5 Resultados............................................................................................. 89

6 Dificuldades .......................................................................................... 92

viii

7 Conclusão.............................................................................................. 93 7.1 PROJETOS FUTUROS. ................................................................................... 93

Referências Bibliográficas....................................................................... 95

A Trabalhando com DLLs...................................................................... 99

B Criando a DLL Utilizando o C++ Borland 2010 ............................ 103

C Criando a DLL Utilizando o Dev C++ 4.......................................... 108

D Carregando uma DLL Estáticamente ............................................. 112

E Carregando uma DLL Dinâmicamente........................................... 115

F RNA gerada pelo Ambiente JavaNNS............................................. 119

G Arquivo de Treinamento da RNA.................................................... 121

H Arquivo de Validação da RNA......................................................... 142

I Arquivo de Resultado da RNA - Validação .................................... 147

J Código Fonte do Aplicativo Validador da RNA............................. 169

K Planilha com os Padrões de Entrada e Saída.................................. 174

L Código Fonte do Arquivo PDRNA.DLL ......................................... 179

M Código Fonte do Mundo MarlosObstaculo..................................... 190

N Código Fonte do Mundo MarlosLaberinto..................................... 191

O Alterações para Adaptar o Robô à RNA......................................... 193

ix

LISTA DE ABREVIATURAS

BP Backpropagation CA Corrente Alternada CC Corrente Contínua DLL Dynamic Link Library GSC Graduation in Science of the Computation GNU GNU is Not Unix GPL General Public Licence IPVR Institute for Parallel and Distributed High Performance Systems IA Inteligência Artificial JavaNNS Java Neural Network Simulator JNA Java Native Access JNI Java Native Interface JOONE Java Object Oriented Neural Engine MLP Multilayer Perceptron Quickprop Quickpropagation PRNA Projeto Rede Neural Artificial PDRNA Projeto Dev Rede Neural Artificial RBF Generalized Radial Basis functions RCS Revision Control System RProp Resilient Backpropagation RNA Rede Neural Artificial SNA Sistema de Navegação Autônoma SNNS Stuttgart Neural Network Simulator TCC Trabalho de Conclusão de Curso TDNN time-delay neural networks WSI Wilhelm-Schickard-Institute for Computer Science UNIVALI Universidade do Vale do Itajaí VSC Valor do Sensor Central VSD Valor do Sensor Direito VSE Valor do Sensor Esquerdo X11R4 X Window System - Version 11 release 4 of the X protocol X11R5 X Window System - Version 11 release 5 of the X protocol XGUI X Graphical User Interface

x

LISTA DE FIGURAS

Figura 1. Shakey, Kephera e Sojourmer. ...........................................................................................12 Figura 2. Neurônio de McCulloch e Pitts...........................................................................................16 Figura 3. Feedforward de uma camada. .............................................................................................18 Figura 4. Feedforward de duas camadas. ...........................................................................................18 Figura 5. Recorrência entre saída e intermediária..............................................................................18 Figura 6. Recorrência auto-associativa. .............................................................................................18 Figura 7. Aprendizado supervisionado ..............................................................................................20 Figura 8. Aprendizado não-supervisionado .......................................................................................21 Figura 9. Esquema de funcionamento do Algoritmo Backpropagation. ............................................23 Figura 10. Exemplo de uma superfície de erro para um treinamento usando backpropagation. .......24 Figura 11. Tipos de funções de ativação mais utilizados...................................................................25 Figura 12. Ambiente do Java Object Neural Engine – Joone. ...........................................................28 Figura 13. Ambiente do Stuttgart Neural Network Simulator – SNNS.............................................31 Figura 14. Ambiente do Java Neural Network Simulator – JavaNNS...............................................32 Figura 15. Anatomia de um robô no simulador Robocode. ...............................................................33 Figura 16. Interface do ambiente de simulação do Robocode. ..........................................................35 Figura 17. Interface do ambiente de simulação do Khepera. .............................................................36 Figura 18. Interface do ambiente de simulação do Webots 6. ...........................................................37 Figura 19. Interface do ambiente de simulação Simbad 3D. .............................................................39 Figura 20. Exemplo de uma RNA da arquitetura MLP. ....................................................................42 Figura 21. Sensores do Veículo Móvel. .............................................................................................43 Figura 22. Direções do Veículo Móvel ..............................................................................................43 Figura 23. Exemplo de dados que obedece ao conjunto de regras apresentadas ...............................48 Figura 24. Layout explicativo quanto ao funcionamento do veículo.................................................49 Figura 25. Primeira seqüência de valores para análise. .....................................................................50 Figura 26. Segunda seqüência de valores para análise. .....................................................................50 Figura 27. Terceira seqüência de valores para análise. ......................................................................51 Figura 28. Quarta seqüência de valores para análise. ........................................................................52 Figura 29. Quinta seqüência de valores para análise. ........................................................................52 Figura 30. Layout oficial do arquivo de padrões do JavaNNS e SNNS. ...........................................55 Figura 31. Layout de padrões de arquivo simples aceito pelo JavaNNS e SNNS. ............................55 Figura 32. Criando camadas para a RNA no JavaNNS. ....................................................................57 Figura 33. Caixa de dialogo para a criação das camadas. ..................................................................58 Figura 34. Criando conexões entre as camadas de neurônios. ...........................................................58 Figura 35. Caixa de definição quanto ao tipo de conexões a serem criadas. .....................................59 Figura 36. RNA criada no ambiente JavaNNS. .................................................................................59 Figura 37. Abrindo o Painel de Controle. ..........................................................................................60 Figura 38. Painel de Controle do JavaNNS. ......................................................................................61 Figura 39. RNA GSC200901-A Treinada..........................................................................................63 Figura 40. Arquivo log de Treinamento e Validação da RNA GSC200901-A. ................................63 Figura 41. Gráfico de erro (∑e2) e validação da RNA GSC200901-A. .............................................64 Figura 42. RNA GSC200901-B Treinada. .........................................................................................65 Figura 43. Arquivo log de Treinamento e Validação da RNA GSC200901-B..................................66 Figura 44. Gráfico de erro (∑e2) e validação da RNA GSC200901-B. .............................................66 Figura 45. RNA GSC200901-C Treinada. .........................................................................................67 Figura 46. Arquivo log de Treinamento e Validação da RNA GSC200901-C..................................68

xi

Figura 47. Gráfico de erro (∑e2) e validação da RNA GSC200901-C. .............................................69 Figura 48. RNA GSC200901-D Treinada..........................................................................................71 Figura 49. Arquivo log de Treinamento e Validação da RNA GSC200901-D. ................................71 Figura 50. Gráfico de erro (∑e2) e validação da RNA GSC200901-D..............................................72 Figura 51. Convertendo a Rede para a Linguagem C com o snns2c.exe...........................................72 Figura 52. Comando de utilização do snns2c.exe. .............................................................................73 Figura 53. Trecho do arquivo de rede gerado pelo JavaNNS. ...........................................................74 Figura 54. Trecho do arquivo em linguagem C gerado pelo snns2c.exe. ..........................................74 Figura 55. Comando de utilização do analyse. ..................................................................................74 Figura 56. Trecho do Arquivo de Resultados da RNA GSC200901-B. ............................................75 Figura 57. Utilização do aplicativo analyzer......................................................................................76 Figura 58. Trecho do código em linguagem C referente ao programa principal. ..............................78 Figura 59. Formato do arquivo de entrada. ........................................................................................78 Figura 60. Formato do arquivo de saída.............................................................................................78 Figura 61. Visualização das funções contidas no arquivo PRNA.DLL. ............................................81 Figura 62. Visualização das funções contidas no arquivo PDRNA.DLL. .........................................81 Figura 63. Exemplo de definição de uma interface utilizando JNA. .................................................84 Figura 64. Exemplo de chamada de interface utilizando JNA...........................................................84 Figura 65. Código do arquivo interfacePrna.java. .............................................................................84 Figura 66. Chamada detalhada da interface interfacePrna.................................................................85 Figura 67. Invocando a função rede() através da interface “neural”..................................................85 Figura 68. Mundo virtual MarlosObstaculos. ....................................................................................86 Figura 69. Mundo virtual MarlosLaberinto. ......................................................................................86 Figura 70. Robô Virtual Simulado. ....................................................................................................87 Figura 71. Importação do pacote JNA para utilização no ambiente virtual. ......................................87 Figura 72. Posição Inicial do Robô. ...................................................................................................90 Figura 73. Trajetória e posição Final do Robô...................................................................................90 Figura 74. Posição Inicial do Robô. ...................................................................................................91 Figura 75. Trajetória e posição Final do Robô...................................................................................91 Figura 76. Uma visão didática do conteúdo interno de uma dll.......................................................100 Figura 77. Vários programas em execução usando a mesma dll simultaneamente. ........................101 Figura 78. Chamando uma dll escrita em C++ através de várias linguagens. .................................101 Figura 79. Chamando uma dll dinamicamente em C++. .................................................................102 Figura 80. Caixa de diálogo Other, para escolher o que se deseja criar. .........................................104 Figura 81. Janela New Dynamic-link Library. .................................................................................104 Figura 82. Código fonte gerado automaticamente para começar o desenvolvimento de uma dll....105 Figura 83. Pasta contendo todos os arquivos gerados após a compilação do projeto. .....................105 Figura 84. Sintaxe para declaração de funções que poderão ser exportadas para fora da dll. .........106 Figura 85. Caixa de diálogo New Project. .......................................................................................108 Figura 86. Caixa de Diálogo New DLL Project. ..............................................................................109 Figura 87. Conteúdo alterado do arquivo PDRNA.dev. ..................................................................110 Figura 88. Código contido no arquivo PDRNA.H...........................................................................110 Figura 89. Pasta contendo todos os arquivos gerados após a compilação do projeto. .....................111 Figura 90. Fluxo genérico de carregamento estático de uma dll......................................................112 Figura 91. Código inserido no envento OnClick do objeto Button1................................................113 Figura 92. Declaração da função a ser importada estaticamente da dll: ..........................................113 Figura 93. Posição onde deve ser inserida a instrução contida na Figura 93...................................114 Figura 94. Declaração de um ponteiro para uma função. ................................................................115 Figura 95. Declarando um ponteiro para uma função com parâmetros. ..........................................116

xii

Figura 96. Fluxo genérico de carregamento dinâmico de uma DLL................................................117

xiii

LISTA DE TABELAS

Tabela 1. Principais comandos do robô. ............................................................................................34 Tabela 2. Principais eventos utilizados pelo robô. .............................................................................34 Tabela 3. Principais funções utilizadas para a obtenção de informações...........................................35 Tabela 4. Principais funções disponibilizadas pelo Simbad 3D. .......................................................40 Tabela 5. Regras de decisão da Rede Neural Artificial. ....................................................................48 Tabela 6. Análise e Pontuação dos Ambientes de Criação de RNAs. ...............................................54 Tabela 7. Resultados obtidos pelo Analyzer quanto ao Treinamento da RNA. .................................76 Tabela 8. Resultados obtidos pelo Analyzer quanto a Validação da RNA. .......................................76 Tabela 9. Análise e Pontuação dos Ambientes de Virtualização de Robôs. ......................................83 Tabela 10. Comandos que devem ser inseridos na construção de funções para dll. ........................106 Tabela 11. Tipos redefinidos............................................................................................................107 Tabela 12. Ponteiro para Funções. ...................................................................................................115 Tabela 13. Ponteiros para Variáveis.................................................................................................116 Tabela 14. Protótipos de Funções. ...................................................................................................116 Tabela 15. Declaração de Ponteiro para Função. .............................................................................116 Tabela 16. Sintax e Descrição da Função LoadLibrary(). ...............................................................117 Tabela 17. Sintax e Descrição da Função FreeLibrary()..................................................................118 Tabela 18. Sintax e Descrição da Função GetProcAddress()...........................................................118

xiv

RESULMO

SOUZA FILHO, Marlos Roberto de. Rede Neural Artificial para o Deslocamento de um Robô Autônomo. Itajaí, 2009. 210 f. Trabalho de Conclusão de Curso (Graduação em Ciência da Computação)–Centro de Ciências Tecnológicas da Terra e do Mar, Universidade do Vale do Itajaí, Itajaí, 2009. A crescente necessidade de desenvolvimento de mecanismos capazes de auxiliar o ser humano, e o desejo de criar sistemas capazes de substituir o homem em tarefas consideradas inadequadas ou que representem risco à sobrevivência do mesmo, aliadas ao crescente avanço de ciências aplicadas como a Robótica e a Inteligência Artificial (IA), criaram um ambiente propício ao desenvolvimento de robôs que sejam, até certo ponto, autônomos o suficiente para executarem tarefas tipicamente humanas. O deslocamento autônomo ainda é o maior obstáculo enfrentado pela IA, todavia essa dificuldade tem sido superada, com certo grau de sucesso, por aquela que é uma das técnicas mais antigas de IA, as Redes Neurais Artificiais (RNA). Esse projeto teve como objetivo o desenvolvimento de uma RNA capaz de propiciar a um robô o deslocamento necessário ao mesmo, tornando-o capaz de se deslocar de forma autônoma através de um ambiente terrestre plano. Para tal finalidade, foi utilizada uma RNA feedforward, treinada através do algoritmo backpropagation. Para o desenvolvimento da RNA foram analisados e documentados seis (6) ambientes de desenvolvimento de redes neurais, além de aplicativos utilizados para analisar arquivos de resultado e para converter os arquivos de arquitetura de RNA para arquivos fonte em linguagem C. Após os arquivos de arquitetura terem sido convertidos para arquivos fonte em linguagem C, esses arquivos fontes foram utilizados para a criação de um aplicativo capaz de ler um arquivo de padrões de entrada, analisá-los utilizando o código fonte da RNA e gerar um arquivo de padrões de saída com a resposta da RNA. Foram ainda desenvolvidas bibliotecas de ligação dinâmicas (BLD) utilizando os arquivos fonte da RNA, detalhes quanto às bibliotecas de ligação dinâmica, sua criação e utilização estão documentadas em detalhes. A biblioteca JNA foi utilizada para realizar a ligação entre a biblioteca de ligação dinâmica e o ambiente de simulação de robôs, sua utilização e funcionamento estão documentados em detalhes. Para a simulação do robô utilizando a rede neural artificial desenvolvida foram analisados e documentados seis (6) ambientes de simulação de robôs. Por fim, apresentam-se os resultados obtidos, as dificuldades encontradas e sugestões para novos projetos. Na seção de Apêndices encontram-se além de informações adicionais do projeto, dados utilizados no treinamento e na validação da RNA, além de alguns códigos fonte completos, em linguagem C e java. Palavras-chave: Redes Neurais Artificiais. RNA. Robótica. Robôs. Backpropagation. Inteligência Artificial. IA. Dynamic-link library. DLL. Biblioteca de ligação dinâmica. Java Native Access. JNA. Simbad 3D.

xv

ABSTRACT

Nowadays there has been an increasing necessity of developing mechanisms in order to help people to accomplish several tasks, as well as the wish to create systems effective enough to replace people regarding risky and harmful activities. Furthermore, applied sciences - such as Robotics an Artificial Intelligence (AI) - have advanced in such a way that there are now the ideal conditions to project robots which, until a certain point, would be independent enough to carry on with typical human work. Autonomous moving is still the greatest obstacle to be overcome by AI, however this challenge has been faced, successfully so to speak, by the AI technique is the oldest among all: the Artificial Neural Networks (ANN). The aim of this project is develop an ANN able to give any robot adaptative motion skills, allowing it to go anywhere, plan, in earthly environment. For this ANN development, (6) neural networks development enviroments have been analyzed and documented, besides applicatives commonly used to analyze result files and to convert ANN architeture files into source files in C language. After such a conversion these source files have been used to create an applicative able to read an entry patterns file, analyze them using the ANN source code and generate an exit patterns file along the ANN response. Dynamic Link Libraries (DLL) have been developed using the ANN source files. Details from the BLD – their creation and utilization have been documented in detail. The JNA libray has been used to link the DLL and the robots simulation enviroment, also reported in detail. For the simulation of the robot with the artificial neural network developed, (6) robot simulations enviroments have been analyzed and documented. Finally, the results obtained, the challenges faced and suggestions for new projetcs are presented. In the appendix section data used in the ANN training and validation, besides additional informations of the project and full source codes in C and Java language. Keywords: Artificial Neural Networks. ANN. Robotics. Robots. Backpropagation. Artificial Intelligence. Dynamic-Link Library. DLL. Java Native Access. Simbad 3D.

1 INTRODUÇÃO

1.1 Inteligência e Autonomia

A evolução científica e tecnológica tem trazido inovações e descobertas cada vez mais

freqüentes e surpreendentes. No entanto, há áreas do conhecimento que sempre foram e ainda hoje

continuam sendo desafiadoras e intrigantes. É o caso da inteligência: o que a caracteriza, de que

forma e quando ela opera e como reproduzi-la artificialmente (CAZANGI, 2004)?

Considerando a possibilidade de graduar a manifestação de inteligência em vários níveis e

escalas, a natureza é fonte inesgotável de mecanismos, comportamentos e organismos que podem

ser considerados inteligentes. Dos seres extremamente simples aos mais complexos há vestígios de

inteligência, seja em indivíduos isolados ou então no comportamento coletivo de um grupo de

indivíduos. São estes aspectos que atraem a atenção de pesquisadores das mais diversas áreas, como

biologia, psicologia e engenharia da computação, na busca pela compreensão e reprodução artificial

dos sistemas biológicos que expressam algum grau de inteligência (CAZANGI, 2004).

Não é possível estudar a inteligência de forma isolada, dado que ela interligada a outras

propriedades presentes nos organismos biológicos. Uma das principais propriedades diretamente

conectadas à existência de inteligência é a autonomia. Um agente artificial não autônomo não

possui capacidade de inteligência própria. Na verdade, ele incorpora aspectos de inteligência

especificados por quem o projetou. Sistemas biológicos são em geral autônomos, isto é, suas

estruturas não são impostas por agentes externos, mais sim desenvolvidas e mantidas por eles

próprios por meio de mecanismos como auto-organização, evolução, adaptação e aprendizagem.

Considera-se, portanto, que a manifestação de algum grau de inteligência pode ser vista como um

atributo de agentes autônomos (Steels, 1995 apud CAZANGI, 2004).

Dizer que um agente é autônomo implica em afirmar que ele, além de agir por si só,

consegue se auto-regular gerando as próprias regras que regem sua atuação. Esta definição distingue

autônomo de automático. Ser automático é ser capaz de atuar em um ambiente: percebê-lo e

impactá-lo visando o cumprimento de tarefas definidas. Um agente autônomo é antes de tudo

automático, mas vai além disso: ele deve se autodirigir com base na sua capacidade própria de

aprender e adaptar seus comportamentos. Além disso, os processos de aprendizagem e adaptação

devem ocorrer enquanto o agente está operando no ambiente, e não fora dele (por exemplo, em fase

de projeto) (CAZANGI, 2004).

2

Da mesma maneira adotada para o conceito de inteligência, é possível considerar a

existência de níveis de autonomia, até pelo fato de não existir um ser totalmente autônomo. Os

animais em geral, e o ser humano, em particular, dependem de fatores externos para sobreviverem.

Estes organismos dependem do ambiente em que vivem para obter alimento e oxigênio, por

exemplo. Logo, quando se afirma que um agente é autônomo, deve-se ter em mente que ele detém

certo nível de autonomia, e não que ele é completamente autônomo. Desta forma, é possível

comparar agentes em termos de autonomia, sendo que quanto mais autônomo for o agente, menos

auxílio externo ele necessita (CAZANGI, 2004).

Pfeifer & Sheier (1999 apud CAZANGI, 2004) afirmam que agentes autônomos artificiais

são ideais para se estudar os princípios da inteligência. Segundo eles, uma das motivações para o

emprego desses agentes envolve a idéia de emergência. Agentes autônomos apresentam

comportamentos chamados emergentes, ou seja, comportamentos que surgem pela interação do

agente com o ambiente sem que tenham sido programados a priori pelo projetista. Por exemplo,

processos de navegação autônoma envolvendo múltiplos robôs podem promover a emergência de

comportamentos organizados que não são expressos por nenhum destes robôs quando isolados dos

demais (CRESTANI, 2001 apud CAZANGI, 2004).

1.2 Navegação Autônoma de Robôs e Aprendizagem

A pesquisa de sistemas inteligentes por intermédio de agentes autônomos é classificada

como uma metodologia sintética, cuja idéia se resume em “construir para entender”. A abordagem

sintética consiste em criar sistemas artificiais que reproduzam aspectos dos sistemas naturais, de

modo a entender seus mecanismos internos e assim descobrir como e por que certos eventos

ocorrem. O outro paradigma de abordagem, conhecido como analítico, prega a realização de

experimentos em um sistema já existente (um ser humano, ou uma colônia de formigas, por

exemplo) para então analisar os resultados visando desenvolver um modelo que seja capaz de

prever os efeitos de experimentos futuros (PFEIFER & SHEIER, 1999 apud CAZANGI, 2004).

Um dos problemas de engenharia mais complexos, desafiadores e propícios à pesquisa de

sistemas autônomos inteligentes é a navegação autônoma de robôs. O problema consiste,

basicamente, em desenvolver mecanismos de tomada de decisão para um ou mais robôs móveis,

dispostos em um ambiente arbitrário junto ao qual devem atuar de forma autônoma, visando

cumprir certas tarefas. Muito embora a navegação de robôs possa ser descrita com base nesta breve

definição, existem muitos aspectos de projeto envolvidos: configurações do ambiente, modelo do

3

robô, elenco de tarefas e critérios de desempenho. Sendo assim, o desenvolvimento de critérios de

navegação autônomos envolve desafios extremamente complexos para o trabalho do projeto

(FIGUEIREDO, 1999 apud CAZANGI, 2004).

Devido à grande variedade de situações com que o robô pode se defrontar ao longo da

navegação, sendo algumas inéditas e não previsíveis (sobretudo em ambientes desconhecidos), o

desempenho de um sistema de navegação depende de sua capacidade de aprendizagem e adaptação.

Ou seja, somente aprimorando sai estratégia de navegação, por meio da incorporação de

conhecimento (adquirido por experimentação) e ajuste de parâmetros, um sistema de navegação

torna-se apto a guiar eficientemente o robô visando maximizar o atendimento dos objetivos de

navegação. Justamente devido à importância da aprendizagem, intensos esforços de pesquisa têm

sido dedicados ao aperfeiçoamento desta potencialidade em sistemas de navegação (FIGUEIREDO,

1999 apud CAZANGI, 2004). Já no tocante aos mecanismos de adaptação (ajuste de parâmetros),

mecanismos sofisticados e eficientes derivados da teoria de controle automático (KUO, 1991 apud

CAZANGI, 2004) podem ser prontamente empregados.

Um robô controlado por um sistema que possua capacidade de aprendizagem vai vivenciar

suas próprias experiências, adquirindo conhecimento ao longo do tempo e por meios próprios, não

pela imposição de um agente externo. Fica evidente, portanto, que um robô com capacidade de

aprendizado é potencialmente mais autônomo que outro incapaz de aprender. Um benefício da

aprendizagem pode ser observado na seguinte situação: supondo que o agente encontre as mesmas

circunstâncias pelas quais já passou antes, depois de uma fase de aprendizado ter ocorrido, seu

sistema pode reagir de forma diferente da anterior e, possivelmente, com melhores resultados. Fica

explícita então a relevância dos mecanismos de aprendizagem na construção de sistemas autônomos

inteligentes (CAZANGI, 2004).

Nolfi & Floreano (2000 apud CAZANGI, 2004)explicam que a aprendizagem de robôs

baseia-se na idéia de que um sistema de controle pode se tornar apto a atuar eficientemente diante

de novas situações, sustentando-se na sua capacidade de generalizar conhecimentos adquiridos

anteriormente, mesmo que estes sejam diversos e incompletos. Entretanto, generalização não e a

única propriedade de um sistema com aprendizagem, existem outras propriedades importantes.

Alguns atributos básicos relacionados a abordagens que contemplam aprendizagem são descritos a

seguir (PFEIFER & SHEIER, 1999 apud CAZANGI, 2004):

· O sistema deve ser robusto em relação a ruídos;

4

· Os mecanismos devem convergir rapidamente e têm que permitir a aprendizagem

durante a operação do sistema (on-line);

· A aprendizagem deve ser incremental e continuada;

· O processo de aprendizagem precisa ser computacionalmente tratável, isto é, deve

possibilitar sua execução em tempo real; e

· O aprendizado deve depender apenas de informações obtidas pelo próprio robô, por

meio de sua capacidade sensorial.

1.3 Abordagens para Sistemas Autônomos Inteligentes

A pesquisa em torno do desenvolvimento de sistemas autônomos inteligentes é intensa e

apresenta diversas abordagens. Algumas abordagens promissoras envolvem: sistemas dinâmicos,

economia comportamental e esquemas. Entretanto, a abordagem mais consolidada e amplamente

utilizada, particularmente em sistemas de navegação autônomos (como são denotados os sistemas

autônomos inteligentes dedicados ao problema de navegação de robôs) é a Inteligência Artificial

(CAZANGI, 2004).

A Inteligência Artificial pode ser dividida em duas partes: a IA clássica (tradicional) e a

inteligência computacional. A IA clássica reúne técnicas baseadas em lógica proposicional e na

manipulação algorítmica de estruturas simbólicas. Já a inteligência computacional, a qual engloba

redes neurais artificiais, computação evolutiva, sistemas nebulosos e, mais recentemente, outros

mecanismos de computação bio-inspirada, se caracteriza pela síntese de estruturas flexíveis para

armazenagem e fluxo de informação, podendo apresentar processamento distribuído, controle

descentralizado, auto-organização, não-linearidade, além de recorrer a uma grande variedade de

mecanismos de inferência e buscas em espaços de atributos (DE CASTRO & YON ZUBEN, 2004

apud CAZANGI, 2004).

Existe um consenso em grande parte da comunidade de pesquisa em sistemas inteligentes de

que as técnicas clássicas de IA falham em alguns aspectos relativos à aprendizagem e interação com

o ambiente. A maioria desses aspectos tem sido bastante discutida na literatura (CAZANGI, 2004).

Note que, neste projeto, quando se fala em sistemas de IA clássica , refere-se a sistemas

puramente simbólicos. A principal razão para o problema encontrado na IA clássica é que os

5

sistemas nem sempre levam suficientemente em consideração as características do mundo real.

Muitos trabalhos de IA clássica têm sido dedicados a espaços abstratos, virtuais, cujos espaços e

variações são precisamente definidos, o que, em geral, ocorre raramente no mundo real. Outras

deficiências estão relacionadas à organização hierárquica, processamento centralizado e

direcionamento a tarefas bastante específicas (PFEIFER & SHEIER apud CAZANGI, 2004).

Steells (1995 apud CAZANGI, 2004) vai ainda mais longe, afirmando que sistemas

construídos com base na IA clássica não são autônomos, embora sejam automáticos. A afirmação se

justifica pelo fato do conhecimento presente neste sistema ser geralmente fornecido por

especialistas e embutido de forma explícita. Neste sentido, o sistema não tem seus próprios

objetivos e motivações, tem apenas os de seus criadores (CAZANGI, 2004).

Todos estes aspectos conceituais da IA clássica se refletem na ausência ou deficiência da

capacidade de aprendizagem pelos sistemas que a utilizam, o que, conseqüentemente, implica em

uma redução drástica de sua autonomia. Por isso, críticas têm sido feitas a propostas de sistemas de

navegação incapazes de aprender suas estratégias a partir da interação com o ambiente, visto que

seus desempenhos estão limitados ao conhecimento neles implantado a priori. Supondo que o robô

se depare com situações que não estejam previstas pelo sistema de navegação implementado, é

provável que seu desempenho sofra degradações significativas e recorrentes frente à repetição do

mesmo cenário. Apesar dos problemas, vale ressaltar que existem muitas aplicações bem sucedidas

das técnicas de IA em outros tipos de problemas. (CAZANGI, 2004).

Propostas de sistema de navegação baseadas em técnicas de inteligência computacional têm

apresentado resultados promissores, sobretudo devido a elas possuírem características essenciais à

concepção de sistemas autônomos inteligentes. Estas técnicas contemplam as seguintes

propriedades:

· O emprego de mecanismos de aprendizado na aquisição de conhecimento e

adaptação de comportamento a partir da interação com o ambiente;

· A capacidade de encontrar soluções factíveis, que atendam simultaneamente a

múltiplos objetivos, possivelmente conflitantes, utilizando o conhecimento

adquirido; e

6

· A habilidade para operar em condições adversas, tais como: ausência de um conjunto

de informações completo para um planejamento prévio de seu comportamento,

imprevisibilidade na interação com seu ambiente (suposto ser de topologia

desconhecida) e ruído nos sensores e atuadores (CRESTANI, 2001 apud CAZANGI,

2004).

Dentre as técnicas de inteligência computacional, as redes neurais artificiais, cuja inspiração

vem do sistema nervoso dos organismos superiores, especificamente do cérebro dos mamíferos, têm

um papel muito relevante junto a sistemas de navegação autônomos. As redes neurais artificiais se

mostram muito eficazes na síntese de arquitetura de controle em navegação de robôs, por

apresentarem um grande poder de representação de conhecimento e por serem excelentes modelos

de aprendizagem e generalização. A seguir, são descritos alguns sistemas de navegação autônomos

(SNAs) fundamentados em redes neurais artificiais. Figueiredo (1997 apud CAZANGI, 2004)

apresenta uma proposta inovadora e eficaz com base em técnicas avançadas de redes neurais

artificiais e sistemas nebulosos, capazes de realizar processamento híbrido, com etapas de natureza

numérica e simbólica. A arquitetura do sistema é hierárquica e dividida em três módulos principais:

dois devotados a tomada de decisão e um terceiro a coordenação. Em Crestani (2001 apud

CAZANGI, 2004), procedi-se à extensão do trabalho de Figueiredo (1997 apud CAZANGI, 2004),

mantendo a arquitetura básica e incluindo extensões como novas formas de operação interna dos

módulos da rede, etapas mais elaboradas de coordenação e aprendizado, além de controle de

velocidade. Mais recentemente, Haydu (2003 apud CAZANGI, 2004) implementa um SNA baseado

em uma rede neural multicamadas, com diferentes tipos de conexões sinápticas e que realiza

aprendizagem por reforço (CAZANGI, 2004).

Outra ferramenta de inteligência computacional são os sistemas imunológicos artificiais. A

idéia é ter uma rede de anticorpos que reage à presença de antígenos, modificando a configuração

da rede e tomando ações. Suas maiores virtudes são a capacidade de auto-organização e operação

distribuída, conferindo requisitos fundamentais para a síntese de processos cognitivos baseados em

comportamento dinâmico. Watanabe et al. (1999 apud CAZANGI, 2004) investiga um SNA

baseado nesta técnica, em que os anticorpos realizam reconhecimento de padrões e estão associados

a comportamentos básicos do robô e os antígenos carregam os estímulos capturados pelos sensores.

Aperfeiçoamentos do SNA de Watanabe el al. (1999 apud CAZANGI, 2004) são propostos em

Michelan (2003 apud CAZANGI, 2004), incluindo a aplicação de um mecanismo evolutivo para

determinação das conexões da rede imunológica (CAZANGI, 2004).

7

De fato, as técnicas de computação evolutiva merecem um grande destaque em navegação

autônoma, sendo a principal delas os algoritmos genéticos. Estas técnicas se inspiram basicamente

na teoria da evolução das espécies e comungam uma estrutura básica: realizam reprodução, impões

variações aleatórias, promovem competição e executam seleção de indivíduos de uma dada

população. Suas principais características são: grande robustez, diversidade e capacidade de busca

associada ao atendimento de objetivos específicos (CAZANGI, 2004).

A grande eficiência dos métodos evolutivos viabiliza seu emprego na proposição estrutural

de modelos, e não apenas em seu ajuste paramétrico, no desenvolvimento integral de sistemas de

controle e na concepção e operação de robôs autônomos. Esta última utilização, conhecida como

Robótica Evolucionária (NOLFI & FLOREANO, 2000 apud CAZANGI, 2004), é bastante

ambiciosa, embora não esteja ainda totalmente consolidada. Ela propõe que todos os módulos do

robô, desde seu sistema de controle até sua carcaça, sejam obtidos por métodos evolutivos

(CAZANGI, 2004).

Um quesito muito forte em prol dos sistemas evolutivos se refere à autonomia. Ao se

construir um sistema autônomo, seja robótico ou computacional, normalmente designa-se esta

atividade a engenheiros. Porém, a própria evolução pode assumir o papel de projetista do sistema

(DAWKINS, 1998 apud CAZANGI, 2004), de forma eficiente. Além disso, agentes que possuam

características evolutivas podem, em princípio, ter seu nível de autonomia bastante incrementado. A

evolução torna o agente mais independente de seu projetista e, portanto, propicia a ele potencial

para ser mais autônomo que agentes cujos sistemas de controle não contemplam o evolucionismo

(PFEIFER & SHEIER, 1999 apud CAZANGI, 2004).

1.4 Problematização

1.4.1 Formulação do Problema

O desenvolvimento de sistemas de controle para robôs móveis autônomos tem se mostrado

um grande desafio para a Inteligência Artificial. Diferentes abordagens para o projeto de sistema de

controle para robôs móveis autônomos vêm sendo utilizadas em diversas áreas de pesquisa. Por

muitos anos os pesquisadores de Inteligência Artificial têm construído sistemas de controle que

apresentam um comportamento inteligente, mas normalmente não no mundo real e somente em

ambientes controlados. Alguns pesquisadores desenvolveram certos sistemas de controle para serem

8

utilizados no mundo real, mas geralmente estes sistemas são limitados e não apresentam um

comportamento autônomo ou inteligente (HEINEN, 2002).

A utilização de robôs móveis está diretamente associada ao grau de autonomia que os

mesmos apresentam, desta forma quanto maior a autonomia de um robô, maiores serão as

possibilidades de utilização deste na realização de diversos objetivos, ainda assim, resolver o

problema de deslocamento evitando obstáculos ainda é uma área de intensa pesquisa.

Várias técnicas são utilizadas com o intuito de resolver o problema, algumas mais

promissoras que outras, mas ainda nenhum robô completamente autônomo (capaz de se deslocar

sem a intervenção humana) foi criado.

1.4.2 Solução Proposta

Este Trabalho de Conclusão de Curso (TCC) propõe-se a modelar e implementar uma

solução em software capaz de auxiliar um veículo móvel a se deslocar em um ambiente plano de

forma autônoma, através da utilização da técnica de Inteligência Artificial denominada Redes

Neurais Artificiais (RNA).

1.5 Objetivos

1.5.1 Objetivo Geral

O objetivo geral deste projeto é desenvolver uma rede neural artificial para controlar o

deslocamento de um robô autônomo sobre uma superfície plana.

1.5.2 Objetivos Específicos

Os objetivos específicos deste projeto de pesquisa são:

· Pesquisar e analisar as técnicas de aprendizado de redes neurais disponíveis;

· Pesquisar e analisar os mecanismos de hardware disponíveis;

· Pesquisar e analisar soluções similares;

· Determinar os requisitos de software e hardware do sistema;

· Compreender a metodologia de desenvolvimento de RNAs;

9

· Compreender a metodologia de desenvolvimento de robôs inteligentes;

· Realizar a modelagem conceitual do sistema;

· Realizar a modelagem da RNA;

· Programar o sistema de RNA;

· Treinar o sistema RNA;

· Testar a utilidade/funcionamento do sistema RNA;

· Validar o funcionamento do sistema RNA; e

· Documentar o desenvolvimento e os resultados do sistema RNA.

1.6 Metodologia

Para a Fundamentação Teórica, pesquisas foram realizadas para compreender os princípios e

metodologias envolvidas no método de Inteligência Artificial denominado Redes Neurais

Artificiais, compreender os diversos tipos de RNAs existentes, suas características e métodos de

aprendizado. Foram pesquisadas ferramentas de simulação de ambientes para o treinamento de

robôs, suas características e seu nível de complexidade.

Também foram realizadas pesquisas referentes à robótica, mapeamento de ambientes e

projetos similares ao proposto, essas pesquisas foram realizadas através de livros, artigos

científicos, sites de instituições de pesquisa e de órgãos governamentais, alem de trabalhos

acadêmicos e documentários científicos. As características identificadas nas metodologias e

ferramentas foram analisadas para serem consideradas no desenvolvimento do projeto. Essa

pesquisa serviu ainda para refinar o projeto proposto tornando-o mais eficiente.

Procurou-se apresentar o que deve ser realizado de forma clara e objetiva em cada uma das

etapas. O desenvolvimento do projeto foi iniciado com uma análise de todos os requisitos que o

sistema deveria atender, alguns requisitos foram acrescentados após ser constatado sua ausência nos

projetos similares encontrados.

Depois de modelada, a RNA foi treinada e validade em um ambiente virtual, o qual simulará

o ambiente externo no qual o protótipo virtual deverá se deslocar.

10

1.7 Estrutura do trabalho

Este trabalho esta estruturado em quatro capítulos. O Capitulo 1, Introdução, apresentou

uma visão inicial sobre o tema abordado, a formulação do problema e a proposta para a solução do

mesmo.

No Capítulo 2, Fundamentação Teórica é apresentada um sucinto histórico sobre os robôs,

suas definições e o que se considera um robô inteligente. Apresentam-se ainda algumas definições

de Inteligência Artificial e definições importantes referentes a Redes Neurais Artificiais, como

modelo MCP, função de ativação, topologias, arquiteturas e aprendizado, alem de uma revisão

bibliográfica sobre Redes Neurais Artificiais. Finalizando esse capítulo, apresentam-se ainda

algumas ferramentas similares ao projeto aqui proposto.

No Capítulo 3, apresenta-se uma descrição do projeto proposto, sua arquitetura e modelo,

além do método de aprendizagem escolhido. Há também uma seção onde é detalhada a forma de

funcionamento da rede neural artificial, considerando seus padrões de entrada e seus respectivos

padrões de saída

No Capítulo 4 trata-se da implementação do projeto, a definição do ambiente de

manipulação da RNA, a criação dos arquivos de padrões, a criação das RNAs, sua conversão para

linguagem C, sua utilização em aplicativo e em bibliotecas de ligação dinâmica. Também é definido

o ambiente de simulação do robô virtual, sua integração com a biblioteca JNA e a construção dos

mundos virtuais.

O Capítulo 5 apresenta os resultados obtidos em cada fase do projeto, descrevendo de forma

sucinta e apresentando-os ordenadamente.

O Capítulo 6 apresenta as dificuldades encontras durante a realização deste projeto,

detalhando-as para uma melhor compreensão de sua complexidade.

O Capítulo 7 refere-se às conclusões finais quanto ao projeto em questão, considerando seus

resultados e suas dificuldades, e propõe projetos futuros baseados na experiência obtida com o

desenvolvimento deste.

Por fim, na seção de apêndices encontram informações adicionais referentes à elaboração

deste projeto.

2 FUNDAMENTAÇÃO TEÓRICA

2.1 Robôs

Desde tempos remotos, o homem sonha em poder criar um ser semelhante, esse desejo fica

evidente ao analisarmos os diversos exemplos de imagens humanizadas de criaturas, como as

descritas na obra de Homero, onde Hefesto, deus grego das forjas, possuía duas mulheres feitas em

ouro, capazes de realizar tarefas humanas (ASIMOV, 1994 apud VIEIRA, 1999, p. 10).

Jacques de Vaucanson, um mecânico Francês que viveu no século 18, se tornou célebre por

criar autômatos que tocavam música (GROOVER, WEISS, NAGEL et al, 1988).

A história da robótica se confunde com a história da literatura de ficção científica, de onde

inclusive se tirou seu próprio nome. Em 1921, apesar de já existirem aplicações de sistemas que

reproduziam ações de humanos, em certos aspectos menos sofisticados e extremamente

especializados se comparadas aos dias de hoje, o teatrólogo tcheco Karel Capek, na sua peça “Os

Robôs Universais de Rossum” utilizou pela primeira vez o termo robô (que em eslovaco significa

trabalhador), para identificar homens artificialmente fabricados pela sua personagem principal para

executar todas as tarefas árduas do mundo (ASIMOV, 1994; GROOVER,WEISS, NAGEL et al,

1988).

Para David Nitzan (NITZAN, 1985 apud VIEIRA, 1999, p. 10) “Um robô é uma máquina de

uso geral que, como um humano, pode executar uma variedade de diferentes tarefas sob condições

que não necessitam ser conhecidas a priori”. Gevarter ainda complementa (GEVARTER, 1984 apud

VIEIRA, 1999, p. 10) “... são máquinas flexíveis capazes de controlar suas próprias ações em uma

variedade de tarefas utilizando uma programação armazenada.”.

2.1.1 Breve histórico dos robôs móveis

Segundo a bibliografia, o primeiro robô construído e reconhecido é o Shakey, desenvolvido

pelo Stanford Research Institute, em 1968, ele possuía uma enorme variedade de sensores,

incluindo uma câmera de vídeo e sensores de toque, binários, (GROOVER; WEISS; NAGEL et al,

1988) e navegava entre as salas do laboratório, enviando sinais de rádio ao seu ‘cérebro’, um

computador DEC DP-10, que permitia efetuar algumas tarefas como empurrar caixas e evitar

obstáculos (NITZAN, 1985 apud VIEIRA, 1999). Deve-se atentar para o fato de que a unidade de

12

processamento embarcada no robô apenas coletava os sinais sensoriais e os enviava para um

computador remoto que executava o processamento, transmitindo ao robô o comando que geraria a

ação desejada.

Em todo o mundo foram desenvolvidos importantes trabalhos durante a década de 80. Um

dos mais importantes estudos sobre robôs móveis foi o desenvolvimento do robô Kephera, do K-

Team, do Microcomputing Laboratory do Swiss Federal Institute of Technology, com o apoio de

outras entidades de pesquisa da Europa.

Com apenas 55 mm de diâmetro por 30 mm de altura, o Kephera tem a capacidade de

desviar de obstáculos e seguir ou evitar fontes luminosas, além de permitir a utilização de algumas

extensões, como um sistema de visão e um pequeno manipulador. Seu tamanho reduzido e seu

custo relativamente baixo, em comparação a outros robôs no mercado, têm feito do Kephera um

sucesso dentro das universidades, sendo objeto de pesquisa inclusive no Brasil (BOTELHO, 1996).

No entanto, uma das mais espetaculares aplicações de robôs móveis deste século é a família

Rocky, resultado das pesquisas do Jet Propulsion Laboratory do Califórnia Institute of Technology

(HAYATI, 1996; HAYATI; VOLPE; BACKES et al, 1997 apud VIEIRA, 1999). Com dimensões

comparadas a um brinquedo de rádio controle, um modelo Rocky 4, carinhosamente batizado como

Sojourner (hóspede temporário, em inglês), foi capaz de realizar uma das maiores façanhas da

pesquisa no espaço, a exploração, à distância, do planeta Marte.

Figura 1. Shakey, Kephera e Sojourmer.

A empresa LunaCorp (www.lunacorp.com), juntamente com o Robotics Institute, da

Carnegie Mellon University pretendem lançar, até a virada do século, dois veículos móveis

13

autônomos à lua. O objetivo da empresa é criar um parque temático na Terra, de onde as pessoas

poderão comandar os veículos e sentir-se virtualmente explorando o solo lunar.

Os protótipos da LunaCorp já vêm sendo testados no deserto de Atakama, no Chile, sob

supervisão do Robotics Institute, com financiamento da NASA.

2.1.2 Definições de robôs móveis

Segundo McComb, existem duas vertentes na definição de robôs móveis: a primeira afirma

ser o robô completo, auto contido, autônomo, que necessita instruções de seu mestre apenas

ocasionalmente. Já a segunda é aquela que define robô como sendo qualquer equipamento que se

mova por seus próprios meios, com o objetivo de executar tarefas próximas às humanas.

(MCCCOMB, 1987 apud VIEIRA, 1999).

2.1.3 Robôs Inteligentes

Determinados autores classificam robôs inteligentes como aqueles que são capazes de tomar

decisões em tempo real, suportadas por técnicas de inteligência artificial, baseados em sensores

(KOREN, 1985 apud VIEIRA, 1999), o que lhes possibilita trabalharem em ambientes

completamente imprevisíveis.

Ao compararmos as técnicas de controle de robôs que não fazem uso de inteligência

artificial com aquelas que utilizam os recursos proporcionados pela mesma, podem-se classificar

essas ultimas como hierarquicamente superiores as primeiras (GEVARTER, 1984 apud VIEIRA,

1999). No caso de aplicação em máquinas autônomas, o emprego de inteligência artificial em robôs

não os tornará apenas mais flexíveis nas linhas de montagem, mas também os tornaram cada vez

mais aptos a executarem atividades fora do ambiente industrial (GERVARTER, 1984 apud

VIEIRA, 1999) mais próxima das humanas, no conceito de Schalkoff (SCHALKOFF, 1990 apud

VIEIRA, 1999).

2.2 Inteligência Artificial

Para Oswaldo Ludwig Jr e Eduard Montgomery (LUDWIG, MONTGOMERY, 2007), para

uma máquina ser considerada inteligente, deve apresentar as seguintes habilidades:

· Capacidade de realizar inferência e resolver problemas;

14

· Capacidade de planejamento;

· Capacidade de acumular e manipular conhecimento;

· Compreensão de linguagem natural;

· Capacidade de aprender com ou sem supervisão; e

· Capacidade de interpretar estímulos sensoriais.

Arnold e Bowie (1986 apud MIOTTO, 2006), definem Inteligência Artificial (IA) como a

parte da Ciência da Computação concernente ao projeto de sistemas computacionais que exibem

inteligência humana: aprender novas informações, entender linguagens, raciocinar e resolver

problemas.

Segundo Feigenbaum (1992 apud FERNANDES, 2003), a Inteligência Artificial (IA) é a

parte da Ciência da Computação voltada para o desenvolvimento de sistemas de computadores

inteligentes, isto é, sistemas que exibem características, as quais se associam com a inteligência no

comportamento humano, por exemplo: compreensão da linguagem, aprendizado, raciocínio,

resolução de problemas, etc.

2.3 Redes Neurais Artificiais

Segundo Fernandes (2003), é possível se chegar a diversas definições do que seja uma Rede

Neural Artificial, contudo, as três palavras “chaves”: neurônio, arquitetura e aprendizado, requerem

um entendimento, à priori, em qualquer definição de Rede Neural Artificial. Ainda segundo

Fernandes (2003), o neurônio é a unidade computacional básica da rede em questão; a arquitetura é

a estrutura topológica de como os neurônios são conectados; e a aprendizagem é um processo que

adapta a rede de modo a computar uma função desejada ou realizar uma tarefa.

Para Loesch (1996 apud FERNANDES, 2003), Redes Neurais Artificiais são sistemas

computacionais, de implementação em hardware e software, que imitam as “habilidades

computacionais” do sistema nervoso biológico, utilizando para isso um grande número de simples

neurônios artificiais interconectados.

Lippmann (1997 apud FERNANDES, 2003) afirma que as Redes Neurais Artificiais são

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

15

alcançar uma boa performance, devido a sua densa interconexão entre os nós da rede, Elas também

são conhecidas por: modelos conexionistas, modelos de processamentos paralelo distribuído e

sistemas neuromorfológicos.

No entanto, Haykin (HAYKIN, 2001), adapta a definição de rede neural de Aleksander e

Morton (1990 apud HAYKIN, 2001. p. 28), na qual afirma:

Uma rede neural é um processador maciçamente paralelamente distribuído constituído de unidades de processamento simples, que tem a propensão natural para armazenar conhecimento experimental e torná-lo disponível para uso. Ela se assemelha ao cérebro em dois aspectos:

1. O conhecimento é adquirido pela rede a partir de seu ambiente através de um processo de aprendizado.

2. Forças de conexão entre neurônios, conhecidas como pesos sinápticos, são utilizados para armazenar o conhecimento adquirido.

2.3.1 Neurônios Artificiais: Modelo MCP

O modelo de McCulloch e Pitts (MCCULLOCH; PITTS, 1943 apud BRAGA;

CARVALHO; LUDERMIR, 2007) é uma simplificação do que se sabia na época, a respeito do

neurônio biológico. Sua representação matemática resultou em um modelo com n terminais de

entrada (dendritos) que recebem os valores x1, x2..., xn (que representam as ativações dos neurônios

anteriores) e apenas um terminal de saída y (representando o axônio).

Para representar o comportamento das sinapses, os terminais de entrada do neurônio têm

pesos acoplados w1, w2,..., wn, cujos valores podem ser positivos ou negativos, dependendo de as

sinapses correspondentes serem inibitórias ou excitatórias. O efeito de uma sinapse particular i no

neurônio pós-sináptico é dado por xiwi. Os pesos determinam “em que grau” o neurônio deve

considerar sinais de disparo que ocorram naquela conexão. (BRAGA; CARVALHO; LUDERMIR,

2007).

Uma descrição do modelo está ilustrada na Figura 2, no qual ∑ representa a soma ponderada

das entradas e f(.) a função de ativação.

16

Figura 2. Neurônio de McCulloch e Pitts.

Fonte: Braga, Carvalho e Ludermir, 2007

2.3.2 Função de Ativação

A função de ativação é responsável por gerar a saída y do neurônio a partir dos valores dos

vetores de peso w = (w1, w2,... wn)T e de entradas x = (x1, x2,... Xn)

T. Dependendo do tipo de

problema a ser abordado, neurônios com funções de ativação lineares, podem também ser

utilizados, já as Redes Neurais Artificiais do tipo RBF (Radial Basics Functions) utilizam neurônios

com funções de ativação radiais. (BRAGA; CARVALHO; LUDERMIR, 2007)

2.3.3 Topologias de Redes Neurais Artificiais

Segundo Rummelhart (1986 apud FERNANDES, 2003), uma Rede Neural Artificial deve

possuir no mínimo duas camadas: a camada de entrada e a camada de saída dos resultados. Com

duas camadas, somente, a rede apresenta um desempenho muito limitado, a adição de uma camada

intermediária faz-se necessária. Neste tipo de configuração, cada neurônio está ligado com todos os

outros das camadas vizinhas, mas neurônios da mesma camada não se comunicam, além da

comunicação ser unidirecional, apresentando, assim, um comportamento estático.

A Rede Neural Artificial de Hopfield (1982 apud FERNANDES, 2003), apresenta

comportamento dinâmico e fluxo de dados multidirecional, devido à integração total dos neurônios,

desaparecendo assim, a idéia de camadas bem distintas. Com isso, seu funcionamento é mais

complexo, havendo certas complicações, seja na fase de aprendizado quanto na fase de testes, seu

uso é direcionado a problemas de minimização e otimização de percursos.

17

Para Hecht-Nielsen (1987 apud FERNANDES, 2003), com a presença de apenas uma

camada oculta (intermediária), já é possível calcular uma função arbitrária qualquer, a partir de

dados fornecidos.

Cybenko (1989 apud FERNANDES, 2003), afirma que é necessária a presença de duas

camadas ocultas para o cálculo das funções. Observa-se que para cada três neurônios da primeira

camada oculta é preciso um neurônio da segunda camada.

Todavia para Lippmann (1987 apud FERNANDES, 2003), a segunda camada oculta deve

ter o dobro de neurônios da camada de saída, no caso de apenas uma camada oculta, ela deverá ter

s(i+1) neurônios, onde s é o número de neurônios de saída e i é o número de neurônios de entrada.

2.3.4 Principais Arquiteturas de Redes Neurais Artificiais

Independente da função de ativação escolhida, neurônios individuais possuem capacidade

computacional limitada. No entanto, um conjunto de neurônios conectados na forma de uma rede

(neural) é capaz de resolver problemas de complexidade elevada.

A estrutura mais simples é apresentada na Figura 3, que corresponde a uma RNA de camada

única alimentada para frente (feedfoward). Estruturas como essas são capazes de resolver problemas

multivariáveis de múltiplas funções acopladas, mas com algumas restrições de complexidade, por

serem de uma única camada. A estrutura apresentada na Figura 4 é semelhante a da Figura 3, com a

diferença de que possui uma camada adicional. A camada intermediaria confere a RNA uma maior

capacidade computacional e universalidade na aproximação de funções contínuas.

As redes neurais artificiais apresentadas nas Figuras 3 e 4 são consideradas estáticas, já que

não possuem recorrência em sua estrutura: as suas saídas em um determinado instante dependem

apenas de suas entradas atuais. Já as estruturas das Figuras 5 e 6 possuem conexões recorrentes

entre neurônios de um mesmo nível ou entre neurônios de saída e de camada anteriores.

No exemplo da Figura 5, a saída depende não somente das entradas, mas também de seu

valor atual. Essa estrutura de rede neural artificial é utilizada na resolução de problemas que

envolvam processamento temporal, como em previsão de eventos futuros. Já a estrutura da Figura 6

possui um único nível de neurônios, em que a saída de cada um deles está conectada as entradas de

todos os outros. A rede não possui entradas externas, e sua operação se dá em função da dinâmica

de mudança de estados dos neurônios, Que operam de forma auto-associativa.

18

Figura 3. Feedforward de uma camada.


Figura 4. Feedforward de duas camadas.


Figura 5. Recorrência entre saída e intermediária.


Figura 6. Recorrência auto-associativa.


A definição da estrutura de uma rede neural artificial para a solução de um determinado

problema depende de vários fatores, entre eles:

· Complexidade do problema;

· Dimensionalidade do espaço de entrada;

· Características dinâmicas ou estáticas;

19

· Conhecimento à priori sobre o problema; e

· Representatividade dos dados.

As redes neurais artificiais podem ser distinguidas com base na direção na qual o sinal flui,

basicamente, há dois tipos de redes neurais artificiais: feedforward e feedback. Nas redes neurais

feedforward, os sinais se propagam em apenas uma direção a partir do sinal de entrada, passando

pela camada intermediária até a saída. Nas redes neurais feedback, os sinais de entrada podem

propagar da saída de qualquer neurônio para a entrada em outro neurônio (FERNANDES, 2003).

Para Anderson (1972 apud FERNANDES, 2003), os neurônios são ligados por conexões,

cada um com um peso (w) associado, que corresponde à influência do neurônio no processamento

do sinal de saída.

2.3.5 Aprendizado

A propriedade mais importante das redes neurais artificiais é a habilidade de “aprender de

seu ambiente” e, com isso, melhorar seu desempenho (FERNANDES, 2003).

Segundo Ackley (1985 apud FERNANDES, 2003), a habilidade de aprender ocorre através

de um processo interativo de ajustes aplicados a seus pesos, o treinamento. O aprendizado ocorre

quando a rede neural atinge uma solução generalizada para uma classe de problemas.

Para Haykin (2001), as redes neurais artificiais podem ser classificadas de acordo com o seu

tipo de aprendizagem:

· Não supervisionada - a rede aprende a classificar a entrada em conjuntos, sem que

haja monitoramento; e

· Supervisionada - a rede ajusta os pesos com base na diferença dos valores entre as

unidades de saída e os valores desejados.

Para Gurney (1985 apud FERNANDES, 2003), uma rede neural artificial não executa uma

serie de instruções, ela responde em paralelo às entradas apresentadas. O resultado não é

armazenado em um local especifico da memória, mas consiste de todos os estados da rede, após

encontrar uma condição de equilíbrio.

20

Na abordagem conexionista o conhecimento não é adquirido através de regras explícitas,

como na Inteligência Artificial simbólica, mas através dos ajustes das intensidades das conexões

entre os neurônios. A etapa de aprendizado de uma rede neural artificial consiste em um processo

iterativo de ajuste de parâmetros da rede, os pesos das conexões, que guardam, ao final do processo,

o conhecimento que a rede adquiriu do ambiente externo (BRAGA; CARVALHO; LUDERMIR,

2007). Segundo Mendel e McLaren (1970 apud BRAGA; CARVALHO; LUDERMIR, 2007), uma

definição geral do que vem a ser aprendizado pode ser expressa da seguinte forma:

“Aprendizado é o processo pelo qual os parâmetros livres de uma rede neural são ajustados

por meio de uma forma continuada de estímulo pelo ambiente externo, sendo o tipo específico de

aprendizado definido pela maneira particular como ocorrem os ajustes dos parâmetros livres”.

É importante ressaltar que o conceito de aprendizado está relacionado com a melhoria do

desempenho da rede segundo algum critério preestabelecido. O erro quadrático médio da resposta

da rede em relação ao conjunto de dados fornecidos pelo ambiente, por exemplo, é utilizado como

critério de desempenho pelos algoritmos de correção de erros. Assim, quando estes algoritmos são

utilizados no treinamento de redes neurais artificiais, espera-se que o erro diminua à medida que o

aprendizado prossiga (BRAGA; CARVALHO; LUDERMIR, 2007)

2.3.5.1 Aprendizado Supervisionado

Aprendizagem supervisionada implica, necessariamente, a existência de um supervisor, ou

professor externo, o qual é responsável por estimular as entradas da rede por meio de padrões de

entrada e observar a saída calculada pela mesma, comparando-a com a saída desejada, (BRAGA;

CARVALHO; LUDERMIR, 2007) conforme Figura 7.

Figura 7. Aprendizado supervisionado


21

2.3.5.2 Aprendizado Não-supervisionado

No aprendizado não-supervisionado, como o próprio nome sugere, não há um professor ou

supervisor externo para acompanhar o processo de aprendizado. Neste esquema de treinamento

somente os padrões de entrada estão disponíveis para a rede, ao contrário do aprendizado

supervisionado, cujo conjunto de treinamento possui pares de entrada e saída. Durante o processo

de aprendizado os padrões de entrada são apresentados continuamente a rede, e a existência de

regularidades nesses dados fazem com que o aprendizado seja possível. Regularidade e redundância

nas entradas são características essenciais para haver aprendizado não-supervisionado.

Um esquema genérico do aprendizado não-supervisionado é apresentado na Figura 8.

Figura 8. Aprendizado não-supervisionado


2.3.5.3 O Algoritmo Backpropagation

O método backpropagation ( BEALE, 1994 apud REIS; ALBUQUERQUE; CASTRO,

2001), utilizado neste trabalho, pode ser usado para várias aplicações de redes neurais. Ele é um

método de treinamento do tipo supervisionado, onde o padrão de entrada é apresentado à rede

juntamente com a sua saída desejada. O objetivo é treinar a rede e atingir um meio-termo entre a

habilidade de responder corretamente aos padrões de entrada que são usados para o treinamento

(memorização) e a habilidade de fornecer uma resposta coerente a uma entrada que é similar, mas

não idêntica, àquelas utilizadas no treinamento. O método backpropagation envolve 3 estágios: a

propagação dos padrões de entrada, a retropropagação do erro associado e o ajuste de pesos.

O desenvolvimento do algoritmo de aprendizagem backpropagation foi um dos mais

importantes avanços da área de redes neurais nos últimos tempos. Neste algoritmo, usamos a função

sigmóide como função de ativação:

F(x) = 1/1 + e – (x - θ) sendo θ (Teta) o theshold.

22

Uma das razões de se usar a função sigmóide como função de ativação é que ela fornece

uma informação mais precisa quando o threshold e a soma dos pesos têm valores parecidos. Ou

seja, o valor de saída de um neurônio não é simplesmente 1 ou 0, mas varia no intervalo de 0 a 1.

Esta informação é importante para o ajuste de pesos.

Os estágios do algoritmo são os seguintes (BEALE, 1994 apud REIS; ALBUQUERQUE;

CASTRO, 2001):

1. Inicializar os pesos e os thresholds com valores randômicos pequenos;

2. Apresentar as entradas Xp = x0, x1,x2, xn-1 e a saída desejada Tp = t0, t1,t2, tm-1, onde n

é o número de nós de entrada e m é o número de nós de saída. Atribua a w0 o valor -θ

e a x0 o valor 1. Para a associação do padrão, Xp e Tp representam os padrões a serem

associados. Para a classificação, Tp é definido como 0, exceto para um dos nós,

definido como 1 que corresponde a classe que Xp pertence;

3. Calcular a saída atual. Para cada camada, calcule yp = f [∑wjxi], e passe este

resultado para a próxima camada. A camada final fornece a saída opj;

4. Adaptar os pesos. Começando pela camada de saída e trabalhando de trás para frente.

wij(t+1) = wij(t) + ηδpjopj,

onde wij representa o peso do nó i para o nó j no instante t, η (Eta) é a taxa de

aprendizagem e δpj é um termo de erro para o padrão p no nó j.

Para neurônios de saída,

δij = kopj (1 - opj)(tpj - opj),

e para neurônios intermediários,

δpj = kopj(1 – opj)∑kδpkwjk

onde a soma é sobre os k nós na camada acima do nó j.

5. Repetir os passos 2 a 4 até a rede convergir, ou seja, até que o erro decline a um nível

aceitável (Previsão do preço da soja utilizando redes neurais, 1999).

23

Durante o treinamento com o algoritmo backpropagation, a rede opera em uma seqüência de

dois passos, como mostra a Figura 9. Primeiro, um padrão é apresentado à camada de entrada da

rede. A atividade resultante flui através da rede, camada por camada, até que a resposta seja

produzida pela camada de saída. No segundo passo, a saída obtida é comparada à saída desejada

para esse padrão particular. Se estas não forem iguais, o erro é calculado. O erro é retropropagado

da camada de saída até a camada de entrada. Os pesos das conexões das unidades da camada de

saída e das camadas intermediárias vão sendo modificados conforme o erro é retropropagado.

Figura 9. Esquema de funcionamento do Algoritmo Backpropagation.

Fonte: (REIS; ALBUQUERQUE; CASTRO, 2001)

As redes que utilizam backpropagation trabalham com uma variação da regra delta,

apropriada para redes com múltiplas camadas: a regra delta generalizada. A regra delta padrão

essencialmente implementa um gradiente descendente no quadrado da soma do erro para funções de

ativação lineares.

Entretanto, a superfície do erro pode não ser tão simples, como a ilustrada na Figura 10, e

suas derivadas mais difíceis de serem calculadas. Nestes casos, devem ser utilizadas redes com

camadas intermediárias. Ainda assim, as redes ficam sujeitas aos problemas de procedimentos hill-

climbing, ou seja, ao problema de mínimos locais. A figura também ilustra o processo de redução

dos erros utilizando o backpropagation.

24

O erro cometido pela rede vai sendo progressivamente diminuído, podendo chegar ao

mínimo global.

Figura 10. Exemplo de uma superfície de erro para um treinamento usando backpropagation.


A regra delta generalizada funciona quando são utilizadas na rede unidades com uma função

de ativação semi-linear, que é uma função diferenciável e não decrescente. Note que a função

threshold não se enquadra nesse requisito. Uma função de ativação amplamente utilizada, nestes

casos, é a função sigmoid.

O verdadeiro gradiente descendente requer que sejam tomados passos infinitesimais. Assim

quanto maior for essa constante, maior será a mudança nos pesos, aumentando a velocidade do

aprendizado, o que pode levar a uma oscilação do modelo na superfície de erro. O ideal seria

utilizar a maior taxa de aprendizado possível que não levasse a uma oscilação, resultando em um

aprendizado mais rápido.

O treinamento das redes MLP com backpropagation pode demandar muitos passos no

conjunto de treinamento, resultando um tempo de treinamento consideravelmente longo. Se for

encontrado um mínimo local, o erro para o conjunto de treinamento pára de diminuir e estaciona em

um valor maior que o aceitável. Uma maneira de aumentar a taxa de aprendizado sem levar à

oscilação é modificar a regra delta generalizada para incluir o termo momentum, uma constante que

determina o efeito das mudanças passadas dos pesos na direção atual do movimento no espaço de

pesos.

25

Desta forma, o termo momentum leva em consideração o efeito de mudanças anteriores de

pesos na direção do movimento atual no espaço de pesos. O termo momentum torna-se útil em

espaços de erro que contenham longas gargantas, com curvas acentuadas ou vales com descidas

suaves, como o apresentado na Figura 10.

As respostas geradas pelas unidades são calculadas através de uma função de ativação.

Existem vários tipos de funções de ativação, as mais comuns são: Hard limiter, Threshold Logic e

Sigmoid, como mostra a Figura 11 (REIS; ALBUQUERQUE; CASTRO, 2001).

Figura 11. Tipos de funções de ativação mais utilizados.


2.4 Sensores

Os sensores usados como dispositivos periféricos na robótica incluem tanto tipos simples,

tais como chaves limites, quanto tipos sofisticados, tais como sistemas de visão de máquina.

Evidentemente os sensores são usados também como componentes integrais do sistema de controle

de realimentação do robô. Sua função como dispositivos periféricos em uma célula de trabalho

robótica e a de permitir que as atividades do robô sejam coordenadas com outras atividades na

célula. Os sensores na robótica incluem as seguintes categorias gerais:

· Sensores de tato: São sensores que respondem a forças de contato com outro objeto.

Alguns desses dispositivos são capazes de medir o nível de força envolvido;

· Sensores de proximidade e distância: Um sensor de proximidade é um dispositivo

que indica quando um objeto está próximo (mas antes que o contato tenha sido

26

estabelecido). Quando a distância entre os objetos pode ser detectada, o dispositivo é

chamado de sensor de alcance;

· Sensores de tipos diversos: A categoria diversos inclui os tipos restantes de sensores

que são usados na robótica. Incluem sensores de temperatura, pressão e outras

variáveis; e

· Sensores de visão de máquina: Um sistema de visão de máquina é capaz de

visualizar o espaço de trabalho e interpretar o que vê. Esses sistemas são utilizados

na robótica para realizar inspeção, reconhecimento de peças e outras tarefas

similares.

Os sensores são um importante componente no controle da célula de trabalho e em sistemas

de monitoração de segurança (GROOVER et al., 1989).

2.5 Atuadores

Atuadores são dispositivos que fornecem a força motriz efetiva para as juntas do robô.

Geralmente recebem sua força de uma das três fortes: ar comprimido, fluido pressurizado ou

eletricidade. São chamados, respectivamente, atuadores pneumáticos, hidráulicos ou elétricos.

· Atuadores pneumáticos e hidráulicos: Tanto os atuadores pneumáticos quanto

hidráulicos são acionados por fluidos em movimento. No primeiro caso, o fluido é o

ar comprimido e, no segundo caso, o fluido é geralmente óleo pressurizado. A

operação desses acionamentos é geralmente semelhante, exceto em sua capacidade

para contem a pressão do fluido. Os sistemas pneumáticos tipicamente operam a

aproximadamente 100 lb/in² 68,96N/cm² e sistemas hidráulicos a 68,96N/cm² até

3000 lb/in² 2068,8N/cm²; e

· Atuadores elétricos: À medida que suas características evoluem, os motores elétricos

se tornam cada vez mais o atuador escolhido no projeto de robôs. Propiciam

excelente controlabilidade com o mínimo de manutenção. Existe uma variedade de

tipos de motores em uso nos robôs, os mais comuns são os servomotores, motores de

passo e servomotores de CA (GROOVER et al., 1989).

27

2.6 Controladores

A finalidade do controlador é comparar a saída efetiva da planta com o comando de entrada

e propiciar um sinal de controle que reduz o erro a zero ou ao mais próximo de zero possível.

Existem quatro ações de controle básicas que são usadas isoladamente ou em combinação, para

propiciar seis tipos comuns de controlador: controle liga-desliga, controle proporcional, controle

derivado e controle integral. Os seis tipos de controlador são:

· Controle liga-desliga: Nesse controlador, o elemento de controle fornece apenas dois

níveis de controle, plenamente ligado ou plenamente desligado;

· Controle proporcional: Em casos em que é requerida uma ação de controle mais

suave, pode ser usado um controlador proporcional. O controlador proporcional

propicia um sinal de controle que é proporcional ao erro;

· Controle integral: Num controlador empregando uma ação de controle integral, o

sinal de controle é mudado a uma taxa proporcional ao sinal do erro. Isto é, se o sinal

do erro é grande, o sinal de controle aumenta rapidamente, se é pequeno, o sinal de

controle aumenta lentamente;

· Controle proporcional-integral: Às vezes é necessário combinar ações de controle.

Um controlador proporcional é incapaz de neutralizar uma carga sobre o sistema sem

um erro. Um controlador integral pode propiciar erro zero, mas geralmente fornece

resposta lenta. Um modo de superar isto é com o controlador proporcional-integral,

que é capaz de ajustar tanto o ganho do integrador quanto o ganho proporcional;

· Controle proporcional-derivativo: A ação de controle derivativo fornece um sinal de

controle proporcional à taxa de mudança do sinal de erro. Já que este não geraria

qualquer saída, a menos que o erro esteja mudando, raramente é usado sozinho. O

efeito da ação de controle derivado é prever mudanças no erro e propiciar uma

resposta mais rápida às perturbações; e

· Controle proporcional-integral-derivativo: O controle proporcional-integral-

derivativo é o tipo de controle mais genérico e provavelmente o mais comumente

usado. Fornece resposta rápida, bom controle de estabilidade do sistema e baixo erro

de regime permanente (GROOVER et al., 1989).

28

2.7 Ferramentas para Criação de RNAs

Durante o desenvolvimento deste projeto, foram estudadas diversas ferramentas para a

criação de RNAs, dentre as quais três delas se destacaram, e serão explicadas a seguir.

2.7.1 Java Object Oriented Neural Engine – Joone

Joone é um framework gratuito, para a criação, treinamento e teste de redes neurais

artificiais. O objetivo foi criar um poderoso ambiente de desenvolvimento, tanto para entusiastas

quanto para profissionais da área, baseado nas mais recentes tecnologias Java.

Joone é formado por um motor central que funciona como uma central de comando para

todos os aplicativos que são desenvolvidos com o mesmo. A rede neural criada com o Joone pode

ser construída na máquina local, ser treinada em um ambiente distribuído e executada em qualquer

dispositivo. Qualquer individuo pode implementar novos módulos para implementar novos

algoritmos ou novas arquiteturas partindo de um simples componente distribuído com o motor

central. A idéia fundamental é criar uma base para promover a criação de incontáveis aplicações em

Inteligência Artificial em torno do núcleo do framework (MARRONE, 2009).

Figura 12. Ambiente do Java Object Neural Engine – Joone.

29

Fonte: (MARRONE, 2009)

2.7.2 Stuttgart Neural Network Simulator – SNNS

SNNS (Stuttgart Neural Network Simulator) é um software simulador para redes neurais em

estações de trabalho Unix desenvolvido pelo IPVR (Institute for Parallel and Distributed High

Performance Systems) na Universidade de Stuttgart. A meta do projeto SNNS é criar um ambiente

de simulação eficiente e flexível para aplicação em pesquisas de redes neurais.

O simulador SNNS consiste em dois componentes principais:

1. O núcleo do simulador, escrito na linguagem C.

2. Interface gráfica do usuário sob X11R4 ou X11R5.

O núcleo do simulador opera ligado a rede interna de dados de estruturas de redes neurais e

realiza todas as operações de aprendizagem e sensibilidade. Também pode ser utilizado sem as

outras partes, como um programa C incorporado em aplicações personalizadas. Ele suporta várias

topologias de rede e, como RCS (Revision Control System), suporta o conceito de sites. O SNNS

pode ser estendido pelo usuário com a definição de funções de ativação, funções de saída, funções

de peso e procedimentos de aprendizagem. Que são escritas como simples programas em C e

ligadas ao núcleo do simulador.

Atualmente, a seguintes arquiteturas de rede e procedimentos de aprendizagem estão

incluídos no simulador:

· Backpropagation (BP) para redes feedforward;

o Vanilla (online) BP;

o BP dinâmico com prazo fixo local e de eliminação; e

o Lote BP.

· Counterpropagation;

· Quickprop;

· Backpercolation 1;

30

· RProp;

· RBF (Generalized radial basis functions);

· ART1;

· ART2;

· ARTMAP;

· Cascade Correlation;

· Recurrent Cascade Correlation;

· Dynamic LVQ;

· Backpropagation through time (para redes recorrentes);

· Quickprop through time (para redes recorrentes);

· Self-organizing maps (mapas de Kohonen);

· TDNN (time-delay neural networks) com Backpropagation;

· Redes de Jordan;

· Redes de Elman e redes de Elman com hierarquia estendida; e

· Memória Associativa.

A interface gráfica XGUI (X Graphical User Interface), construída sobre o núcleo, oferece

uma representação gráfica em 2D ou 3D das redes neurais e dos controles do núcleo durante a

execução da simulação. Além disso, a interface do usuário em 2D possui um editor de redes

integrado, que pode ser utilizado diretamente para criar, manipular e visualizar redes neurais, de

varias maneiras (ZELL et al., 2009).

Na Figura 13 é possível visualizar o ambiente de desenvolvimento do SNNS.

31

Figura 13. Ambiente do Stuttgart Neural Network Simulator – SNNS.

Fonte: (ZELL et al., 2009).

2.7.3 Java Neural Network Simulator – JavaNNS

Java Neural Network Simulator (JavaNNS) é um simulador para redes neurais desenvolvido

no Wilhelm-Schickard-Institute for Computer Science (WSI) em Tübingen, Alemanha. Ele é

baseado no núcleo do Stuttgart Neural Network Simulator (SNNS) 4.2, com uma nova interface

gráfica do usuário escrita em Java sobre ele. Como conseqüência, as capacidades do JavaNNS são

iguais a maioria das capacidades do SNNS, considerando que a interface com o usuário foi

recentemente desenvolvida e tornou-se mais fácil e intuitiva de usar. Algumas características

complexas do SNNS, mas não utilizadas (e. g. visualização de redes neurais em três dimensões)

foram deixadas de fora ou sua inclusão foi adiada para uma versão posterior, todavia, algumas

características novas, como o painel de log, foram introduzidas.

32

Além da nova interface de usuário, uma grande vantagem do JavaNNS é o aumento de sua

independência quanto a plataforma de utilização. Considerando que o SNNS foi desenvolvido

principalmente com estações de trabalho Unix em mente, o JavaNNS também funciona em

computadores pessoais, desde que o Java Runtime Environment esteja instalado (ZELL et al.,

2009).

O JavaNNS foi testado em Windows NT, Windows 2000, Windows XP, RedHat Linux 6.1,

Solaris 7 e Mac OS X (ZELL et al., 2009).

Na Figura 14 é possível visualizar o ambiente de desenvolvimento do JavaNNS.

Figura 14. Ambiente do Java Neural Network Simulator – JavaNNS.

Fonte: (ZELL et al., 2009).

33

2.8 Simuladores de Robôs

Durante o desenvolvimento deste projeto, foram estudadas diversas ferramentas para a

simulação de robôs, dentre as quais três delas se destacaram, e serão explicadas a seguir.

2.8.1 Robocode

O Robocode foi desenvolvido pela AlphaWorks, uma divisão da IBM que tem como

finalidade difundir novas tecnologias de desenvolvimento. O Robocode é um projeto hospedado

pela SourceForge e pode ser encontrado em http://robocode.sourceforge.net/. A idéia básica é

fornecer um ambiente de simulação de batalhas entre robôs que seja executado em qualquer

plataforma Java. O usuário pode utilizar as classes básicas disponibilizadas pelo ambiente para criar

um robô e colocá-lo em batalha contra outros robôs desenvolvidos por outros programadores. Com

ele é possível aprimorar conceitos como herança, polimorfismo, eventos, entre outros, além de

servir para testes de heurísticas de combate e de movimentação (PASSOS, 2008).

No Robocode, um robô é composto por: (i) um veiculo (body), que prove movimentação e

rotação ao robô; (ii) um canhão (gun), que serve para atacar os robôs inimigos; (iii) um radar, que é

utilizado para localizar outros robôs no campo de batalha e para movimentar-se de forma

independente do canhão, conforme Figura 15. E tem como restrições: (i) energia, que é utilizada

para realizar as operações no robô e nos disparos, onde é possível definir a quantidade de energia

que será utilizada e sendo recuperada quando se acerta outro robô; (ii) calor, onde um canhão só

dispara quando seu nível de calor estiver em zero, sendo que o calor produzido é proporcional a

potencia do disparo (PASSOS, 2008).

Figura 15. Anatomia de um robô no simulador Robocode.

Fonte: (PASSOS, 2008).

34

O Robocode apresenta certas características físicas, como: (i) tempo, que é medido no

Robocode através dos “ticks” que são equivalentes aos frames, que são os quadros do jogo por

segundo, iniciados na tela; (ii) distância, a distância é medida através dos pixels, com duas

exceções, na primeira as distâncias são medidas com precisão “double”, permitindo que se possa

mover uma fração de um pixel, na segunda o Robocode pode alterar automaticamente a escala para

que as mesmas possam caber na tela, sendo nesse caso a unidade de medida menor que um pixel; a

(iii) aceleração do robô é feita na taxa de 1 pixel/tick e a desaceleração na taxa de 2 pixel/tick, sendo

que o robocode determina automaticamente a aceleração baseada na distancia que se pretende

movimentar o robô; (iv) velocidade, é representada por uma equação v=em, sendo que a velocidade

máxima não pode exceder o nível 8 (SOURCEFORGE, 2007 apud PASSOS, 2008).

Os principais comandos do robô são apresentados na Tabela 1.

AÇÃO DO ROBÔ MÉTODO turnRight(double degree) Virar o robô turnLeft(double degree) Ahead(double distance) Move o robô e finaliza caso bata em uma parede back(double distance) turnGunRight(double degree) Move o canhão independente do veiculo turnGunLeft(double degree)

Se verdadeiro, vira o canhão junto com o veiculo setAdjustGunForRobotTurn(boolean flag) Se verdadeiro, vira o radar junto com o veiculo setAdjustRadarForRobotTurn(boolean flag) Se verdadeiro, vira o radar junto com o canhão setAdjustRadarForGunTurn(boolean flag)

Tabela 1. Principais comandos do robô.


Os principais eventos realizados pelo robô são descritos na Tabela 2.

DESCRIÇÃO MÉTODO Chamado quando o robô é detectado pelo radar onScannedRobot(ScannedRobotEvent) Chamado quando o robô é atingido por uma bala onHitByBullet(HitByBulletEvent) Chamado quando ocorre uma colisão entre robôs onHitRobot(HiRobotEvent) Chamado quando o robô colide contra uma parede onHitWall(HitWallEvent)

Tabela 2. Principais eventos utilizados pelo robô.


As principais funções para se obter informações são descritas na tabela 3.

35

DESCRIÇÃO MÉTODO get(x) Coordenadas correntes do robô get(y) getHeading() getGunHeading() Direção corrente do robô getRadarHeading() getBattleFieldWidth() Dimensões do campo de batalha getBattleFieldHeight()

Tabela 3. Principais funções utilizadas para a obtenção de informações.


Os robôs comuns executam apenas uma tarefa de cada vez, todavia é possível criar robôs

mais avançados, nos quais ações assíncronas são definidas e executadas, permanecendo em

execução paralelamente a outras possíveis ações. As principais vantagens nesse tipo de

programação são: (i) execução de múltiplos movimentos simultâneos; (ii) pode-se definir uma

estratégia diferente a cada tique do relógio; (iii) pode-se definir eventos customizados.

Existe também a opção de se criar equipes de robôs cooperativos entre si, nos quais os robôs

podem trocar mensagens através dos métodos broadcastMessage (Serializable msg) e

onMessageReceived (MessageEvent Event) (PASSOS, 2008).

Na Figura 16 pode-se visualizar o ambiente de simulação do Robocode.

Figura 16. Interface do ambiente de simulação do Robocode.

Fonte: (NELSON et al., 2009).

36

2.8.2 Khepera Simulator

O simulador Khepera foi desenvolvido na Universidade Nice Sophia, por Oliver Michel.

Trata-se de um software freeware desenvolvido em C que pode ser adquirido gratuitamente no site

http://diwww.epfl.ch/lami/team/michel/khep-sim/. Ele foi projetado para desenvolver algoritmos de

controle utilizando a linguagem C ou C++ e conta com uma biblioteca de funções para realizar a

movimentação do robô e obter os resultados. Sendo caracterizado pela habilidade de dirigir um robô

Khepera real, sendo possível transferir facilmente os resultados da simulação para o robô físico

(MICHEL et al., 2009).

O simulador opera apenas em sistemas baseados na plataforma Unix, apresentando uma

interface gráfica colorida e agradável. A interface do simulador Khepera se divide em duas partes:

(i) a primeira, localizada à esquerda na Figura 17, representa o ambiente simulado, onde é possível

visualizar o comportamento do robô, (ii) a segunda, apresentada a direita na mesma figura,

representa o robô, onde é possível observar o que ocorre internamente no robô (sensores, atuadores

e controladores). Na Figura 17 pode-se visualizar o ambiente de simulação Khepera (MICHEL et

al., 2009).

Figura 17. Interface do ambiente de simulação do Khepera.

Fonte: (MICHEL et al., 2009).

37

O simulador conta com diversos ambientes de simulação já disponíveis em seus diretórios,

que podem ser utilizados para a realização de simulações. Sendo que o mesmo ainda permite ao

usuário a edição e criação de novos ambientes de simulação. O robô simulado pelo simulador

Khepera conta com oito sensores infravermelhos, que tem como finalidade detectar objetos e medir

o nível de luz do ambiente. Ele também simula motores diretos, movendo o robô de acordo com a

velocidade estipulada pelo usuário (MICHEL et al., 2009).

Embora esteja disponível para download e seja um software freeware, o Khepera simulador

deixou de receber atualizações em 1996, quando deu origem a uma versão comercial batizada como

Webots, pertencente a empresa Cyberbotic. Esse novo simulador tornou-se referencia no mercado e

foi adotado pelas maiores empresas de robótica do Japão, e possui uma versão de demonstração

disponível em http://www.cyberbotics.com/. Uma licença comercial deste simulador custa U$

9.000,00, entretanto há uma licença acadêmica mais em conta, no valor de U$ 400,00. Atualmente

mais de 500 universidades e centros de pesquisa utilizam este simulador. Na Figura 18 é

apresentado o ambiente de simulação do Webots 6 (MICHEL et al., 2009).

Figura 18. Interface do ambiente de simulação do Webots 6.

Fonte: (MICHEL et al., 2009).

38

2.8.3 Simbad 3D

O Simbad é um projeto Open Source (tipo de software cujo código fonte é visível

publicamente), que utiliza a plataforma JAVA 3D e tem como objetivo gerar um ambiente para

simulação de robôs que forneça aos desenvolvedores uma base simples para estudos na área de IA,

no contexto de robótica autônoma e agentes autônomos (SIMBA, 2007 apud PASSOS, 2008).

Conforme Hugues e Bredeche (2006), o Simbad possui dois pacotes adicionais, são eles:

· PicoNode. Contém bibliotecas de Redes Neurais (feed-forward, recorrentes, etc.);

· PicoEvo. É uma estrutura de evolução artificial para algoritmos genéticos, estratégias

evolutivas e programação genética.

Esses pacotes são direcionados para robôs evolutivos.

O pacote Simbad possui um simulador de robôs móveis com complexa modelagem de cena

em 3D (simbad), uma biblioteca de Redes Neurais (feed-forward, recorrentes), bem como uma

completa biblioteca de algoritmos evolutivos (algoritmo genético, estratégia evolutiva, programação

genética com árvores ou grafos). Todas as ferramentas foram escritas para serem eficientes e fáceis

de usar por programadores em Java ou em Pyton, permitindo a eles escrever seus próprios

controladores de robôs, modificar o ambiente e utilizar sensores disponíveis ou construir novos

sensores (HUGUES; BREDECHE, 2006).

O Simbad está disponível a partir do site http://simbad.sourceforge.net/ sob as condições da

GPL (GNU General Public Licence) e necessita da plataforma Java (versão 1.4.2 ou superior) e Sun

Java 3D (versão 1.3.1 ou superior). Estes dois componentes estão disponíveis para uma ampla gama

de plataformas (Windows, Mac OS X, Linux, IRIX, AIX). Após o Java ser instalado e configurado

de acordo com o sistema operacional e depois do Java 3D ser instalado, basta executar o comando

java -jar simbad-[versão].bin.jar, para iniciar o simulador (SIMBA, 2007).

Em relação a simulação, o usuário somente utilizará um ambiente derivado da classe

EnvironmentDescription e um controlador de robô derivado da classe Robot. Esta última tem um

método de inicialização (initBehavior) e um método a ser chamado a cada etapa da simulação

(performBehavior). Em seguida são executadas as ordens de controle motor de forma semelhante a

39

um verdadeiro controlador de robô, isto é, repetitivas chamadas para o micro-controlador,

(HUGUES; BREDECHE, 2006).

Na Figura 19 é possível ver a interface do simulador Simbad 3D.

Figura 19. Interface do ambiente de simulação Simbad 3D.

Fonte: (HUGUES; BREDECHE, 2009).

40

As principais funções disponibilizadas pelo simulador Simbad são descritas na Tabela 4.

DESCRIÇÃO MÉTODO Define o tamanho do quadro que receberá o mundo setWorldSize(float size) Cria um objeto caixa no ambiente Box(Vector3d, Vector3f, EnvironmentDescription) Classe que auxilia na construção de robôs e sensores RobotFactory() Define a velocidade translacional em metro por segundo setTranslationalVelocity(double TV) Define a velocidade rotacional em radianos por segundo setRotationalVelocity(double TV) Retorna a posição do robô em coordenadas getCoords(javax.vecmath.Point3d cood)

Tabela 4. Principais funções disponibilizadas pelo Simbad 3D.


2.9 Ferramentas Similares

Nesta seção serão mostradas as ferramentas que se mostraram relevantes ao escopo deste

projeto, visando facilitar o entendimento das mesmas e permitindo que se extraía delas sugestões

para solucionar os possíveis problemas desse projeto.

2.9.1 Utilizando RNAs no Controle de Robôs Moveis Aplicados ao Combate de Incêndios Florestais

O objetivo deste trabalho foi detalhar o projeto e o desenvolvimento de um sistema multi-

agente que opera em um ambiente virtual de simulação realística. Onde uma equipe heterogênea de

agentes autônomos trabalha cooperativamente a fim de realizar com sucesso a identificação e o

combate de incêndios em áreas florestais, sem intervenção humana. A abordagem implementada

adota estratégia centralizada, mas com controle de ação distribuído, onde cada agente possui

autonomia na execução das tarefas que lhe são passadas. Os robôs de combate são fisicamente

simulados com a biblioteca ODE e as informações sensoriais de cada robô (e.g. GPS, bússola,

sonar) servem de entrada para uma Rede Neural que controla os atuadores do veículo para assim

realizar navegação com desvio de obstáculos de um ponto aleatório até um ponto de atuação no

combate ao incêndio. O ambiente desenvolvido apresenta simulação de propagação de fogo baseado

em tipos de vegetação, orientação e intensidade do vento. Os resultados das simulações demonstram

que a Rede Neural controla satisfatoriamente os robôs móveis e que o sistema proposto pode vir a

ter um papel muito importante no planejamento e execução de operações reais de combate a

incêndios florestais e possivelmente em outras tarefas similares, como acidentes nucleares ou

desastres ambientais (PESSIN, G. et al., 2007).

41

2.9.2 Estacionamento de um Veículo de Forma Autônoma Utilizando RNAs

Este artigo teve como objetivo descrever o sistema SEVA3D, que é um simulador utilizado

para o controle de veículos autônomos durante o estacionamento em vagas paralelas, utilizando um

ambiente tridimensional realista e sensores do tipo Sonar. Os resultados obtidos nas simulações

demonstraram que o sistema de controle possui a capacidade de controlar corretamente o veículo,

cumprindo seu objetivo principal: estacionar o veículo de modo autônomo corretamente na vaga,

sem se chocar contra os demais elementos presentes no ambiente. As verificações, tanto numéricas

quanto visuais, permitiram constatar que a tarefa pôde ser corretamente executada na maioria das

simulações realizadas, demonstrando que o sistema de controle do SEVA3D é bastante estável.

Atualmente o veículo real que serviu de modelo para o veículo virtual está sendo equipado com os

sensores do tipo sonar, a fim de validar o sistema de controle do SEVA3D (HEINEM, et al., 2006).

2.9.3 Dirigibilidade de Mini-Robôs com RNAs: Uma Experiência Acadêmica

Trata-se do desenvolvimento de um mini-robô (LEGO Mindstorm (LEGO®)), simulando o

movimento em um ambiente desconhecido. Para controlar o movimento desse conjunto

mecatrônico, utiliza-se a estratégia do paradigma SPA (sentir-planejar-agir), proposto por

Kortenkamp. Uma rede neural artificial, implementada pelo framework JOONE e um programa de

controle dos sensores de rotação que tem o objetivo de contar a variação de coordenadas

provocadas pelo movimento do robô. Os programas foram desenvolvidos em leJOS e um conjunto

de APIs que permitem a programação do RCX 1.0 da LEGO® Mindstorm™, numa linguagem

diferente da nativa. A escolha se justifica pelo interesse de usar as vantagens do JAVA no ambiente

do LEGO®, englobando uma JVM (Java Virtual Machine), a TinyVM, que substitui o firmware

original do RCX, e um conjunto de outras classes que interagem com a TinyVM e são usadas para

programar o robô. O programa controla sensores, atuadores e uma bússola embarcada, monitorada

por um sensor de luz, viabilizando a orientação e o posicionamento geográfico do robô. Fica para a

Rede Neural Artificial (RNA) a responsabilidade pela navegação diante dos obstáculos encontrados

no ambiente, ditando como o robô se movimentará ao encontrar uma obstrução na sua rota

planejada. (DINIZ, M. V. C., 2006).

42

3 PROJETO

Trata-se do projeto de uma Rede Neural Artificial capaz de comandar o deslocamento de um

veículo através de uma superfície plana, permitindo que o mesmo seja capaz de prever e assim optar

por um caminho no qual não ocorram obstáculos em seu trajeto.

A arquitetura escolhida para implementação da RNA foi o Perceptron de Múltiplas Camadas

(MLPs – Multilayer Perceptron). Foi realizada a implementação de diversas RNAs apresentando

cada uma delas uma configuração específica. Todas as RNAs foram treinadas e validadas com os

mesmos conjuntos de padrões (training.pat e validation.pat). Um exemplo de uma rede MLP é

visualizado na Figura 20.

Figura 20. Exemplo de uma RNA da arquitetura MLP.

Fonte: Braga, Carvalho e Ludermir, 2007.

Após diversas configurações quanto ao veículo no que diz respeito à quantidade e

localização dos sensores de entrada e das direções possíveis de serem tomadas pelo veículo, optou-

se pela implementação de uma RNA capaz de atender a um veículo autônomo dotado de três (3)

sensores do tipo sonares como entrada de dados, conforme Figura 21, e capacidade de direcionar-se

43

em oito (8) direções pré-programadas apresentadas em graus, são elas: 0 graus, 30 graus, 90 graus,

120 graus, 180 graus, 240 graus, 270 graus e 330 graus, como pode ser visualizado na Figura 22.

Figura 21. Sensores do Veículo Móvel.

Figura 22. Direções do Veículo Móvel

Os sensores de entrada trabalharam com valores entre 0 e 1, sendo 0 a total ausência de

obstáculo e 1 a presença de obstáculo imediatamente à frente. A RNA decide a direção do veículo

através da combinação entre os três valores de entrada e da respectiva proximidade que cada um

deles apresentar do valor 1.

Quando aos neurônios de saída da RNA, cada um deles corresponde a uma direção

específica do veículo, sendo que cada neurônio pode assumir o valor de 0, que significa que a

respectiva direção não será tomada, e 1, que assume ser esta a direção na qual o veículo deverá se

deslocar.

O método de treinamento adotado pela RNA é o backpropagation, e a função de ativação

escolhida é a função logística, recomendada quando se trabalha com valores entre 0 e 1.

44

3.1 Metodologia

A realização deste projeto seguiu a seguinte metodologia:

1) Estudo das RNAs MLPs: Realizado estudo aprofundado desta arquitetura de RNAs,

já que a mesma foi escolhida para ser utilizada neste projeto;

2) Estudo e definição do sensor a ser utilizado pela RNA neste projeto: Após ampla

pesquisa, optou-se por utilizar sensores do tipo sonar, devido à forma e amplitude

com a qual mapeiam o ambiente disponível;

3) Definição da quantidade de neurônios das camadas de entrada e saída: Após estudo

quanto ao comportamento esperado pelo veiculo planejado para utilização da RNA

criada nesse projeto, analise das possíveis direções que o mesmo deveria tomar, e

levando em conta o objetivo de criar uma RNA o menos exigente possível quanto ao

fator processamento, optou-se por uma rede com três neurônios na camada de

entrada e oito neurônios na camada de saída;

4) Definição da função de ativação a ser utilizada pela RNA: Considerando o fato da

RNA operar basicamente com valores em um intervalo entre 0 e 1, considerou-se

como melhor opção a função de ativação logística;

5) Definição do ambiente a ser utilizado na manipulação da RNA: Após análise de seis

(6) ambientes de desenvolvimento de RNAs, a serem especificados na seção 2.7,

optou-se pelo ambiente desenvolvido na Wilhelm Schickard Institute for Computer

Science (WSI) em Tübingen, Alemanha, denominado Java Neural Network

Simulator (JavaNNS);

6) Definição do ambiente a ser utilizado na virtualização do veiculo a utilizar a RNA

desenvolvida neste projeto: Após análise de alguns ambientes de simulação de robôs,

a serem especificados na seção 2.8, optou-se pelo ambiente em Java denominado

Simbad 3D;

7) Criação dos arquivos de padrões da RNA: Definida a quantidade de neurônios na

camada de entrada e na camada de saída, e escolhido o ambiente a ser utilizado para

a manipulação da RNA, realizou-se o estudo do layout dos arquivos de treinamento e

45

validação utilizados pelo ambiente. Com base nesse estudo, foram criados

manualmente dois arquivos de padrões, um arquivo para treinamento, denominado

training.pat, com 911 entradas de dados, e um arquivo para validação, denominado

validation.pat, composto por 200 entradas de dados;

8) Definição da quantidade de neurônios da camada intermediária da RNA: Após

realizar pesquisas na literatura de RNAs, ler trabalhos similares e realizar diversos

testes no ambiente JavaNNS utilizando diferentes configurações quando ao número

de camadas e quantidade de neurônios concluiu-se que a camada de neurônios

intermediaria deveria possuir entre 25 a 30 neurônios;

9) Criação, Treinamento e Validação da RNA no JavaNNS: Foram criadas diversas

RNAs no ambiente JavaNNS, com diversas configurações quanto à quantidade de

neurônios na camada intermediaria, todavia todas sofreram o processo de

treinamento e validação utilizando os mesmo arquivos de padrões;

10) Geração do Código em Linguagem C utilizando o arquivo de topologia gerado pelo

ambiente JavaNNS: Após finalizado o treinamento e validação da RNA no ambiente

JavaNNS, foi utilizada a ferramenta snns2c.exe, disponibilizado no kernel do

software SNNS para converter o arquivo criado pelo JavaNNS contendo a RNA para

um arquivo fonte na linguagem C;

11) Análise estatística do arquivo de resultado gerado pelo ambiente JavaNNS: Após o

Treinamento e Validação da rede realizado pelo ambiente JavaNNS. Para isso foi

utilizado o software analyser.exe, disponibilizado no Kernel do software SNNS;

12) Desenvolvimento de um software contendo o código gerado pelo snns2c.exe: A

partir desse fonte foi criado um software em C capaz de ler um arquivo de padrões

de entrada e gerar um arquivo de padrões de saída, contendo a saída da RNA em

questão, que foi comparado com a saída esperada da rede;

13) Desenvolvimento de uma DLL contendo o código gerado pelo snns2c.exe: Foram

criado dois (02) arquivos DLL, ambos utilizando o código fonte criado pelo software

snns2c.exe, uma foi criada no ambiente Embarcadero C++ Builder 2010 e outra no

ambiente Bloodshed Dev-C++ 4;

46

14) Desenvolvimento de uma aplicação capaz de utilizar as DLLs criadas: Foi

desenvolvida uma aplicação em linguagem C capaz de utilizar as DLLs previamente

criadas a fim de analisar a saída gerada pelas mesmas;

15) Simulação do veículo que utiliza a RNA: Criação de um ambiente virtual no

simulador Simbad 3D com a finalidade de demonstrar o funcionamento da RNA,

utilizando a DLL já criada através da utilização da biblioteca JNA; e

16) Documentação do projeto: Todo o projeto está detalhadamente documentado, os

dados de entrada e saída da rede, assim como os códigos fonte encontram-se nos

apêndices desse documento.

3.2 Requisitos Funcionais

Os requisitos funcionais descrevem as funcionalidades que o sistema deve atender, são eles:

· RF01: O sistema deve se locomover sem o auxílio humano;

· RF02: O sistema deve desviar de obstáculos antes de se chocar com os mesmos;

· RF03: O sistema deve evitar caminhos que apresentarem um diâmetro de passagem

menor do que o diâmetro do próprio veículo que utiliza a RNA; e

3.3 Requisitos não Funcionais

Os requisitos não funcionais são aqueles que não estão relacionados com a funcionalidade

do sistema, são eles:

· RNF01: A RNA deve ser desenvolvida e manipulada em um ambiente não

proprietário;

· RNF02: O código fonte gerado através do arquivo da RNA deve ser independente de

plataformas.

47

3.4 Regras de Decisão da Rede Neural Artificial

As regras de decisão da RNA foram criadas para auxiliar na criação dos arquivos de padrões

usados no treinamento e na validação da RNA, trata-se de um conjunto de normas que tem como

finalidade reger o comportamento da RNA, é um espelho quanto ao comportamento que o sistema

deve possuir. As regras são apresentadas em ordem decrescente, sendo a primeira a regra mais geral

e a última a mais específica.

A Figura 23 apresenta um conjunto de entradas e saídas que obedecem as regras

apresentadas na Caixa de Texto 1:

Se ((Sensor Esquerdo <= 0.90) e (Sensor Central <= 0.90) e (Sensor Direito <= 0.90)) então:

•Se (Sensor Central = Sensor Esquerdo) e (Sensor Central < Sensor Direito) Faça (Direção = 0º)

•Se (Sensor Central = Sensor Direito) e (Sensor Central < Sensor Esquerdo) Faça (Direção = 0º)

•Se (Sensor Central = Sensor Esquerdo) e (Sensor Central > Sensor Direito) Faça (Direção = 30º)

•Se (Sensor Central = Sensor Direito) e (Sensor Central > Sensor Esquerdo) Faça (Direção = 330º)

•Se (Sensor Central < Sensor Esquerdo) e (Sensor Direito > Sensor Esquerdo) Faça (Direção = 0º)

•Se (Sensor Central < Sensor Direito) e (Sensor Direito < Sensor Esquerdo) Faça (Direção = 0º)

•Se (Sensor Direito = Sensor Esquerdo) e (Sensor Central < Sensor Esquerdo) Faça (Direção = 0º)

•Se (Sensor Direito < Sensor Esquerdo) e (Sensor Central > Sensor Esquerdo) Faça (Direção = 30º)

•Se (Sensor Direito = Sensor Esquerdo) e (Sensor Central > Sensor Direito) Faça (Direção = 90º)

•Se (Sensor Direito > Sensor Esquerdo) e (Sensor Central > Sensor Direito) Faça (Direção = 330º)

Se ((Sensor Esquerdo >= 0.91) e (Sensor Central <= 0.90) e (Sensor Direito <= 0.90)) Faça: Direção = 90º

Se ((Sensor Esquerdo <= 0.90) e (Sensor Central <= 0.90) e (Sensor Direito >= 0.91)) Faça: Direção = 270º

Se ((Sensor Esquerdo <= 0.90) e (Sensor Central >= 0.91) e (Sensor Direito <= 0.90)) Faça:

•Se (Sensor Direito > Sensor Esquerdo) Então (Direção = 90º)

•Se (Sensor Esquerdo < Sensor Direito) Então (Direção = 270º)

Se ((Sensor Esquerdo >= 0.91) e (Sensor Central >= 0.91) e (Sensor Direito <= 0.90)) Faça: Direção = 90º

Se ((Sensor Esquerdo <= 0.90) e (Sensor Central >= 0.91) e (Sensor Direito >= 0.91)) Faça: Direção = 270º

Se ((Sensor Esquerdo >= 0.91) e (Sensor Central <= 0.90) e (Sensor Direito >= 0.91)) Faça: Direção = 180º

Se ((Sensor Esquerdo >= 0.91) e (Sensor Central >= 0.91) e (Sensor Direito >= 0.91)) Faça: Direção = 180º

Se ((Sensor Esquerdo <= 0.98) e (Sensor Central >= 0.98) e (Sensor Direito >= 0.98)) Faça: Direção = 240º

Se ((Sensor Esquerdo >= 0.98) e (Sensor Central >= 0.98) e (Sensor Direito <= 0.98)) Faça: Direção = 120º

Se ((Sensor Esquerdo >= 0.98) e (Sensor Central >= 0.98) e (Sensor Direito >= 0.98)) Faça: Direção = 180º

Se ((Sensor Esquerdo <= 0.90) e (Sensor Central >= 0.91) e (Sensor Direito <= 0.90)) Faça:

•Se (Sensor Esquerdo = Sensor Direito) Faça (Direção = 90º)

Caixa de Texto 1. Regras de Comportamento da Rede Neural Artificial.

48

Figura 23. Exemplo de dados que obedece ao conjunto de regras apresentadas

Uma alternativa mais simples de se visualizar o conjunto de regras apresentado é através da

Tabela 5, que é apresentada a seguir:

Sensor Esquerdo Sensor Central Sensor Direito Direção A (<= 0.90) >= 91º A (<= 0.90) 90º

>= 0.98 >= 0.98 >= 0.98 180º >= 0.98 >= 0.98 <= 0.98 120º <= 0.98 >= 0.98 >= 0.98 240º >= 0.91 >= 0.91 >= 0.91 180º >= 0.91 <= 0.90 >= 0.91 180º <= 0.90 >= 0.91 >= 0.91 270º >= 0.91 >= 0.91 <= 0.90 90º

<= 0.90 >= 0.91 <= 0.90

VSE < VSD 270º VSD < VSE 90º

<= 0.90 <= 0.90 >= 0.91 270º >= 0.91 <= 0.90 <= 0.90 90º

<= 0.90 <= 0.90 <= 0.90

VSD > VSE VSC > VSD 330º VSD = VSE VSC > VSD 90º VSD < VSE VSC > VSE 30º VSD = VSE VSC < VSE 0º VSC < VSD VSD < VSE 0º VSC < VSE VSD > VSE 0º VSC = VSD VSC > VSE 330º VSC = VSE VSC > VSD 30º VSC = VSD VSC < VSE 0º VSC = VSE VSC < VSD 0º

Tabela 5. Regras de decisão da Rede Neural Artificial.

49

3.5 Funcionamento da RNA e do Veículo

Para uma melhor compreensão quanto ao funcionamento do veículo, é apresentado a seguir

em detalhes como o mesmo se comporta em relação aos dados de entrada enviados pelos três (3)

sensores do veículo e quanto aos oito (8) sinais de saída retornados pela rede neural artificial. A

Figura 24 apresenta um layout contendo os três (3) valores de entrada seguidos dos oito (8) valores

de retorno da RNA, acima de cada valor de entrada encontra-se uma seta indicando sua direção, e

sobre cada valor de retorno há o indicador referente à direção que o mesmo representa.

Figura 24. Layout explicativo quanto ao funcionamento do veículo.

A seguir são apresentados cinco (5) seqüências de valores contendo os três (3) valores de

entradas e seus respectivos oito (8) valores de saída. Após será apresentado o layout explicativo

quanto ao significado de cada uma dessas saídas.

Na Primeira seqüência, apresentada na Figura 25, é possível perceber que os valores

esquerdo (0.30), central (0.24) e direito (0.68) são valores considerados neutros, pois são valores

inferiores à 0.80, isso significa que não há risco de choque imediato, por esse motivo é considerado

como melhor opção de direção a seguir o sensor que retornar o menor valor, no caso da Figura 25,

tal valor refere-se ao sensor central (0.24).

50

Figura 25. Primeira seqüência de valores para análise.

Figura 26. Segunda seqüência de valores para análise.

51

Na segunda seqüência de valores, apresentada na Figura 26, é possível perceber que os

valores esquerdo (0.56), central (0.61) e direito (0.05) são valores considerados neutros, todavia o

valor retornado pelo sensor direito é extremamente baixo, e sendo assim, é a melhor opção no que

diz respeito a qual direção o veículo deve seguir.

Na terceira seqüência de valores, apresentada na Figura 27, é possível perceber que os

valores esquerdo (0.65) e direito (0.27) são valores neutros enquanto o valor central (0.91) é

consideravelmente alto, ao considerarmos os três (3) valores, torna-se evidente que a direção a ser

tomada é à direita, todavia o valor do sensor central implica em alta possibilidade de choque, o que

exige que o veículo realize uma curva mais fechada, esse fato pode ser visto na Figura 27.

Figura 27. Terceira seqüência de valores para análise.

Na quarta seqüência de valores, apresentada na Figura 28, é possível perceber que os valores

esquerdo (0.62), central (0.76) e direito (0.67) são valores considerados neutros, todavia o valor

retornado pelo sensor esquerdo é o mais baixo, e sendo assim, é a melhor opção no que diz respeito

a qual direção o veículo deve seguir.

Na quinta seqüência de valores, apresentada na Figura 29, é possível perceber que os valores

esquerdo (0.19) e central (0.43) são valores neutros enquanto o valor direito (0.91) é

consideravelmente alto, ao considerarmos os três (3) valores, torna-se evidente que a direção a ser

52

tomada é à direita, todavia o valor do sensor direito implica em alta possibilidade de choque, o que

exige que o veículo realize uma curva mais fechada, esse fato pode ser visto na Figura 29.

Figura 28. Quarta seqüência de valores para análise.

Figura 29. Quinta seqüência de valores para análise.

53

4 IMPLEMENTAÇÃO

Nesta seção é apresentada a implementação do sistema, incluindo métodos e componentes

utilizados para isso. Serão também apresentados os procedimentos utilizados para treinamento,

validação e teste do mesmo. Essa seção abrange tanto os aspectos virtuais quanto os aspectos

físicos relacionados com o projeto.

A seção 4.1 e suas subseções estão relacionadas à utilização do ambiente de criação e

manipulação da Rede Neural Artificial JavaNNS e dos aplicativos relacionados ao mesmo, como o

snns2c.exe (utilizado para converter o arquivo de padrões da Rede Neural Artificial gerado pelo

JavaNNS para um arquivo fonte na linguagem C) e o analyzer.exe (utilizado para analisar o arquivo

de resultado gerado pelo JavaNNS de forma a retornar de forma estatística as informações

referentes aos acertos, erros e padrões não reconhecidos pela Rede Neural Artificial). Aqui é criada,

treinada e validada a Rede Neural Artificial.

A seção 4.2 e suas subseções estão relacionadas à criação e utilização de Bibliotecas de

ligação Dinâmica ou, como são mais conhecidas, Dinamic Link-library (DLL). São detalhadas sua

criação a partir do código fonte gerado pelo snns2c.exe, sua utilização em um aplicativo

desenvolvido em linguagem C e até a verificação do layout de suas funções internas antes mesmo

de utilizá-la.

A seção 4.3 e suas subseções estão relacionadas à utilização do ambiente de simulação de

Robôs Simbad 3D e dos aplicativos e bibliotecas relacionados com o mesmo, como o Java3D (uma

biblioteca gráfica necessária para a utilização do Simbad 3D) e o JNA (uma biblioteca utilizada

para realizar chamadas de bibliotecas externas de forma simples e eficiente, sem que seja necessário

a utilização do JNI). Aqui são criados os mundos e robôs virtuais onde é demonstrado o

desempenho da Rede Neural Artificial em um ambiente simulado.

4.1 Definição do Ambiente de Manipulação da RNA

Para definir qual seria o ambiente a ser utilizado neste projeto para realizar toda a

manipulação da RNA, foi realizada uma pesquisa, na qual foram analisados um total de seis (6)

ambientes de desenvolvimento, sendo que os três (3) de maior destaque foram o Java Neural

Network Simulator (JavaNNS), o Stuttgart Neural Network Simulator (SNNS) e o Java Object

54

Neural Engine (Joone), já mencionados e apresentados na seção 2.7 deste documento. Os demais

ambientes testados foram os seguintes:

· Artificial Neural Networks Framework (ANNeF): trata-se de um framework,

implementado em linguagem Java, que oferece condições de realizar inúmeras

aplicações portáveis usando uma API bastante simplificada, cujo usuário poderá

adaptar este conjunto de classes para as suas necessidades ou criar outros modelos de

redes neurais. Está disponível em: http://www.inf.unisinos.br/~jrbitt/annef/.

· Fast Artificial Neural Network Library (FANN): trata-se de uma biblioteca livre de

redes neurais com código aberto, que implementa redes neurais artificiais de

múltiplas camadas em linguagem C. Ele inclui um framework para simples

manipulação do conjunto de dados de treinamento. Esta biblioteca livre encontra-se

disponível em: http://leenissen.dk/fann/.

· Scilab: é um pacote de software científico para computações numéricas fornecendo

um poderoso ambiente computacional aberto para aplicações científicas e de

engenharia. Trata-se de um software de código aberto. Desde 1994 tem sido

distribuído gratuitamente junto com o código fonte, através da Internet. Atualmente,

é utilizado em ambientes industriais e educacionais em todo o mundo. Esse software

está disponível em: http://www.scilab.org/platform/.

Embora todos os seis (6) ambientes apresentem-se como ótimas opções para o

desenvolvimento de RNAs, a escolha baseou-se na disponibilidade de recursos oferecidos, na

simplicidade de manipulação da mesma e no reconhecimento da ferramenta no meio acadêmico.

Após análise desses três (3) fatores, optou-se pela ferramenta denominada JavaNNS, conforme

tabela 6.

Recursos Oferecidos Simplicidade de Uso Reconhecimento Acadêmico Total Ambiente (1 a 3) (1 a 3) (1 a 3)

JavaNNS 3 3 3 9 SNNS 3 2 3 8 JOONE 2 2 2 6 ANNeF 2 1 2 5 FANN 2 1 2 5 Scilab 2 1 3 6

Tabela 6. Análise e Pontuação dos Ambientes de Criação de RNAs.

55

4.1.1 Criação dos Arquivos de Padrões

Após definida a ferramenta a ser utilizada para a manipulação da RNA, iniciou-se o estudo

quanto aos layouts de arquivos aceitos pela ferramenta, os mesmos apresentaram grande

simplicidade. São constituídos por um cabeçalho padrão, onde são inseridas algumas informações

quanto à quantidade de neurônios de entrada e de saída da RNA, a quantidade de entradas de

treinamento e os dados de treinamento. A Figura 30 apresenta o formato padrão oficial do arquivo

de padrões.

Figura 30. Layout oficial do arquivo de padrões do JavaNNS e SNNS.

Todavia, os padrões de treinamento podem ser apresentados de forma ainda mais simples

para o ambiente JavaNNS, como demonstrado na Figura 31.

Figura 31. Layout de padrões de arquivo simples aceito pelo JavaNNS e SNNS.

Observe que, como é informada no arquivo, a quantidade de neurônios na camada de

entrada (No. of input units) e a quantidade de neurônios na camada de saída (No. of output units), a

56

ferramenta reconhece os três (3) primeiros valores da seqüência como dados de entrada da rede,

enquanto os demais oito (8) valores da seqüência são automaticamente reconhecidos como dados de

saída da RNA. O campo posicionado na quarta linha do arquivo (No. of patterns) informa a

quantidade de entradas de treinamento contidas no arquivo. Após abrir o arquivo no formato

simples na ferramenta JavaNNS, em qualquer momento você pode salva-lo, através do menu “File –

Save Data...”, e automaticamente ele será salvo no formato padrão oficial, conforme apresentado na

Figura 24.

Os arquivos de treinamento e validação foram criados manualmente, seguindo as regras

especificadas neste documento, na seção 3.4. O arquivo de treinamento possui novecentos e onze

(911) padrões de entrada, enquanto o arquivo de validação possui duzentos (200) padrões de

entrada. Cada arquivo foi verificado oito (8) vezes, em dias distintos, sempre observando as regras

citadas na seção 3.4.

4.1.2 Instalação e Detalhamento da Ferramenta JavaNNS

Para iniciar a utilização do ambiente JavaNNS, basta descompactá-lo em qualquer diretório,

a ferramenta pode ser executada digitando a seguinte linha de comando no command prompt:

“java -jar JavaNNS.jar” ou clicando duas vezes no arquivo JavaNNS.jar.

O JavaNNS utiliza as seguintes extensões para seus arquivos:

· .net arquivos de rede (unidades e ligações);

· .pat arquivos de padrões;

· .cfg arquivo de configurações;

· .txt arquivos de texto (log files); e

· .res arquivos de resultados (ativações de unidades).

4.1.2.1 Criando a Rede Neural Artificial

Já com o ambiente JavaNNS sendo executado, escolha o menu Tools, a opção Create,

depois a opção Layers, como visto na Figura 32:

57

Figura 32. Criando camadas para a RNA no JavaNNS.

O ambiente apresenta uma caixa de diálogo para a criação das camadas, como demonstra a

Figura 33. Nesta caixa as seguintes informações são solicitadas:

· Width: o número de neurônios a serem criados na posição horizontal;

· Height: o número de neurônios a serem criados na posição vertical;

· Top left position: posição inicial na qual devem ser criados os neurônios;

· Unit type: define o tipo de neurônio a ser criado, pode-se escolher entre a camada de

entrada, a camada oculta, a camada de saída, entre outras;

· Activation function: define qual será a função de ativação a ser utilizada.

· Output function: define qual será a função de saída a ser utilizada.

· Layer number: número da camada a ser criada; e

· Subnet number: número da rede interna a ser criada.

58

Figura 33. Caixa de dialogo para a criação das camadas.

Após a criação das camadas da RNA, devem ser criadas as conexões entre as camadas. Para

tal, escolha o menu Tools, a opção Create, depois a opção Connections, como pode ser visualizado

na Figura 34.

Figura 34. Criando conexões entre as camadas de neurônios.

O ambiente apresenta uma caixa para definição quanto ao tipo de conexões a serem criadas,

apresentada na Figura 35, na qual são apresentadas as seguintes opções:

· Connect selected units: permite selecionar os neurônios desejados e criar as conexões

manualmente;

· Connect feed-forward: cria conexões feed-forward; e

59

· Auto-associative: cria conexões auto associativas.

Figura 35. Caixa de definição quanto ao tipo de conexões a serem criadas.

Na Figura 36 é apresentada uma RNA criada no ambiente JavaNNS, mas ainda não treinada.

Figura 36. RNA criada no ambiente JavaNNS.

4.1.2.2 Manipulando a Rede Neural Artificial

Após criada a RNA, deve-se inicializar, treinar, manipular entradas e validar a mesma, para

executar essas tarefas, deve-se abrir o “Painel de Controle”. Para isso, escolha no menu Tools a

opção Control Panel, como visto na Figura 37.

60

Figura 37. Abrindo o Painel de Controle.

Será exibida a caixa de diálogo do “Painel de Controle”, que contém as seguintes abas:

1) Initializing: inicia os pesos da RNA. A função de inicialização deve ser escolhida em

Initializing function, feito isso basta definir os parâmetros da função escolhida. Pode-

se inicializar a RNA nessa aba clicando no botão Init.

2) Updating: define a função de atualização. A função deve ser escolhida em Updating

function, feito isso basta definir os parâmetros da função escolhida.

3) Learning: define as opções para a aprendizagem da rede. A função de aprendizado

deve ser escolhida em Learning function, feito isso, basta definir os parâmetros da

função escolhida. Nessa aba há três (3) botões:

· Init: que inicializa a rede da mesma forma que ocorre na aba Initializing;

· Learn Current: se selecionado, a rede é treinada utilizando apenas uma

entrada do arquivo de padrões; e

· Learn All: que inicia o treinamento da rede utilizando todas as entradas

contidas no arquivo de padrões.

Existem ainda dois campos, são eles:

· Cicles: que especifica o número de ciclos de aprendizagem; e

· Steps: que especifica o número de passos de atualização da rede. Em redes

comuns (topological order, por exemplo), um passo é suficiente. Em redes

recursivas, ou com outros modos de atualização, mais de um passo pode ser

necessário.

61

Por último há o checkbox Shuffle que caso esteja desmarcado, os padrões serão

lidos do arquivo ordenadamente, e caso esteja marcado, os mesmos padrões serão

lidos do arquivo aleatoriamente.

4) Pruning: define as opções de poda para a RNA. O método de poda deve ser definido

em Method, feito isso deve-se definir os parâmetros do método escolhido e então

clicar no botão Prune.

5) Patterns: define os conjuntos ou arquivos de entrada e saída da RNA, trata-se dos

arquivos de treinamento e validação. A função de re-mapeamento deve ser definida

em Remapping function, feito isso deve-se definir os parâmetros da função escolhida.

Em Training set escolha o arquivo de treinamento a ser utilizado pela RNA e em

Validation set defina o arquivo a ser utilizado pela RNA para validação. Para

carregar os arquivos no ambiente escolha o menu File e a opção Open, em seguida

selecione os arquivos, que devem possuir a extensão .pat e carregue-os no sistema.

6) Subpatterns: apresenta o parâmetros referentes aos subconjuntos de entrada e saída,

quando utilizados.

Figura 38. Painel de Controle do JavaNNS.

4.1.3 As Redes Neurais Artificiais Criadas no JavaNNS.

Nesta seção serão apresentadas as RNAs criadas no ambiente JavaNNS. São apresentados

quatro (4) RNAs, os respectivos dados e resultados apresentados por elas no ambiente JavaNNS.

62

4.1.3.1 Primeira RNA apresentada – GSC200901-A

A primeira RNA apresentada nesse documento, denominada GSC200901-A, definida assim

para uma melhor organização deste documento, foi criada com as seguintes especificações:

· Camada de Entrada (Input): contém três (3) neurônios ativados pela função de ativação Act Identity e utilizando a função de saída Out Identity.

· Camada Oculta (Hidden): contém uma (1) camada composta por vinte e sete (27) neurônios ativados pela função de ativação Act Logistic e utilizando a função de saída Out Identity.

· Camada de Saída (Output): contém oito (8) neurônios ativados pela função de ativação Act Logistic e utilizando a função de saída Out Identity.

· Conexões: feed-forward.

· Inicialização: inicializada com valores entre 0 e 1, utilizando a função de inicialização Random Weights.

· Função de Atualização: topological order.

· Função de Aprendizado: backpropagation, com taxa de aprendizado (η) de 0.2 e erro acumulado (dmax) de 0.1.

· Ciclos: 20000 SSE.

· Passos: 1

· Função de Re-mapeamento: não foi utilizada.

· Arquivo de Padrões de Treinamento: training.pat com 911 padrões de entrada.

· Arquivo de Padrões de Validação: validation.pat com 200 padrões de entrada.

A Figura 39 apresenta a RNA após o treinamento e validação no ambiente JavaNNS.

63

Figura 39. RNA GSC200901-A Treinada.

Figura 40. Arquivo log de Treinamento e Validação da RNA GSC200901-A.

64

A Figura 40 apresenta os resultados do treinamento e validação realizados no JavaNNS

enquanto a Figura 41 nos apresenta o gráfico de erro (∑e2).

Figura 41. Gráfico de erro (∑e2) e validação da RNA GSC200901-A.

4.1.3.2 Segunda RNA Apresentada – GSC200901-B

A segunda RNA apresentada nesse documento, a GSC200901-B possui basicamente a

mesma configuração da rede GSC200901-A, exceto pela quantidade de neurônios na camada oculta

e pelo total de ciclos realizados:

· Camada de Entrada (Imput): contém três (3) neurônios ativados pela função de ativação Act Identity e utilizando a função de saída Out Identity.

· Camada Oculta (Hidden): contém uma (1) camada composta por dezessete (17) neurônios ativados pela função de ativação Act Logistic e utilizando a função de saída Out Identity.






65


· Passos: 1




Embora essa RNA possua menos neurônios na camada oculta, ela apresentou melhores

resultados de validação que a rede anterior, a GSC200901-B. A Figura 42 apresenta a arquitetura da

RNA, a Figura 43 apresenta os resultados do treinamento e validação e a Figura 44 apresenta o

gráfico de erro (∑e2).

Figura 42. RNA GSC200901-B Treinada.

66

Figura 43. Arquivo log de Treinamento e Validação da RNA GSC200901-B.

Figura 44. Gráfico de erro (∑e2) e validação da RNA GSC200901-B.

4.1.3.3 Terceira RNA Apresentada – GSC200901-C

A terceira RNA apresentada nesse documento, a GSC200901-C é uma RNA com duas

camadas ocultas e uma quantidade reduzida de neurônios em cada uma delas.

67


· Camada Oculta (Hidden): contém duas (2) camadas ocultas, cada uma com dez (10) neurônios ativados pela função de ativação Act Logistic e utilizando a função de saída Out Identity.







· Passos: 1




Figura 45. RNA GSC200901-C Treinada.

68

A RNA GSC200901-C, utilizando o método de parada padrão do ambiente JavaNNS,

apresentou problemas de aprendizado, o método mais indicado para o treinamento dessa rede seria

o método conhecido como validação cruzada, porém o JavaNNS não trabalha com esse método. A

arquitetura da RNA é apresentada na Figura 45, os resultados do treinamento e validação realizados

no JavaNNS são apresentados na Figura 46 enquanto a Figura 47 apresenta o gráfico de erro (∑e2).

Figura 46. Arquivo log de Treinamento e Validação da RNA GSC200901-C.

69

É possível perceber que a validação está ocorrendo inversamente ao treinamento, para essa

rede o mais indicado seria utilizar o método de validação cruzada, a fim de interromper o

treinamento. Considerando o arquivo de log apresentado na Figura 46, é provável que o método

interrompe-se o treinamento da RNA GSC200901-C no passo 5000. Na Figura 47 é possível

confirmar a situação da RNA em seu gráfico de erro (∑e2).

Figura 47. Gráfico de erro (∑e2) e validação da RNA GSC200901-C.

Como pode ser visualizado no gráfico de erro, embora a RNA apresente uma diminuição no

erro quanto ao treinamento, a validação não acompanha a queda, pelo contrário, segue em caminho

inverso, há ainda certa instabilidade no gráfico de erro, picos durante o treinamento, é uma situação

ideal para o uso da técnica de validação cruzada.

Este método consiste em uma técnica estatística, para validar o modelo obtido durante o

treinamento da rede, utilizando um conjunto de dados diferentes dos usados, para estimar os

parâmetros durante o treinamento (HAYKIN, 2001). O método consiste em acompanhar a evolução

do aprendizado nas curvas correspondentes aos subconjuntos de dados de treinamento e de

70

validação. Deste modo, o treinamento é interrompido, quando a curva de validação decresce a um

erro mínimo, e antes de começar a crescer, conforme o treinamento continua. (MÓDULO DE

VALIDAÇÃO CRUZADA PARA TREINAMENTO DE REDES NEURAIS ARTIFICIAIS COM

ALGORITMOS BACKPROPAGATION E RESILIENT PROPAGATION, 2007)

4.1.3.4 Quarta RNA Apresentada – GSC200901-D

A quarta RNA apresentada nesse documento, a GSC200901-D é uma RNA com duas

camadas ocultas e uma quantidade maior de neurônios em cada uma delas.


· Camada Oculta (Hidden): contém duas (2) camadas ocultas, cada uma com vinte e sete (27) neurônios ativados pela função de ativação Act Logistic e utilizando a função de saída Out Identity.







· Passos: 1




Essa RNA apresentou a maior diferença entre o erro apresentado pelo treinamento e a taxa

apresentada na validação. A Figura 48 apresenta a arquitetura da RNA GSC200901-D, a Figura 49

apresenta os resultados obtidos no arquivo de log e a Figura 50 apresenta o gráfico de erro (∑e2) da

RNA.

71

Figura 48. RNA GSC200901-D Treinada.

Figura 49. Arquivo log de Treinamento e Validação da RNA GSC200901-D.

72

Figura 50. Gráfico de erro (∑e2) e validação da RNA GSC200901-D

4.1.4 Convertendo o Arquivo da RNA para a Linguagem C

Ao utilizar o ambiente JavaNNS para a criação e manipulação de RNAs, tem-se a opção de

salvar diversos arquivos relacionados com a rede então manipulada, conforme já mencionado na

seção 3.2.3, uma das extensões criadas pelo ambiente são os arquivos net, que são os responsáveis

por armazenar a topologia da RNA, suas unidades e ligações. Por ser uma ferramenta derivada do

SNNS 4.2, os arquivos gerados pelo JavaNNS são idênticos aos arquivos gerados pelo SNNS, por

essa razão, pode-se utilizar os aplicativos que acompanham o SNNS para manipular arquivos

gerados no JavaNNS. Um destes aplicativos chama-se snns2c.exe, e sua função é converter o

arquivo contendo os padrões de rede gerados pelo SNNS ou JavaNNS para arquivos fonte em

linguagem de programação C, como demonstrado na Figura 51.

Figura 51. Convertendo a Rede para a Linguagem C com o snns2c.exe

73

A sintaxe e utilização deste aplicativo é extremamente simples, e resume-se a uma única

linha de comando, bastando digitar no prompt de comando a linha de código apresentada na Figura

52:

snns2c.exe <arquivo-da-rna.net> <nome-da-função.c>

Figura 52. Comando de utilização do snns2c.exe.

O arquivo em linguagem c criado contém a RNA pura, com seus pesos e treinada, o código

não possui os trechos referentes ao treinamento, pois os mesmos não são mais necessários, já que a

rede já foi treinada pelo JavaNNS. Esse arquivo gerado pode ser usado em um aplicativo ou mesmo

em uma dll. Na Figura 53 é possível visualizar um trecho do arquivo da RNA gerado pelo

JavaNNS, enquanto na Figura 54 encontra-se um trecho do arquivo gerado em linguagem C.

74

Figura 53. Trecho do arquivo de rede gerado pelo JavaNNS.

Figura 54. Trecho do arquivo em linguagem C gerado pelo snns2c.exe.

4.1.5 Analisando o Arquivo de Resultado da RNA.

Outro aplicativo disponibilizado pelo SNNS e utilizado neste projeto denomina-se

analyse.exe, esse aplicativo analisa o arquivo de resultados criado pelo JavaNNS após o término do

treinamento da RNA. O arquivo de resultados a ser analisado pelo aplicativo deve possuir os

padrões de treinamento e as saídas da RNA. A sintaxe desse aplicativo é apresentado na Figura 55:

analyse [-opções]

Figura 55. Comando de utilização do analyse.

É possível optar entre os vários parâmetros em qualquer ordem:

· -w é impresso o número dos padrões classificados como corretos;

75

· -r é impresso o número dos padrões classificados como errados;

· -u é impresso o número dos padrões não classificados;

· -a o mesmo que -w -r -u;

· -v cada número impresso é precedido por uma das seguintes palavras: “correto”, “errado” ou “não classificado”, dependendo do resultado de sua classificação;

· -s informações estáticas quanto aos padrões “correto”, “errado” e “não classificado”;

· -c o mesmo que -s, mas são demonstradas estatísticas para cada unidade de saída;

· -i nome do “arquivo de resultado” que será analisado (-i <arquivo de entrada>);

· -o nome do arquivo que será criado pelo analyzer (-o <arquivo de saída>);

· -e define o nome da função de análise (-e <função>);

· -l primeiro parâmetro da função de análise (-l <float>); e

· -h segundo parâmetro da função de análise (-h <float>).

Esse aplicativo foi utilizado para obter informações com maior precisão quanto ao resultado

do treinamento das RNAs apresentadas neste projeto. Na Figura 56 é apresentado um trecho do

arquivo de resultado da rede GSC200901-B, e na Figura 57 o resultado da linha de comando

responsável pelas informações estatísticas referentes ao arquivo de resultados dessa mesma rede.

Figura 56. Trecho do Arquivo de Resultados da RNA GSC200901-B.

76

Figura 57. Utilização do aplicativo analyzer.

A utilização deste aplicativo retornou que a rede GSC200901-B respondeu corretamente a

901 padrões (98,90 %) e incorretamente a 10 padrões (1,10 %), resultados que ainda segundo o

aplicativo, representa um erro de 11,604062. Lembrando que foram utilizados os padrões de

treinamento nessa demonstração.

4.1.6 Comparando as RNAs apresentadas.

O aplicativo analyser foi utilizado para comparar as quatro RNAs apresentadas neste

projeto, como pode ser verificado na Tabela 7 (arquivos de resultados de treinamento) e na Tabela 8

(arquivos de resultados de validação).

Padrões Reconhecidos RNA

Total de Padrões

Corretos Incorretos

Padrões Ñ Reconhecidos

% de Acertos

Erro da RNA No

Treinamento

A 911 902 1 8 99,01 10,712665 B 911 901 1 9 98,90 11,604062 C 911 905 0 6 99,34 8,208152 D 911 904 0 7 99,23 7,444362

Tabela 7. Resultados obtidos pelo Analyzer quanto ao Treinamento da RNA.

Padrões Reconhecidos RNA

Total de Padrões

Corretos Incorretos

Padrões Ñ Reconhecidos

% de Acertos

Erro da RNA Na

Validação

A 200 182 3 15 91,00 17,447292 B 200 185 4 11 92,50 16,745084 C 200 185 10 5 92,50 24,464050 D 200 186 7 7 93,00 21,461576

Tabela 8. Resultados obtidos pelo Analyzer quanto a Validação da RNA.

77

A utilização desse aplicativo nos permite obter informações estatísticas mais precisas quanto

ao treinamento e a validação de redes neurais artificiais criadas no ambiente JavaNNS, permitindo

que seja possível a escolha da RNA considerando dados consideravelmente detalhados, como por

exemplo a quantidade de padrões reconhecidos incorretamente ou a quantidade de padrões não

reconhecidos pela rede, destacando que não se trata da mesma informação e que possuem pesos

diferentes quanto ao cálculo do erro da RNA.

Ao observar os dados da Tabela 7, pode-se observar que a RNA que apresentou o melhor

resultado foi à rede GSC200901-D, pois além de apresentar a maior porcentagem de acertos,

também apresentou o menor erro. Todavia esses dados são referentes apenas ao treinamento e, ao se

analisar a Tabela 8, responsável pelos dados de validação, constata-se que a melhor opção é a rede

GSC200901-B, pois apresenta uma porcentagem de acertos semelhante à rede GSC200901-D, mas

com um erro consideravelmente menor.

4.1.7 Utilizando a RNA em um aplicativo.

Na seção 4.1.4, com a utilização do aplicativo snns2c.exe foi gerado o código fonte da RNA

GSC200901-B em linguagem C. Nesta seção será demonstrado o funcionamento da RNA através da

utilização do código gerado em um aplicativo construído para utilizar esse mesmo código. O

software desenvolvido lê um arquivo texto contendo os padrões de entrada (entrada.txt), envia esses

padrões à rede neural, que os analisa e retorna os padrões de saída, esses padrões são gravados pelo

aplicativo em outro arquivo de texto (saida.txt). A Figura 58 apresenta o trecho do código referente

ao programa principal.

O arquivo de entrada apresentado ao programa possui os 200 padrões de entrada utilizados

no processo de validação da RNA, esse experimento tem como objetivo detalhar os padrões de

saída gerados pela RNA e verificar a natureza quanto aos erros gerados pela rede (Apêndice K). A

Figura 59 demonstra o formato do arquivo de entrada do aplicativo e a Figura 60 nos permite

visualizar o formato do arquivo de saída gerado pelo aplicativo.

O aplicativo funcionou como esperado, após a execução do mesmo e análise dos resultados,

foram encontradas situações interessantes em alguns resultados da RNA. A análise detalhada dos

padrões de entrada retornou que a rede acertou precisamente 184 padrões, restando 16 padrões que,

embora não possam todos serem considerados acertos precisos, também não podem ser

considerados erros completos.

78

Figura 58. Trecho do código em linguagem C referente ao programa principal.

Figura 59. Formato do arquivo de entrada.

Figura 60. Formato do arquivo de saída.

79

Desses 16 padrões, 02 sugerem duas direções opostas, mas não problemáticas, por exemplo,

ao invés de sugerir o ângulo de 30 graus, a rede sugeriu os ângulos de 30 e 330 graus ao mesmo

tempo (0 1 0 0 0 0 0 1), todavia analisando a entrada (0.02 0.18 0.06), percebeu-se que a saída

gerada não causaria problema ao veículo, visto que ambas as direções são viáveis. Outros 03

padrões também apresentaram duas sugestões, mas ambas na mesma direção, porém nesse caso

percebeu-se que esse fato pode ter ocorrido por se tratar de situações que embora se enquadrem nas

regras gerais, deveriam atender a regras específicas, por exemplo, ao invés da rede sugerir o ângulo

de 90 graus, considerando a regra específica, foi sugerido o ângulo de 30 (regra padrão) e 90 (regra

específica) graus simultaneamente (0 1 1 0 0 0 0 0), e verificando os padrões de entrada (0.93 0.9

0.81) percebe-se que mesmo que o veiculo desloque-se em um ângulo de 30 e não 90 graus, como

seria o “correto”, ainda é possível permanecer na rota certa. Ocorreram ainda 03 casos nos quais os

padrões de saída novamente sugeriram duas direções, mas nesses casos uma das sugestões era

correta, e a outra sugestão embora incorreta não apresentava risco eminente ao robô. Por exemplo,

analisando o padrão de entrada 0.62, 0.21, e 0.20, levando em conta as regras da RNA, a rede

deveria sugerir o padrão 1 0 0 0 0 0 0 0 (0 grau), mas é sugerido o padrão 1 1 0 0 0 0 0 0 (0 e 30

graus), porém considerando os padrões de entrada, o robô continuará seu deslocamento

normalmente sem correr nenhum risco. Dos 16 padrões que a RNA não considerou corretos, os 08

padrões apresentados e explicados acima poderiam ainda ser corrigidos através da utilização de

regras no controlador que receberá os sinais da RNA.

Ainda restam 8 padrões a serem analisados e explicados, desses 08 padrões, 01 sugeriu um

ângulo menor do que o esperado, ou seja, foi apresentado um padrão de entrada (0.91 0.73 0.02), e a

rede neural retornou um padrão de saída (0 1 0 0 0 0 0 0) trinta graus menor que o padrão esperado

(0 0 1 0 0 0 0 0), nesse caso especificamente, não há perigo eminente ao robô. Ocorreram ainda 02

padrões de entrada que retornaram padrões de saída errados. Um exemplo é um padrão de entrada

(0.91 0.02 0.59) no qual a rede sugeriu um padrão de saída referente a 30 graus(1 0 0 0 0 0 0 0),

quando na verdade a sugestão correta seria de 90 graus (0 0 1 0 0 0 0 0). Os últimos 05 padrões

apresentados não foram reconhecidos pela rede, sendo que a mesma retornou para todos eles um

padrão de saída “vazio” (0 0 0 0 0 0 0 0). Ao considerarmos que dos 16 padrões não reconhecidos

como padrões esperados, 08 podem ser considerados padrões não mapeados, mas capazes de gerar

sugestões de direção corretas, temos um total de 192 padrões reconhecidos corretamente, o que

representa um acerto de 96%, um ótimo resultado para uma RNA. Para isso, basta que sejam

mapeadas no controlador combinações entre os oito padrões de saída.

80

4.2 Dynamic Link Library – DLL.

Após o desenvolvimento da rede neural artificial através do ambiente JavaNNS e finalizado

os testes com a mesma no software desenvolvido em C que utilizou o fonte gerado no aplicativo

snns2c.exe, foi dado inicio à próxima fase do projeto, que consistiu na criação de bibliotecas

utilizando o fonte gerado pelo aplicativo snns2c.exe.

O objetivo da criação de bibliotecas de ligação dinâmica é a sua utilização através do JNA –

seção 4.4.1 – no ambiente Simbad 3D. Essa biblioteca contém a rede neural artificial, ela receberá

os parâmetros de entrada referentes aos três (3) sensores de entrada, e retornará os valores referentes

aos oito (8) sensores de saída, que representam as oito (8) direções possíveis a serem tomadas pelo

veículo.

Detalhes quanto ao funcionamento de Bibliotecas de Link Dinâmico são apresentadas no

Apêndice A, o Apêndice B descreve o procedimento para a criação dessas bibliotecas utilizando o

software Embarcadero C++ Builder 2010, o Apêndice C descreve o desenvolvimento da mesma

biblioteca, mas utilizando outro software, o Bloodshed Dev-C++ 4. No Apêndice D é apresentado

como é carregada uma biblioteca estaticamente. Por fim, no Apêndice E é descrito como uma

biblioteca é carregada dinamicamente.

O desenvolvimento correto dessa biblioteca é essencial para o correto funcionamento do

veículo, pois ela contém a rede neural artificial e a descrição do método a ser chamado para o

funcionamento da mesma. Convertendo a rede neural em uma biblioteca de ligação dinâmica é

possível utilizá-la por diversas aplicações, e por meio das ferramentas utilizadas neste projeto, esse

procedimento tornou-se simples e rápido.

4.2.1 Verificando o cabeçalho das DLLs criadas

Foi concluído o desenvolvimento de duas dlls contendo o código gerado pelo software

“snns2c.exe”, agora será utilizado o software freeware “DLL Export Viewer”, que pode ser

adquirido no site http://www.nirsoft.net/utils/dll_export_viewer.html , esse aplicativo nos apresenta

uma lista contendo todas as funções de saída e os respectivos endereços de memória contidos em

uma ou em um grupos de bibliotecas pré selecionado. O software não possui instalador, bastando

descompactá-lo para iniciar sua utilização, após descompactado, executou-se o arquivo “dllexp.exe”

e selecionou-se a dll “PRNA.DLL”, o resultado é apresentado na Figura 61, o mesmo procedimento

foi aplicado ao arquivo “PDRNA.DLL”, cujo resultado obtido é apresentado na Figura 62:

81

Figura 61. Visualização das funções contidas no arquivo PRNA.DLL.

Fonte: DLL Export Viewer.

Figura 62. Visualização das funções contidas no arquivo PDRNA.DLL.

Fonte: DLL Export Viewer.

Em ambos os arquivos é possível constatar a existência da função rede, conforme definida

no momento da criação de ambas as dlls, pode-se então utilizar as dlls em outras aplicações

chamando-as através da função interna rede( ).

4.2.2 Validando as DLLs desenvolvidas

Com ambas as dlls criadas, deve-se criar um software capaz de utililazá-las, foi

desenvolvida uma aplicação em linguagem C que utiliza a dll a fim de gerar o mesmo resultado

obtido através do software desenvolvido na seção 4.1.7. O objetivo desse software é validar o

funcionamento das dlls desenvolvidas. A dll foi carregada utilizando tanto o método estático quanto

o método dinâmico, a implementação de ambas está detalhado no Apêndice D e no Apêndice E,

respectivamente.

82

4.3 Definição do Ambiente de Simulação do Robô.

Para definir qual seria o ambiente a ser utilizado neste projeto para realizar a fase de

virtualização da RNA, foi realizada uma pesquisa, na qual foram analisados um total de seis (6)

ambientes de simulação, sendo que os três (3) de maior destaque foram o Simbad 3D, o Khepera

Simulator e o Robocode, já mencionados e apresentados na seção 2.8 deste documento. Os demais

ambientes testados foram os seguintes:

· Webots: trata-se de um ambiente de desenvolvimento usado para modelar, programar

e simular robôs móveis. Com o Webots o usuário pode projetar complexos sistemas

robóticos, com um ou vários robôs, iguais ou diferentes, em um ambiente

compartilhado. As propriedades de cada objeto, como forma, cor, textura, massa,

fricção, etc., é escolhido pelo usuário. Várias opções de sensores simulados e

atuadores estão disponíveis para equipar cada robô. Os controladores do robô podem

ser programados com o IDE embutido ou com ambientes de desenvolvimento de

terceiros. O comportamento de robô pode ser testado em mundos fisicamente

realísticos. Os programas de controle podem ser transferidos opcionalmente a robôs

reais comercialmente disponíveis. Está disponível em: http://www.cyberbotics.com/.

· Microsoft Robotics Developer Studio 2008 (RDS): trata-se de um ambiente baseado

no Windows para desenvolvedores, acadêmicos e fomentadores comerciais criarem

aplicações robóticas para uma variedade de plataformas de hardware. O RDS inclui

um ambiente limpo e leve, rotinas orientadas a serviço, um cenário de criação visual

e ferramentas de simulação, como também tutoriais e códigos exemplos para auxiliar

o início do uso do ambiente. Está disponível em: http://msdn.microsoft.com/en-

us/robotics/default.aspx.

· Simulator Bob: trata-se de um ambiente de simulação 3D de código aberto projetado

para - mas não apenas - a simulação de robôs móveis. Ele usa a biblioteca ODE para

simular as dinâmicas de corpos rígidos e a biblioteca OpenSceneGraph para a

visualização em 3D. O GUI é percebido usando MFC e, assim, o software é limitado

para plataformas Win32. Ele é escrito inteiramente em C++ e compilado com o

Microsoft Visual Studio 7.1. A característica fundamental desta aplicação é a

simplicidade. Pode-se facilmente instalá-lo e executar várias simulações existentes.

Está disponível em: http://simbob.sourceforge.net/.

83

Embora todos os seis (6) ambientes apresentem-se como ótimas opções para a simulação de

robôs, a escolha baseou-se na independência da linguagem (multiplataforma), na disponibilidade do

código fonte do ambiente e no reconhecimento da ferramenta no meio acadêmico. Após análise

desses três (3) fatores, optou-se pela ferramenta denominada Simbad 3D, conforme tabela 9.

Multiplataforma Código Aberto Atualizado Reconhecimento Acadêmico Total Ambiente (1 a 3) (1 a 3) (1 a 3)

Simbad 3D 3 3 2 8 Robocode 3 3 1 7 Khepera 2 2 1 5 Webots 1 1 3 5 RDS 1 1 2 4 Simulator Bob 1 1 1 3

Tabela 9. Análise e Pontuação dos Ambientes de Virtualização de Robôs.

4.3.1 A Biblioteca JNA.

O projeto JNA – Java Native Access é uma implementação da JNI (Java Native Interface)

mas sem a necessidade de se preocupar e conhecer detalhes do código nativo que se pretende

chamar. Uma definição mais clara segundo o próprio projeto seria:

“JNA fornece acesso fácil a bibliotecas compartilhas nativas sem a necessidade da utilização da JNI, o acesso é dinâmico em tempo de execução não necessitando a geração de código adicional (.h). JNA permite acessar funções nativas usando métodos naturais do JAVA, a maioria das chamadas não necessitam de tratamento especial ou configuração, o JNA utiliza uma pequena biblioteca para dinamicamente invocar o código nativo, a aplicação JAVA utiliza uma interface para descrever as funções e estruturas da biblioteca nativa, isto facilita a utilização das funcionalidades nativas da plataforma que se está executando o aplicativo.” (JAVA.NET, 2009).

Mesmo utilizando a JNA, teve-se sempre ter o cuidado de controlar o acesso nativo através

de thread´s. Utilize alguma ferramenta de monitoramento de CPU, para verificar se as chamadas aos

códigos nativos não estão utilizando recursos excessivos do sistema, podendo causar instabilidade

ou até parada no sistema, lembrando que os testes devem ser feitos em todos os sistemas

operacionais que a aplicação for rodar (JAVADESK, 2009).

Com JNA pode-se escrever um código limpo e simples em java, sem que seja necessário

detalhar em seu código java a biblioteca nativa a ser chamada. Tudo isso é realizado

automaticamente pelo JNA. Tudo o que é necessário é definir uma interface da biblioteca que é

utilizada e especificar os métodos dos quais se quer ter acesso, como pode ser visto na Figura 63

(NXT, 2009).

84

Figura 63. Exemplo de definição de uma interface utilizando JNA.

Fonte: (NXT, 2009).

Feita a interface com a biblioteca, basta chamá-la usando o código apresentado na Figura 64.

Kernel32 kernel32Instance = (Kernel32) Native.loadLibrary("kernel32", Kernel32.class);

Figura 64. Exemplo de chamada de interface utilizando JNA.

Fonte: (NXT, 2009).

No projeto desenvolvido, primeiramente foi criado um arquivo java contendo a definição da

interface necessária para a utilização da biblioteca “PDRNA.DLL”, então esse arquivo foi salvo

como “interfacePrna.java” (o arquivo deve obrigatoriamente ter o mesmo nome da classe principal)

e incorporado ao pacote do ambiente Simbad 3D. O código completo do arquivo pode ser

visualizado na Figura 65.

Figura 65. Código do arquivo interfacePrna.java.

Fonte: Eclipse Platform - Version: 3.4.0 - Build id: I20080617-2000

Após terminada implementação do arquivo “interfacePrna.java”, basta utilizá-lo através do

código apresentado na Figura 66.

85

Figura 66. Chamada detalhada da interface interfacePrna.

Observe que a palavra “neural” apresentada na Figura 66 é como uma classe contendo todas

as funções da dll “PDRNA.DLL”, dessa forma, basta invocar as funções da dll através desta para

utilizá-las. Na Figura 67 é apresentado o trecho de código em que é invocada a função rede().

Figura 67. Invocando a função rede() através da interface “neural”.

Os códigos apresentados nas Figuras 65, 66 e 67 foram utilizados nesse projeto e

funcionaram corretamente.

4.3.2 Criação dos Mundos Virtuais e dos Robôs Virtuais.

Tendo como finalidade analisar o desempenho da rede neural artificial desenvolvida, foram

criados dois (02) mundos virtuais, cada um deles desenvolvido para testar aspectos específicos do

comportamento da RNA. Os mundos foram criados no ambiente virtual Simbad 3D, utilizando a

biblioteca java Vector 3D. O mundo virtual MarlosObstaculo é constituído por diversos obstáculos

e contendo um (1) robô, como pode ser visto na Figura 68, enquanto o mundo MarlosLaberinto é

composto por um labirinto contendo um robô, como pode ser visto na Figura 69.

86

Figura 68. Mundo virtual MarlosObstaculos.

Fonte: Simbad 3D.

Figura 69. Mundo virtual MarlosLaberinto.

Fonte: Simbad 3D.

87

Os códigos fontes completos correspondentes ao mundo virtual desenvolvido e as alterações

necessárias ao robô encontram-se disponíveis na seção de apêndices (MarlosObstaculo – Apêndice

M, MarlosLaberinto – Apêndice N ).

O robô desenvolvido é dotado de três (03) sensores do tipo sonar, posicionados em ângulos

de 0º, 90º e 270 º relativos ao centro do robô, e direcionados em um ângulo de 0º relativos ao

próprio sensor, como demonstrado na Figura 70.

Figura 70. Robô Virtual Simulado.

Fonte: Simbad 3D.

4.3.3 Chamada e Utilização da Biblioteca RNA.

O último teste para a rede neural artificial foi sua utilização em um ambiente virtual

desenvolvido para verificar seu desempenho. Durante os testes, a RNA comportou-se conforme o

esperado, permitindo que o robô se deslocasse de forma autônoma através do ambiente evitando os

obstáculos existentes no mesmo.

Para a utilização da biblioteca desenvolvida (PDRNA.DLL), basta primeiramente importar

para o projeto o pacote JNA e acrescentá-lo ao projeto, conforme demonstrado na Figura 71.

Figura 71. Importação do pacote JNA para utilização no ambiente virtual.

Fonte: Eclipse Platform - Version: 3.4.0 - Build id: I20080617-2000

Após essa importação inicial deve-se criar o arquivo de interface, conforme mencionado e

apresentado na Figura 65, em seguida deve-se acrescentar a chamada detalhada da interface criada,

88

como é demonstrado na Figura 66 e por fim invocar a função contida na interface criada, como

exemplificado na Figura 67.

Depois de realizados os procedimentos citados acima, foram desenvolvidas funções a fim de

tratar as entradas a serem enviadas a RNA, visto que as definições do ambiente virtual e seus

respectivos valores de varredura dos sonares não eram os mesmos daqueles apresentados à rede

neural através de seus padrões de treinamento e validação. Foram criados dois vetores de dados do

tipo float, um utilizado para passar os valores de entrada para a rede e outro para receber os valores

de saída da mesma.

Como os sonares do ambiente virtual operam com uma margem de valores mais ampla (de 0

a 3 aproximadamente) do que aquele utilizado pela RNA (de 0 a 1) foi implementado no ambiente

uma seqüência de verificação desses valores que no caso do mesmo ser maior que o máximo aceito

pela rede, esse valor é automaticamente substituído por 1. Também foi criada uma função a fim de

realizar uma inversão de valores, visto que para o ambiente virtual 0 representa a presença de

obstáculo imediatamente à frente e 1 a total ausência de obstáculo, enquanto a RNA trabalha com o

inverso dessa definição.

Também foi desenvolvido uma função que trata o retorno gerado pela RNA, com a

finalidade de converter os valores retornados para 0 ou 1, caso necessário. Por último foi

implementado um procedimento chamado de controlador que, baseado nos valores retornados pela

rede neural, envia os comando direcionais ao robô (direção e velocidade).

89

5 RESULTADOS

Neste trabalho foram apresentados o projeto e a implementação de uma rede neural artificial

para o deslocamento de um veículo autônomo capaz de se deslocar por uma superfície plana. Os

objetivos proposto por esse trabalho eram a criação de uma rede neural artificial capaz de guiar um

veículo sem a ajuda humana (autonomamente).

A primeira fase do projeto consistiu no desenvolvimento e criação de uma rede neural

artificial capaz de atingir o objetivo proposto com o menor número de neurônios possível, porém

sem prejudicar o desempenho da mesma. Foram usados 911 padrões de treinamento e 200 padrões

de validação. O aplicativo de análise estatística analyse.exe foi utilizado para analisar a

percentagem de acerto da rede neural após a validação, analisando os dados desse aplicativo

concluiu-se que a rede neural artificial atingiu uma percentagem de acerto de 92,50%, ainda sem a

utilização de um controlador.

A segunda fase do projeto consistiu no desenvolvimento de uma aplicação capaz de

incorporar o código fonte da rede neural artificial gerado pelo aplicativo snns2c.exe e utilizá-lo para

analisar um conjunto de padrões de entrada contidos em um arquivo de texto e, com base nessa

análise, gerar um arquivo contendo os padrões de saídas retornadas pela rede neural considerando o

respectivo padrão de entrada, executada a aplicação, foram analisadas os padrões de entrada e de

saída e, ao considerar-se a utilização de um controlador que receberia os padrões de saída da rede

neural, concluiu-se que o sistema apresentou uma taxa de acerto de 97%.

Com a primeira e a segunda fases concluídas, iniciou-se a terceira fase, que consistiu no

desenvolvimento de um biblioteca de ligação dinâmica, mais conhecida pela sigla em língua inglesa

dll – dynamic link-library – utilizando apenas o código fonte gerado pelo aplicativo snns2c.exe na

segunda fase. Para a criação desta biblioteca foram utilizados dois softwares, o Embarcadero RAD

Studio C++ Builder 2010 e o Bloodshed Dev C++ 4, ambos foram capazes de gerar a biblioteca de

forma correta. Em seguida foi desenvolvida uma aplicação capaz de utilizar a biblioteca gerada em

ambos os softwares de desenvolvimento (C++ Builder e Dev C++), em ambos os casos, a biblioteca

contendo a rede neural artificial funcionou de forma correta e, utilizando um controlador, manteve

uma taxa de acerto de 97%.

90

A quarta fase consistiu no desenvolvimento de dois mundos virtuais, desenvolvidos no

simulador de robôs Simbad 3D, desenvolvido em linguagem java. Essa foi à fase mais complexa do

projeto, primeiramente foram criados os mundos virtuais MarlosObstaculo e MarlosLaberinto, em

seguida foi necessário a utilização de uma biblioteca java externa, o JNA – Java Native Access –

que tem como finalidade permitir a utilização de qualquer biblioteca de ligação dinâmica externa,

utilizando-a como se a mesma fosse nativa da linguagem java. O JNA foi utilizado com sucesso na

chamada das bibliotecas de ligação dinâmicas criadas na terceira fase.

A Figura 72 apresenta o mundo MarlosObstaculo e o robô virtual, ainda inativo em sua

posição inicial, enquanto que na Figura 73 é apresentado o mesmo mundo virtual, mas com o robô

já em movimento, o traçado em cor preto representa o caminho percorrido pelo robô durante seis

(6) minutos de simulação.

Figura 72. Posição Inicial do Robô.

Figura 73. Trajetória e posição Final do Robô.

A Figura 74 apresenta o mundo MarlosLaberinto e o robô virtual, ainda inativo em sua

posição inicial, enquanto que na Figura 75 é apresentado o mesmo mundo virtual, mas com o robô

já em movimento, o traçado em cor preto representa o caminho percorrido pelo robô durante doze

(12) minutos de simulação.

91

Figura 74. Posição Inicial do Robô.

Figura 75. Trajetória e posição Final do Robô.

Em ambos os mundos virtuais o robô se comportou de maneira satisfatória.

Por fim, durante a realização deste projeto, devido à grande dificuldade no que diz respeito a

encontrar bons materiais de referência na fase de implementação, foi optado por transformar esse

documento em uma fonte de referência completa, no que diz respeito à implementação do mesmo,

por tal razão toda informação apresentada aqui contém um nível de detalhamento não encontrado na

maioria dos Trabalhos de Conclusão de Curso pesquisados, a intenção ao elaborar esse documento

foi compartilhar absolutamente toda a informação e conhecimento adquiridos durante o

desenvolvimento do mesmo.

92

6 DIFICULDADES

Muitas dificuldades surgiram durante o desenvolvimento desse projeto, a primeira delas tem

relação com os arquivos de padrões utilizados para o treinamento e validação da rede neural

artificial, a princípio foi planejado que esses padrões seriam obtidos através da simulação de um

ambiente composto por um mundo e um robô virtuais, o robô seria controlado pelo usuário através

de um joystick ou de um mouse, durante esse período os dados dos sonares seriam coletados e

armazenados em uma arquivo de texto, cada conjunto de padrões de entrada seria seguido por um

conjunto de padrões de saída, que seria coletado através do controlador direcional do robô virtual,

após este receber o comando do usuário, todavia essa etapa do projeto não foi concluída devido

principalmente à complexidade do ambiente de simulação Simbad 3D.

Esse fato levou ao desenvolvimento doa arquivos de padrões manualmente, o que

demonstrou ser uma tarefa demorada e maçante. Foram criados manualmente 911 padrões para

treinamento e 200 padrões para validação da rede neural artificial. Porém apenas após esses

arquivos de padrões terem sido revisados oito (8) vezes foram considerados prontos para utilização

nos processos de treinamento e validação da rede neural artificial, todavia um tempo considerável já

havia se passado.

Outro fator problemático durante o desenvolvimento deste projeto está relacionado com a

linguagem na qual o simulador escolhido foi desenvolvido, tendo sido criado utilizando a

linguagem de programação java, o Simbad 3D apresentava maior complexidade para importar uma

biblioteca de ligação dinâmica. Para resolver esse problema optou-se por utilizar a biblioteca JNA –

Java Native Access – que se apresentava como a forma mais simples e rápida de realizar essa

importação, todavia essa biblioteca acabou trazendo consigo outro problema, a falta de uma boa

documentação referente ao uso e manipulação da mesma, o que custou demasiado tempo até que,

por meio de tentativa e erro, se obteve o conhecimento necessário para utilizá-la corretamente.

A falta de uma boa documentação foi um problema recorrente durante todo o

desenvolvimento deste projeto, abrangendo desde a fase de análise de simuladores de robôs até o

desenvolvimento e uso de bibliotecas, fossem elas nativas ou não.

93

7 CONCLUSÃO

Como apresentado ao longo deste documento, e considerando os resultados obtidos durante

os testes no simulador, concluiu-se que o mesmo atendeu os objetivos propostos, pois convergiu

corretamente durante o treinamento e validação, além da mesma ter sido capaz de controlar o robô

no ambiente de simulação Simbad 3D de forma autônoma e segura, porém ficou claro que para um

melhor desempenho, seria necessário o acréscimo de dois (2) sensores de entrada, o que

significaria mais dois (2) neurônios na camada de entrada, percebeu-se ainda que não fosse

necessárias oito (8) direções de saída, o que significa que a camada de saída da rede neural artificial

sofreria uma redução de dois (2) neurônios, pelo menos. Outro aspecto percebido foi o fato de que o

simulador não foi à melhor opção considerando o nível de refinamento apresentado pela rede neural

artificial, pois ele não foi capaz de atender a todos os comandos enviados pela RNA.

Ficou claro também que é essencial o desenvolvimento de um ambiente virtual já na

primeira fase do projeto, para que o mesmo seja utilizado para gerar, através de simulações, os

padrões de treinamento e validação a serem utilizados pela rede neural artificial, além de ser

utilizado posteriormente para demonstrar o funcionamento do protótipo virtual.

Todavia mesmo considerando as dificuldades encontradas, foram adquiridos conhecimentos

além daqueles esperados, como a existência de aplicativos como o snns2c.exe, que proporcionou

uma gama de possibilidade quanto à implementação da RNA e sua utilização em aplicativos de

forma simples e direta, o analyse, que permitiu a verificação referente aos padrões reconhecidos

corretamente, incorretamente e não reconhecidos pela RNA utilizando o arquivo de resultado

gerado pelo JavaNNS, o DLL Export Viewer, que permitiu verificar se a nomenclatura da função

interna da dll estava correta antes mesmo de testar a dll e vários outros, utilizados durante a

realização deste projeto.

7.1 Projetos Futuros.

Considerando as dificuldades encontradas durante o desenvolvimento deste projeto, algumas

sugestões de projetos futuros tornaram-se evidentes, a primeira delas é a implementação de uma

interface de controle no ambiente Simbad 3D, essa interface teria a finalidade de permitir que o

usuário controle o deslocamento de um robô em qualquer ambiente virtual desenvolvido no Simbad

3D através do mouse ou de um joystick padrão, essa implementação seria feita em java e faria parte

94

do próprio ambiente Simbad 3D, permanecendo disponível ao usuário que deseja utiliza-lá, nela o

robô seria controlado pelo usuário através de um joystick ou de um mouse, durante esse período os

dados dos sensores seriam coletados e armazenados em uma arquivo de texto, cada conjunto de

padrões de entrada seria seguido por um conjunto de padrões de saída, que seria coletado através do

controlador direcional do robô virtual, após este receber o comando do usuário, esses padrões de

saída poderiam ser em graus ou em alguma outra forma previamente pesquisada.

Outra sugestão seria o desenvolvimento de um simulador de robôs em linguagem C, para

isso, seria usado como base o simulador Khepera, esse simulador foi desenvolvido em linguagem C,

mas sua versão gratuita recebeu sua ultima atualização em 1997, quanto ganhou uma versão

proprietária conhecida como Webots. O Khepera não funciona hoje em dia devido ao fato de seu

fonte em C estar fora dos padrões ISO, o que o torna incompatível com os compiladores atuais, não

sendo possível compilá-lo e gera um executável.

Outro projeto interessante seria o desenvolvimento de uma rede neural mais complexa com

auxílio deste documento, pois seria mais produtivo e simples, visto que o mesmo apresenta um guia

completo no que diz respeito a um grande número de tecnologias necessárias.

A construção de um protótipo físico capaz de utilizar a rede neural artificial desenvolvida

neste trabalho também seria uma opção viável e instigante.

95

REFERÊNCIAS BIBLIOGRÁFICAS

BARONE, Dante Augusto Couto et al. Sociedades Artificiais: A Nova Fronteira da Inteligência nas Máquinas. São Paulo: Artmed Editora S.A., 2003. 332 p.

BOTELHO, Silvia Silva da Costa. Desenvolvimento de Sistemas Inteligentes para controle de robôs móveis. 1996. 124p. Dissertação (Mestrado em Ciências da Computação) – Instituto de Informática, Universidade Federal do Rio Grande do Sul, Porto Alegre.

BRAGA, Antônio de Pádua; CARVALHO, André Ponce de Leon F.; LUDERMIR, Teresa Bernarda. Redes Neurais Artificiais – Teoria e Prática. Rio de Janeiro. LTC, 2007. 226p.

CAZANGI, Renato Reder. Uma Proposta Evolutiva para Controle Inteligente em Navegação Autônoma de Robôs. 2004. 148 f. Tese (Mestrado) - Curso de Engenharia de Computação, Unicamp, Campinas, 2004.

DINIZ, M. V. C. . Dirigibilidade de mini-robôs com Redes Neurais Artificiais: uma experiência acadêmica.. Cientefico, Faculdade Ruy Barbosa, v. 1, p. 117-121, 2006.

FERNANDES, Anita Maria da Rocha. Inteligência Artificial: noções gerais. Florianópolis: Florianópolis, Visual Books, 2003. 159p.

GROOVER, Mikell P. et al. Robótica: Técnologia e Programação. São Paulo: Mcgraw-hill, 1989. 397 p.

GROOVER, Mikell P.; WEISS, Mitchell; NAGEL, Roger N. et al. Robótica: Tecnologia e Programação. São Paulo: McGraw-Hill, 1998. 401p.

HAYKIN, Simon. Redes Neurais: Princípios e Prática. Porto Alegre, Bookman, 2001. 900p.

HEINEN, Farlei José. Sistema de Controle Híbrido para Robôs Móveis Autônomos. 2002. 130 f. Dissertação (Mestrado) - Universidade do Vale do Rio Dos Sinos, São Leopoldo, 2002.

HEINEM, Milton et al. Estacionamento de um Veículo de Forma Autônoma Utilizando Redes Neurais Artificiais. In: III Encontro de Robótica Inteligente, 10., 2006, Campo Grande. Anais do XXVI Congresso da SBC, Campo Grande: EnRI, 2006. p. 107-116.

HUGUES, Louis; BREDECHE, Nicolas. Simbad: na Autonomus Robot Simulation Package for Education and Reserch. Paris: GINKGO – NETWORS, 2006. Disponivel em: <http://www.lri.fr/~bredeche/MyBiblio/SAB2006simbad.pdf> Acesso em: 01 jun 2009.

HUGUES, Louis; BREDECHE, Nicolas. Simbad 3D Robot Simulator. Disponível em: <http://simbad.sourceforge.net/>. Acesso em: 01 jun. 2009.

JARDIM, Rodrigo Urubatan Ferreira. Java Native Access (JNA). Disponível em: <http://www.urubatan.com.br/chamando-metodos-nativos-dllso-em-java-sem-jni/>. Acesso em: 18 mar. 2009.

96

JAVADESK (Brasil). JNA – Java Native Access. Disponível em: <http://www.javadesk.org/?p=123>. Acesso em: 02 mar. 2009.

JAVA.NET (Estados Unidos). JNA. Disponível em: <https://jna.dev.java.net/>. Acesso em: 22 fev. 2009.

LUDWIG JUNIOR, Oswaldo; MONTGOMERY, Eduard. Redes Neurais: Fundamentos e Aplicações com Programas em C. Rio de Janeiro: Ciência Moderna, 2007. 125p.

MARRONE, Paolo. JOONE: Java Object Oriented Neural Engine. Disponível em: <http://www.jooneworld.com/>. Acesso em: 01 jun. 2009.

MESSIAS A, Antonio Rogério. TRABALHANDO COM DLLs. Disponível em: <http://zz2kzq.site90.com/CursoHtml/Modulo05/Modulo005Aula008.htm>. Acesso em: 18 ago. 2009.

MESSIAS B, Antonio Rogério. CRIANDO UMA DLL EM C++Builder. Disponível em: <http://zz2kzq.site90.com/CursoHtml/Modulo05/Modulo005Aula009.htm>. Acesso em: 18 ago. 2009.

MESSIAS C, Antonio Rogério. CARREGANDO UMA DLL ESTATICA E DINAMICAMENTE. Disponível em: <http://zz2kzq.site90.com/CursoHtml/Modulo05/Modulo005Aula010.htm>. Acesso em: 18 ago. 2009.

MICHEL, Olivier et al. Khepera Simulator. Disponível em: <http://diwww.epfl.ch/lami/team/michel/khep-sim/>. Acesso em: 01 jun. 2009.

MICHEL, Olivier et al. Webots Simulator. Disponível em: <http://www.cyberbotics.com/>. Acesso em: 01 jun. 2009.

MIOTTO, Marcelo. Programação Alimentar Utilizando RBC. 2006. 117p. Trabalho de Conclusão de Curso (Bacharel em Ciências da Computação) – Faculdade de Ciências da Computação, Universidade do Vale do Itajaí, Itajaí, 2006.

MÓDULO DE VALIDAÇÃO CRUZADA PARA TREINAMENTO DE REDES NEURAIS ARTIFICIAIS COM ALGORITMOS BACKPROPAGATION E RESILIENT PROPAGATION. Ponta Grossa: Uepg, 19 nov. 2007. Disponível em: <www.uepg.br/propesp/publicatio/exa/2008_1/Art.2.pdf>. Acesso em: 05 jun. 2009.

NELSON, Mathew et al. Robocode. Disponível em: <http://robocode.sourceforge.net/>. Acesso em: 01 jun. 2009.

PASSOS, Eduardo Rocha. Simulação de Estratégias para um Veículo Robótico Autônomo para Patrulhamento. 2008. 76 f. Tcc (Graduação) - Curso de Ciência da Computação, Centro de Ciências Tecnológicas, da Terra e do Mar - Cttmar, Universidade do Vale do Itajaí - Univali, Itajaí, 2008.

PESSIN, G. ; OSORIO, F. S. ; MUSSE, S. ; NONNEMMACHER, V. ; FERREIRA, S. S. . Utilizando Redes Neurais Artificiais no Controle de Robôs Móveis Aplicados ao Combate de

97

Incêndios Florestais. In: XVI Seminário de Computação (SEMINCO 2007), 2007, Blumenau, SC. Anais do XVI SEMINCO. Blumenau : FURB, 2007. p. 19-30.

REIS, Caime Franco; ALBUQUERQUE, Marcelo Portes de; CASTRO, Sérgio Borges de. Introdução ao Reconhecimento de Padrões utilizando Redes Neurais. 002. ed. Rio de Janeiro: Centro Brasileiro de Pesquisas Físicas, 2001. 17 p.

VIEIRA, Rodrigo de Souza. Protótipo de um Sistema de Monitoramento Remoto Inteligente. 1999. 147 f. Dissertação (Pós-graduação em Engenharia de Produção), Curso de Pós-graduação em Engenharia de Produção, Universidade Federal de Santa Catarina, Florianópolis, 1999.

NXT. JNA: Java Native Access. Disponível em: <http://blog.vdburgh.net/roller/nxtplace/entry/jna_java_native_access>. Acesso em: 15 set. 2009.

ZELL, Andreas et al. JavaNNS: Java Neural Network Simulator. Disponível em: < http://www.ra.cs.uni-tuebingen.de/software/JavaNNS/welcome_e.html />. Acesso em: 01 jun. 2009.

ZELL, Andreas et al. SNNS: Stuttgart Neural Network Simulator. Disponível em: < http://www.ra.cs.uni-tuebingen.de/software/snns/welcome_e.html >. Acesso em: 01 jun. 2009.

98

APÊNDICES

99

A TRABALHANDO COM DLLS

DLL (Dynamic Link Library), ou seja (Biblioteca de Ligação Dinâmica). É uma biblioteca

que contém dados e códigos podendo ser compartilhados por diversos programas aplicativos

quando estão em execução. Dessa forma vários programas que estejam sendo executados podem

chamar a mesma função disponível na dll sem gerar nenhum conflito. Pense numa dll como um

arquivo coletivo, que pode ser compartilhado por vários programas que requisite seus serviços.

Uma dll só será carregada na memória quando requisitada pela aplicação que a chamou, se uma

segunda aplicação desejar chamar a mesma dll, essa biblioteca não será duplicada na memória, mas

sim, compartilhada (MESSIAS A, 2009).

DLLs podem ser acessadas estática ou dinamicamente pelos programas. Quando nossos

programas acessam uma dll, essa biblioteca deverá estar na mesma pasta onde se encontra o

programa, ou em uma pasta padrão do windows. Se o programa estiver carregando a dll de forma

estática e esta não existir em alguma das pastas mencionadas, o programa será finalizado. Se o

programa tentar carregar a dll de forma dinâmica e esta não for encontrada, o programa, mesmo

sem a biblioteca será executado, mas sem usufruir dos recursos da mesma (MESSIAS A, 2009).

Programas que carregam dlls de forma dinâmica tem várias vantagens em relação aos que

carregam de forma estática. Programas que carregam dlls de forma estática só podem liberar o

espaço ocupado na memória pela biblioteca quando o próprio programa que a chamou for

finalizado. Já os programas que carregam dlls de forma dinâmica podem alocar ou liberar a dll da

memória quando desejarem. Sendo assim, quando um programa estiver executando processos que

não utilizem a biblioteca, esta poderá ser removida da memória, liberando espaço para que outros

serviços possam ser executados (MESSIAS A, 2009).

Uma dll pode ser criada em C++ e usada por programas escritos em linguagens como

Delphi, Visual Basic e outras que dêem suporte a dlls. Dessa forma uma função de baixo nível

escrita em C++ poderá ser usada num programa escrito em Visual Basic, como por exemplo, as

funções de acesso à uma Porta Paralela (outportb e inportb) ou quaisquer outras que desejarmos.

Para criar uma dll que possa exportar suas funções para outras linguagens, C++ dispõe de alguns

comandos e modificadores de tipos especiais para resolver algumas divergências entre a passagem

de parâmetros e nomes de funções (MESSIAS A, 2009).

100

Para que um programa C++ possa carregar uma dll de forma dinâmica, precisamos aprender

a declarar ponteiros para função, é dessa forma que estes programas terão acesso ao endereço de

uma função específica da dll na memória. Já no carregamento estático não há a necessidade de

declaração de ponteiro para funções. Na Figura 77, percebe-se que no interior da “MINHA.DLL”

existem duas funções (outportb e inportb), organizadas de uma certa forma para que os programas

possam identificá-las corretamente. Portanto, o que temos dentro de uma dll são funções

compiladas e "linkadas", ou código executável, o mesmo contido nos programas “.EXE”. Essas

funções estão prontas para serem usadas por quaisquer programas que as chame, após o

carregamento da dll na memória (MESSIAS A, 2009).

Figura 76. Uma visão didática do conteúdo interno de uma dll.

Fonte: (MESSIAS A, 2009).

O código fonte mostrado na Figura 77 foi escrito somente para uma melhor compreensão de

uma dll, como se sabe, no interior de uma biblioteca o que há é código executável (compilado e

"linkado") (MESSIAS A, 2009).

A Figura 78 mostra uma única dll compartilhada por quatro programas em execução na

memória. Se esses programas não utilizassem bibliotecas cada um teria que carregar na memória

tanto a função outportb como a função inportb, requisitando mais memória ao sistema (MESSIAS

A, 2009).

101

Figura 77. Vários programas em execução usando a mesma dll simultaneamente.


Conforme a ilustração exibida na Figura 79, uma dll pode ser acessada através de programas

escritos em várias linguagens que dêem suporte a bibliotecas. Em C++ para criarmos dlls que

possam exportar suas funções para outras linguagens, temos que utilizar alguns comandos e

modificadores de tipos especiais para que não ocorram inversão na passagem de parâmetros e

também truncamento de nomes de funções por parte do "ligador" (MESSIAS A, 2009).

Figura 78. Chamando uma dll escrita em C++ através de várias linguagens.


102

Figura 79. Chamando uma dll dinamicamente em C++.


A Figura 80 ilustra passo-a-passo o carregamento dinâmico de uma dll através de programas

escritos em C++. A função LoadLibrary() é responsável pelo carregamento dinâmico da biblioteca

na memória. A função GetProcAddress() retorna o endereço de memória onde se encontra uma

determinada função da dll. O endereço retornado é o da função outportb(). Depois que nosso

programa obtém o endereço de uma função da dll, ele poderá usá-la sem nenhuma restrição

(MESSIAS A, 2009).

103

B CRIANDO A DLL UTILIZANDO O C++ BORLAND 2010

Nesse capítulo será criada uma dll no C++Builder, que possa ser acessada por quaisquer

aplicações escritas em: Delphi, Visual Basic, C/C++, Java e outras linguagens que dêem suporte a

bibliotecas. Não há nenhuma diferença numa função que você cria dentro de seu próprio código

fonte, de uma que será criada para fazer parte de uma dll. O que existe é a inclusão de alguns

modificadores responsáveis pela convenção de parâmetros e comandos para exportar a própria

função. A sintaxe inserida em volta da função que será exportada é um pouco diferente da que se

esta acostumado a escrever, mas com a criação de várias funções, logo tornar-se-ão familiares.

Para começar, criou-se uma dll chamada “PRNA.DLL”, que contém a função rede(float,

float, int) para calcular a direção a ser tomada pelo veículo. Como já existe bastante familiaridade

com essa função, tornou-se fácil compreender a sintaxe de exportação de funções.

Segue passo a passo a criação da biblioteca “PRNA.DLL”:

1. Criou-se em alguma unidade de disco, uma nova pasta com o nome RNA (ou o nome

que desejar). Essa pasta serviu para gravar o nosso projeto;

2. Aberto o C++Builder e selecionado no menu File, item Close All, para fechar o

projeto atual;

3. Selecionado novamente no menu File, New e depois em Other..., foi exibida uma

caixa de diálogo similar a da Figura 81;

4. Selecionado o ícone DLL (Dynamic-link Library) e clicado no botão OK;

5. Apresentada uma janela New Dynamic-link Library como a da Figura 82, em Source

Type selecionada a opção “c”, marcado o checkbox “Mult Threaded” e clicado no

botão “OK”. Éxibida a janela da Figura 83 com o código fonte básico para dar início

a criação de uma DLL;

104

Figura 80. Caixa de diálogo Other, para escolher o que se deseja criar.

Fonte: Embarcadero RAD Studio 2010.

Figura 81. Janela New Dynamic-link Library.


6. Dado continuidade ao código fonte que o C++Builder gerou, acrescentado o código

fonte gerado pelo “snns2c.exe”;

7. Clicado no menu File e depois no item Save. Salvo o projeto com o nome PRNA, na

pasta RNA, criada anteriormente no passo 1;

105

Figura 82. Código fonte gerado automaticamente para começar o desenvolvimento de uma dll.


8. Compilado o código fonte para gerar a DLL. Clicado no menu Projects e depois no

item Build All Projects.

Não ocorreu erro algun, aberta a pasta Debug, criada pelo C++ Builder dentro da pasta

RNA, o conteúdo dela é apresentado na Figura 84:

Figura 83. Pasta contendo todos os arquivos gerados após a compilação do projeto.

Observe que o compilador gerou vários arquivos, dentre eles o arquivo “PRNA.DLL”. Esse

é o arquivo dll onde se encontra a função global rede(float, float, int) que poderá ser chamada

através de aplicativos escritos em linguagens que dêem suporte a dll. Os arquivos “PRNA.LIB” e

“RNA.OBJ” poderão ser úteis para compilar programas que carreguem dll de forma estática no

C++Builder. A utilização dos comandos listados na Tabela garantem que a dll criada possa ser

chamada através de programas escritos em várias linguagens de programação, sem que ocorram

problemas na conversão dos dados de parâmetros e nomes de funções.

106

Comando Função

extern "C"

Indica ao "linkeditor" que a função a ser exportada usará a convenção C e não C++. C++ altera o nome da função para que possa ser possível implementar sobrecarga de função;

__declspec(dllexport) ou _export ou __export Comandos usados para exportar as funções da DLL

_stdcall ou __stdcall ou WINAPI Modificadores de tipos utilizados para ordenar os parâmetros passados às funções. Esses modificadores obedecem ao padrão WIN32.

Tabela 10. Comandos que devem ser inseridos na construção de funções para dll.

Fonte: (MESSIAS B, 2009).

Observa-se na Tabela 10 que um mesmo comando pode ser expresso de várias formas. A

sintaxe __declspec(dllexport) e __stdcall são as mais utilizadas. Para criar uma função dentro de

uma dll que possa ser exportada para outros programas, a sintaxe demonstrada na Figura 85 deverá

sempre ser utilizada, ficando flexível para mudança somente o tipo de dado de retorno, o tipo de

parâmetro e o nome da função.

Figura 84. Sintaxe para declaração de funções que poderão ser exportadas para fora da dll.


Se declarássemos a função rede(float, float, int) de forma padrão (unsigned char

inportb(WORD)), ela não seria exportada, e só poderia ser chamada pela própria dll, ou seja,

somente as funções internas da dll poderia utilizá-la. Veja na Tabela 11 alguns tipos de dados

redefinidos através do comando typedef. Essa redefinição de tipos é muito utilizada pelas funções

da API do windows. Veja alguns sinônimos:

107

Tipo Redefinido Tipo original BYTE unsigned char WORD unsigned int short DWORD unsigned int

Tabela 11. Tipos redefinidos.


O C++Builder permite o uso dos tipos redefinidos na Tabela 11 livremente em nosso código

fonte, sem nenhum erro de sintaxe.

108

C CRIANDO A DLL UTILIZANDO O DEV C++ 4

Alguns programadores podem se sentir desconfortáveis ao se utilizar um software

proprietário para criar uma dll, considerando esse aspecto é apresentado nesse capítulo como

proceder para a criação de uma biblioteca utilizando o software freeware Bloodshed Dev-C++. Para

começar, foi criada uma dll chamada “PDRNA.DLL”, que contém a função rede(float, float, int)

para calcular a direção a ser tomada pelo veículo.

Segue passo a passo a criação da biblioteca “PDRNA.DLL”:

1. Criada em alguma unidade de disco, uma nova pasta com o nome PDRNA (ou o

nome que desejar). Essa pasta foi utilizada para gravar o nosso projeto;

2. Aberto o Dev-C++ e clique no menu File, New Project..., exibida uma caixa de

diálogo similar a da Figura 86;

Figura 85. Caixa de diálogo New Project.

Fonte: Bloodshed Dev-C++ 4

3. Em Project selecionado a opção “DLL”, marcado o checkbox “C project” e clicado

no botão “OK”. Exibida uma janela igual a da Figura 87;

4. Preenchidos os campos da janela mostrada na Figura 87 com os dados do projeto que

será criado, os campos referentes à nossa dll estão contidos no quadro “DLL

Project”, clicado no botão “OK”;

109

5. O projeto foi criado, em seguida foi fechado o software Dev-C++. Aberta a pasta

PDRNA e utilizado o Bloco de Notas ou o Notepad++ para abrir o arquivo

“PDRNA.dev” e alterado a linha referente a extensão do arquivo “PDRNA.CPP”

para “PDRNA.C”, em seguida o arquivo foi salvo. Como demostrado na linha 10 da

Figura 88, esse procedimento garante a compilação correta da dll pelo compilador C,

ao invés do compilador C++, que geraria um erro de “Estrutura Previamente

Declarada”;

Figura 86. Caixa de Diálogo New DLL Project.

Fonte: Bloodshed Dev-C++ 4.

110

Figura 87. Conteúdo alterado do arquivo PDRNA.dev.


6. Alterada a extensão do arquivo “PDRNA.CPP” para “PDRNA.C” e reaberto o

projeto no Dev-C++ através do arquivo “PDRNA.dev”;

7. O software Dev-C++ apresentou duas (02) janelas, referentes ao arquivo de headers

(.h) e o arquivo fonte (.c). Chamamos nosso arquivo header de “PDRNA.H”, é nesse

header que vão os prototipos das funções que foram implementadas no arquivo

“PDRNA.C”, para cada função que se deseja ter acesso na dll, deve ser especificada

um protótipo conforme o apresentado na Figura 89, na dll desenvolvida utilizamos

apenas uma função;

Figura 88. Código contido no arquivo PDRNA.H.


111

8. O arquivo header está pronto, agora basta inserir no arquivo “PDRNA.C” o código

gerado pelo snns2c.exe e incluir os identificadores “__declspec(dllexport)” na

função “rede(float *in, float *out, int init)”;

9. Compilado o projeto, não ocorreu erro algum, aberta a pasta “PDRNA”, o conteúdo

dela é apresentado na Figura 90:

Figura 89. Pasta contendo todos os arquivos gerados após a compilação do projeto.

Observe que após a compilação foram gerados vários arquivos, dentre eles o arquivo

“PDRNA.DLL”. Esse é o arquivo dll onde se encontra a função global “rede()” que poderá ser

chamada através de aplicativos escritos em linguagens que dêem suporte a dll.

112

D CARREGANDO UMA DLL ESTÁTICAMENTE

Após a compilação da dll “PRNA” foram gerados vários arquivos, sendo dois deles

(PRNA.DLL e PRNA.LIB) muito importantes para o projeto desta seção, a Figura 91 mostra um

fluxo básico do carregamento de uma dll estaticamente pelo programa aplicativo:

Figura 90. Fluxo genérico de carregamento estático de uma dll.

Fonte: (MESSIAS C, 2009).

Observa-se no fluxo acima que o programa ao ser inicializado verifica se a dll encontra-se

em alguma pasta especificada na criação do mesmo. Caso não exista o programa é finalizado. Uma

biblioteca carregada estáticamente só poderá ser removida da memória quando o programa que a

carregou for finalizado. Mesmo que o programa não necessite chamar uma função da biblioteca, ela

permanecerá ocupando espaço na memória. Há vantagem no carregamento estático de dll quando o

programa que as carregou utilizar suas funções freqüentemente.

Abaixo seguem os passos para criação de um programa que carregue estáticamente a dll

“PRNA.DLL”:

1. Criado uma nova pasta com o nome “LeDLLEstatica” e copiado para dentro desta

pasta os arquivos “PRNA.DLL”, “PRNA.LIB” e “RNA.OBJ” criados anteriormente.

Essa pasta foi utilizada para gravar esse projeto;

113

2. Aberto o C++Builder;

3. Adicionado um componente “Button” no formulário e alterado o Caption para

"Executa DLL Estática", então foi inserido o código apresentado na Figura 92 no

evento OnClick desse botão.

Figura 91. Código inserido no envento OnClick do objeto Button1.

4. No código fonte do programa, foi inserido o fragmento de código contido na Figura

93, na mesma posição onde se encontram na Figura 94. Observa-se que a sintaxe é a

mesma usada na criação do arquivo “PRNA.DLL”, mas com uma pequena

substituição da instrução “dllexport” para “dllimport”. A instrução na Figura 93 nada

mais é que um protótipo para a função a ser importada da dll para o software. Os

tipos de dados, os nomes das funções e a ordem dos tipos de parâmetros, devem ser

idênticos aos que estão declarados na dll, caso contrário, erros são gerados na

compilação.

extern "C" __declspec(dllexport) WINAPI int rede(float *in, float *out, int init);

Figura 92. Declaração da função a ser importada estaticamente da dll:

114

Figura 93. Posição onde deve ser inserida a instrução contida na Figura 93.

5. Selecionado o menu “Project” o item “Add to Project...” Abra a pasta

“LeDLLEstatica” criada no passo 1, selecionado o arquivo “PRNA.LIB” e

adicionado ao projeto;

6. Selecionado o menu “File” o item “Save”. O projeto foi salvo com o nome

“LeDllEstatica” na pasta “LeDLLEstatica”, criada no passo 1;

7. O projeto foi compilado com sucesso.

115

E CARREGANDO UMA DLL DINÂMICAMENTE

Para se trabalhar com dll dinamicamente, deve-se primeiramente familiarizar-se com

Ponteiros para Funções. Caso se tente armazenar o endereço de uma função em uma variável

ponteiro comum, obtém-se um erro no momento da compilação. Se o objetivo é armazenar o

endereço de uma função, deve-se declarar uma variável ponteiro para uma função. Observe na

Figura 95 como declarar um ponteiro para uma função:

Figura 94. Declaração de um ponteiro para uma função.


São apresentados na Tabela 12 alguns exemplos de como declarar Ponteiros para Funções,

com tipos de retorno e parâmetros diferentes:

Cria um ponteiro para uma função que não retorna nada (void) e não aceita nenhum parâmetro (void). void (*PonteiroFunc)( void ); Cria um ponteiro para uma função que não retorna nada (void) e aceita um parâmetro do tipo int. void (*PonteiroFunc)( int a ); Cria um ponteiro para uma função que não retorna nada (void) e aceita quatro parâmetros. void (*PonteiroFunc)( int a, int b, unsigned char c, float d ); Cria um ponteiro para uma função que retorna um tipo (unsigned char) e aceita dois parâmetros. unsigned char (*PonteiroFunc)( int, unsigned char ); Cria um ponteiro para uma função que retorna um string, e aceita um parâmetro string (caracteres). char * (*PonteiroFunc)( char *texto );

Tabela 12. Ponteiro para Funções.

116

Deve-se tomar cuidado para não confundir declaração de ponteiros para funções com

declaração de ponteiros para variáveis, ou mesmo declaração de protótipos de funções:

int *Ponteiro; ou int (*Ponteiro); char *Ponteiro; void *Ponteiro; unsigned char (*Ponteiro);

Tabela 13. Ponteiros para Variáveis.

int MinhaFunc(int a, int b); char MinhaFunc(void); unsigned char MinhaFunc(int x, char *texto); char *MinhaFunc( unsigned char *s);

Tabela 14. Protótipos de Funções.

Para se declarar um Ponteiro para uma Função são necessários usar dois pares de parênteses,

como pode ser verificado na Figura 96.

Figura 95. Declarando um ponteiro para uma função com parâmetros.


Para se criar um ponteiro para uma função, é necessário conhecer muito bem o protótipo da

função que será apontada. Os tipos de parâmetros da função tem de ser idênticos aos declarados no

ponteiro, como também o tipo de dado de retorno. Na Figura 96 o ponteiro para função

(PonteiroFunc) foi declarado com os mesmos tipos de dados de retorno e de parâmetros que os da

função Soma(). Para que o ponteiro PonteiroFunc aponte para a função Soma() na memória, é

necessário criar uma variável do tipo PonteiroFunc da forma como é apresentado na Tabela 15:

PonteiroFunc MinhaSoma; Cria uma variável com o poder de apontar para uma função na memória. Atribui o endereço da função Soma() ao ponteiro para função 'MinhaSoma'.

MinhaSoma = Soma; Não se usa os parênteses quando o objetivo é passar o endereço da função.

Valor = MinhaSoma(10, 60); Executa a função Soma() indiretamente através do ponteiro 'MinhaSoma'.

Tabela 15. Declaração de Ponteiro para Função.

117

Analisando o fluxo apresentado na Figura 97, percebe-se que o programa é carregado e

executado independentemente da existência ou não da dll. Se a biblioteca não existir, o programa

não terá acesso aos recursos da mesma e somente rotinas inerentes ao programa funcionarão.

Para trabalharmos com dlls dinamicamente é necessário conhecer três funções importantes,

elas são: LoadLibrary(), GetProcAddress() e FreeLibrary().

Figura 96. Fluxo genérico de carregamento dinâmico de uma DLL.

A Tabela 16 apresenta a sintaxe e a descrição da função LoadLibrary().

Função: Descrição:

LoadLibrary(): Carrega um arquivo DLL na memória dinamicamente;

Sintaxe:

HINSTANCE instanciaDLL; Para armazenar um identificador da DLL na memória (uma instância da DLL).

instanciaDLL = LoadLibrary("NomeDaDLL.dll");

Se houver sucesso a função LoadLibrary() carrega a DLL na memória e retorna um identificador (handle); Se houver um erro, a função LoadLibrary() retorna um NULL;

Tabela 16. Sintax e Descrição da Função LoadLibrary().

118

A Tabela 17 apresenta a sintaxe e a descrição da função FreeLibrary() e a Tabela 18

apresenta a sintaxe e a descrição da função GetProcAddress().


FreeLibrary(): Libera uma DLL alocada na memória.

Sintaxe:

BOOL Retorno;

Retorno = FreeLibrary(instanciaDLL); O parâmetro instanciaDLL identifica a DLL que desejamos liberar.

Tabela 17. Sintax e Descrição da Função FreeLibrary().


GetProcAddress(): Obtém o endereço de uma função específica na DLL que esteja alocada na memória.

Sintaxe: FARPROC GetProcAddress(instanciaDLL, "NomeDaFunção");

Tabela 18. Sintax e Descrição da Função GetProcAddress()

O Parâmetro "NomeDaFunção" refere-se exatamente ao mesmo nome contido internamente

na dll. Já o nome da variável ponteiro que irá receber o endereço da função pode ser qualquer um

que desejar. A função GetProcAddress() retorna um endereço de uma função da dll. Para atribuir

esse endereço a uma variável, deve-se declará-la como sendo do tipo Ponteiro para Função. Se

houver sucesso a função GetProcAddress() retorna o endereço da função exportada da dll, se houver

um erro, a função GetProcAddress() retorna um NULL.

119

F RNA GERADA PELO AMBIENTE JAVANNS

A seguir é apresentado o arquivo de topologia da RNA após criada, treinada e validada pelo

ambiente JavaNNS.

SNNS network definition file V1.4-3D generated at Mon Jun 15 00:56:34 2009 network name : GSC200901-B source files : no. of units : 28 no. of connections : 187 no. of unit types : 0 no. of site types : 0 learning function : Std_Backpropagation update function : Topological_Order unit default section : act | bias | st | subnet | layer | act func | out func ---------|----------|----|--------|-------|--------------|------------- 0.00000 | 0.00000 | h | 0 | 1 | Act_Logistic | Out_Identity ---------|----------|----|--------|-------|--------------|------------- unit definition section : no. | typeName | unitName | act | bias | st | position | act func | out func | sites ----|----------|----------|----------|----------|----|----------|--------------|----------|------- 1 | | sEsq | 0.34000 | -0.99750 | i | 1, 3, 1 | Act_Identity | | 2 | | sCnt | 0.45000 | 0.12717 | i | 1, 4, 1 | Act_Identity | | 3 | | sDir | 0.28000 | -0.61339 | i | 1, 5, 1 | Act_Identity | | 4 | | oculto | 1.00000 | 24.02031 | h | 3, 1, 1 ||| 5 | | oculto | 0.98070 | -2.20538 | h | 4, 1, 1 ||| 6 | | oculto | 0.95130 | -1.55068 | h | 3, 2, 1 ||| 7 | | oculto | 0.86800 | 7.87063 | h | 4, 2, 1 ||| 8 | | oculto | 0.00000 | -47.65002| h | 3, 3, 1 ||| 9 | | oculto | 0.99303 | -1.67387 | h | 4, 3, 1 ||| 10 | | oculto | 0.99974 | 21.43050 | h | 5, 3, 1 ||| 11 | | oculto | 0.58436 | 4.94572 | h | 3, 4, 1 ||| 12 | | oculto | 0.00144 | -12.52929| h | 4, 4, 1 ||| 13 | | oculto | 0.00000 | -19.60881| h | 5, 4, 1 ||| 14 | | oculto | 0.05709 | 0.07318 | h | 3, 5, 1 ||| 15 | | oculto | 0.01198 | 2.60847 | h | 4, 5, 1 ||| 16 | | oculto | 0.00000 | -64.47112| h | 5, 5, 1 ||| 17 | | oculto | 0.00135 | -3.60606 | h | 3, 6, 1 ||| 18 | | oculto | 0.00140 | 0.69503 | h | 4, 6, 1 ||| 19 | | oculto | 0.98534 | 0.31193 | h | 3, 7, 1 ||| 20 | | oculto | 0.00000 | -58.48545| h | 4, 7, 1 ||| 21 | | grau0 | 0.00000 | -0.64541 | o | 10, 4, 1 ||| 22 | | grau30 | 1.00000 | -19.72607| o | 9, 5, 1 ||| 23 | | grau90 | 0.00000 | -22.19844| o | 9, 6, 1 ||| 24 | | grau120 | 0.00640 | -0.65943 | o | 8, 7, 1 ||| 25 | | grau180 | 0.00000 | -5.32811 | o | 7, 4, 1 ||| 26 | | grau220 | 0.00000 | -5.29975 | o | 8, 1, 1 ||| 27 | | grau270 | 0.00000 | -1.49156 | o | 9, 2, 1 ||| 28 | | grau330 | 0.00000 | -3.97522 | o | 9, 3, 1 ||| ----|----------|----------|----------|----------|----|----------|--------------|----------|------- connection definition section : target | site | source:weight -------|------|--------------------------------------------------------------------------------------------------------------------- 4 | | 1:-2.69798, 2:-3.15108, 3:-25.21090 5 | | 1: 3.96806, 2:31.24192, 3:-33.12288 6 | | 1:62.06627, 2: 2.64763, 3:-63.46835 7 | | 1:-7.46317, 2:-5.52484, 3:-3.44134 8 | | 1:53.17605, 2:-1.33343, 3:-0.14132 9 | | 1:-0.10378, 2: 0.07629, 3:23.69132 10 | | 1:-15.25484, 2:-12.39511, 3:-8.64312 11 | | 1:22.91128, 2:-19.93140, 3:-12.23478

120

12 | | 1:25.05855, 2:-0.45884, 3:-8.30513 13 | | 1:-3.13781, 2: 2.21535, 3:21.34284 14 | | 1: 4.05916, 2:-25.33205, 3:25.50662 15 | | 1:-13.21846, 2:-2.05508, 3:-5.72196 16 | | 1: 0.19194, 2:72.14281, 3:-2.89443 17 | | 1:-15.41086, 2:-7.67594, 3:20.33433 18 | | 1: 4.30191, 2:-15.81754, 3:-5.75145 19 | | 1:-35.09380, 2:36.28424, 3:-1.78639 20 | | 1: 1.17616, 2:-1.48298, 3:64.15266 21 | | 4:-7.29600, 5:-30.24769, 6:-5.25493, 7: 0.35924, 8:-31.02905, 9: 7.41119, 10: 9.14604, 11: 2.36228, 12: 5.88715, 13:11.61123, 14: 8.62918, 15: 2.87683, 16: 0.32467, 17:-10.89467, 18: 3.83513, 19:-22.18593, 20:-27.55703 22 | | 4:-24.52096, 5:28.61205, 6:25.79306, 7:-2.17326, 8:-17.75300, 9:-7.31167, 10: 5.73598, 11: 6.71984, 12:-5.43337, 13:-3.59284, 14: 6.31532, 15:10.62583, 16:-29.41795, 17:-3.50909, 18:-7.47530, 19: 9.53954, 20:-0.27455 23 | | 4: 3.94771, 5:-3.64191, 6:17.85258, 7: 4.32341, 8:22.97949, 9: 6.81347, 10:-7.08089, 11:-10.57231, 12: 2.96930, 13:-8.18269, 14:-7.68322, 15:-2.81580, 16:24.53243, 17: 2.49387, 18:-4.29908, 19:-11.60732, 20:-17.39714 24 | | 4:-0.14004, 5:-0.49988, 6:-1.41358, 7:-0.41025, 8: 0.13682, 9:-1.21343, 10:-0.41955, 11:-0.05877, 12:-0.79616, 13:-1.38196, 14:-0.01904, 15: 0.49311, 16:-0.68520, 17:-0.78730, 18:-0.34063, 19:-0.40326, 20: 0.07378 25 | | 4:-10.47978, 5:-3.07577, 6:-0.41249, 7:-1.92305, 8:11.30459, 9:-3.78101, 10:-3.45541, 11:-3.08860, 12: 2.47330, 13:-1.77625, 14:-3.20887, 15: 0.19550, 16:-6.06821, 17:-0.07855, 18: 2.59469, 19:-5.29465, 20:10.09263 26 | | 4:-4.17997, 5: 2.85300, 6:-2.29660, 7:-1.14826, 8: 5.36008, 9:-3.35593, 10:-1.68075, 11:-4.25174, 12: 1.23888, 13:-0.56621, 14:-2.05270, 15:-0.71194, 16: 5.02423, 17:-2.29919, 18: 0.07192, 19: 1.58759, 20: 0.55390 27 | | 4:-17.31707, 5:11.93643, 6:-23.94735, 7: 9.19540, 8:-31.32139, 9:-3.08218, 10:-3.91423, 11:-2.53776, 12: 0.06819, 13: 9.97086, 14:-7.53734, 15:-3.35337, 16:26.72727, 17: 3.58549, 18: 4.07042, 19:-1.53553, 20:26.72148 28 | | 4: 5.62610, 5:-18.65056, 6:-28.87497, 7:-2.95670, 8: 3.56285, 9: 3.80239, 10: 2.69381, 11:-11.24108, 12:13.76191, 13:-13.65243, 14:-9.79296, 15: 2.34568, 16:-31.43298, 17:-2.13967, 18:-3.13060, 19:24.89387, 20:-26.59002 -------|------|--------------------------------------------------------------------------------------------------------------------- layer definition section : layer | unitNo. ------|---------------------------------------------------------------------------------------------------------------------------- 2 | 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 3 | 21, 22, 23, 24, 25, 26, 27, 28 ------|----------------------------------------------------------------------------------------------------------------------------

121

G ARQUIVO DE TREINAMENTO DA RNA

A seguir é apresentado o arquivo de treinamento utilizado no processo de treinamento das

RNAs treinadas pelo ambiente JavaNNS.

SNNS pattern definition file V4.2

generated at Sun Jun 14 16:58:51 2009

No. of patterns : 911

No. of input units : 3

No. of output units : 8

# Input pattern 1: # Input pattern 229: # Input pattern 457: # Input pattern 685:

0.3 0.24 0.68 0.4 0.43 0.85 0.86 0.86 0.51 0.19 0.36 0.76

# Output pattern 1: # Output pattern 229: # Output pattern 457: # Output pattern 685:

1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.56 0.61 0.05 0.7 0.4 0.35 0.46 0.77 0.14 0.31 0.24 0.56


0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.62 0.76 0.67 0.55 0.77 0.1 0.24 0.56 0.64 0.26 0.66 0.12


0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0


0.82 0.58 0.73 0.23 0.76 0.11 0.12 0.52 0.18 0.97 0.61 0.91


1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0


0.45 0.87 0.11 0.51 0.77 0.83 0.88 0.46 0.98 0.5 0.21 0.27


0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0


0.72 0.06 0.05 0.99 0.4 0.32 0.17 0.36 0.98 0.97 0.38 0.68


0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0


0.55 0.26 0.02 0.12 0.36 0.15 0.57 0.7 0.89 0.54 0.21 0.47


0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0


0.31 0.44 0.29 0.51 0.94 0.33 0.89 0.78 0.13 0.39 0.4 0.97


0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0

122


0.03 0.54 0.68 0.94 0.84 0.29 0.63 0.16 0.89 0.21 0.07 0


0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.28 0.73 0.14 0.96 0.99 0.99 0.89 0.21 0.31 0.39 0.96 0.75


0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0


0.64 0.5 0.73 0.57 0.23 0.25 0.41 0.59 0.12 0.41 0.18 0.32


1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.63 0.84 0.31 0.94 0.77 0.65 0.41 0.04 0.66 0.86 0.06 0.48


0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.33 0.15 0.04 0.19 0.7 0.14 1 0.61 0.16 0.24 0.14 0.55


0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0


0.49 0.18 0.02 0.38 0.12 0.53 0.46 0.96 0 0.42 0.8 0.34


0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0


0.64 0.33 0.05 0.04 0.42 0.58 0.52 0.64 0.95 0.25 0.68 0.29


0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1


0.84 0.05 0.85 0.12 0.25 0.59 0.38 0.17 0.57 0.96 0 0.96


1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0


0.17 0.62 0.83 0.95 0.69 0.66 0.56 0.08 0.5 0.97 0 0.97


0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0


0.19 0.43 0.91 0.63 0.12 0.81 0.59 0.92 0.66 0.98 0 0.98


0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0


0.85 0.48 0.09 0.63 0.86 0.54 0.28 0.28 0.89 0.99 0 0.99


0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0


0.69 0.68 0.24 0.57 0.27 0.36 0.08 0.47 0.89 0.99 0.06 0.97

123


0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0


0.38 0.95 0.73 0.23 0.59 0.02 0.01 0.54 0.67 1 0 1


0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0


0.38 0.51 0.39 0.41 0.09 0.42 0.42 0.26 0.65 0.96 0 0.98


0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0


0.85 0.8 0.62 0.13 0.09 0.77 0.86 0.17 0.5 0.98 0.01 1


0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0


0.65 0.91 0.27 0.86 0.21 0.86 0.83 0.12 0.15 1 0.05 0.96


0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0


0.29 0.87 0.96 0.58 0.56 0.27 0.06 0.84 0.75 0.96 0.07 0.99


0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0


0.05 0.88 0.38 0.55 0.06 0.3 0.54 0.28 0.34 0.99 0.03 0.96


0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0


0.41 0.47 0.75 0.27 0.71 0.56 0.1 0.24 0.38 0.96 0.09 1


0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0


0.65 0.81 0.15 0.34 0.85 0.71 0.16 0.9 1 0.63 0.02 0.6


0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0


0.55 0.76 0.11 0.7 0.35 0.12 0.7 0.28 0.93 0.33 0.26 0.89


0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0


0.05 0.86 0.19 0.33 0.08 0.65 0.49 0.25 0.58 0.48 0.09 0.75


0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.61 0.57 0.06 0.77 0.48 0.17 0.73 0.45 0.49 0.86 0.5 0.21


0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0

124


0.79 0.57 0.17 0.23 0.35 0.46 0.58 0.03 0.38 0.77 0.61 0.24


0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.92 0.5 0.55 0.01 0.39 0.58 0.34 0.51 0.57 0.51 0.96 0.56


0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0


0.9 0.43 0.37 0.26 0.42 0.96 0.19 0.8 0.5 0.26 0.75 0.37


0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1


0.03 0.66 0.97 0.81 0.72 0.62 0.99 0.82 0.28 0.74 0.39 0.67


0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0


0.05 0.4 0.33 0.56 0.84 0.01 0.37 0.29 0.57 0.03 0.92 0.04


0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0


0.51 0.17 0.61 0.9 0.24 0.08 0.3 0.92 0.57 0.26 0.6 0.31


1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1


0.23 0.53 0.82 0.71 0.62 0.29 0.87 0.34 0.92 0.84 0.44 0.73


0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0


0.52 0.39 0.48 0.3 0.22 0.02 0.23 0.54 0.38 0.77 0.09 0.24


1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0


0.32 0.44 0.88 0.17 0.81 0.77 0.69 0.3 0.1 0.28 0.45 0.34


0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.26 0.65 0.48 0.25 0.28 0.54 0.45 0.68 0.15 0.84 0.33 0.49


0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.4 0.69 0.43 0.95 0.09 0.32 0.85 0.19 0.14 0.4 0.7 0.56


0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.52 0.19 0.39 0.82 0.82 0.55 0.13 0.9 0.09 0.84 0.99 1

125


1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0


0.77 0.29 0.31 0.54 0.56 0.26 0.88 0.37 0.98 0.59 0.95 0.26


1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0


0.9 0.17 0.61 0.91 0.19 0.67 0.3 0.1 0.29 0.56 0.31 0.84


1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.05 0.29 0.81 0.73 0.11 0.44 0.25 0.46 0.42 0.55 0.79 0.32


0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0


0.37 0.23 0.96 0.14 0.21 0.09 0.38 0.82 0.6 0.98 0.01 0.11


0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0


0.4 0.05 0.03 0.85 0.88 0.89 0.26 0.75 0.79 0.12 0.36 0.07


0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0


0.5 0.84 0.05 0.04 0.13 0.47 0.33 0.48 0.06 0.5 0.54 0.92


0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0


0.66 0.84 0.61 0.27 0.21 0.67 0.62 0.29 0.94 0.57 0.43 0.66


0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0


0.58 0.8 0.48 0.87 0.58 0.85 0.39 0.15 0.98 0.26 0.13 0.34


0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0


0.17 0.2 0.56 0.14 0.26 0.66 0.57 0.43 0.87 0.77 0.77 0.9


0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.23 0.19 0.36 0.03 0.03 0.82 0.44 0.76 0.2 0.3 0.22 0.17


1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.58 0.04 0.1 0.23 0.55 0.79 0.77 0.6 0.34 0.59 0.74 0.68


1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1

126


0.72 0.67 0.12 0.51 0.44 0.68 0.99 0.51 0.32 0.81 0.9 0.93


0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0


0.96 0.14 0.33 0.1 0.98 0.82 0.33 0.02 0.24 0.02 0.67 0.67


0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.71 0.81 0.04 0.5 0.3 0.4 0.82 0.3 0.76 0.41 0.35 0.17


0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.45 0.27 0.12 0.02 0.62 0.28 0.82 0.75 0.4 0.04 0.72 0.49


0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.81 0.06 0.76 0.01 0.11 0.05 0.39 0.23 0.86 0.55 0.06 0.9


1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.49 0.77 0.18 0.57 0.36 0.28 0.22 0.81 0.39 0.35 0.8 0.79


0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1


0.96 0.34 0.13 0.17 0.67 0.79 0.51 0.48 0.24 0.09 0.88 0.51


0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.36 0.33 0.7 0.7 0.29 0.64 0.87 0.04 0.63 0.15 0.41 0.19


1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.49 0.61 0.62 0.47 0.1 0.03 0.23 0.8 0.02 0.51 0.56 0.51


0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0


0.44 0.99 0.34 0.73 0.89 0.89 0.27 0.04 0.74 0.01 0.55 0.85


0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.07 0.77 0.85 0.04 0.75 0.74 0.44 0.82 0.91 0.38 0.94 0.41


0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0


0.79 0.82 0.85 0.13 0.31 0.9 0.42 0.84 0.41 0.47 0.11 0.46

127


0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.99 0.69 0.37 0.6 0.07 0.58 0.48 0.02 0.28 0.65 0.04 0.45


0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.03 0.43 0.15 0.99 0.36 0.57 0.84 0.78 0.52 0.61 0.44 0.03


0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.44 0.69 0.62 0.17 0.67 0.69 0.74 0.83 0.69 0.21 0.91 0.85


0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1


0.37 0.12 0.41 0.25 0.81 0.62 0.91 0.79 0.42 0.2 0.21 0.62


1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1


0.38 0.24 0 0.59 0.53 0.55 0.63 0.51 0.38 0.6 0.66 0.22


0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0


1 0.75 0.04 0.26 0.33 0.36 0.73 0.91 0.85 0.12 0.83 0.69


0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1


0.62 0.65 0.45 0.61 0.08 0.73 0.1 0.65 0.7 0.79 0.32 0.72


0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0


0.54 0.73 0.19 0.11 0.08 0.94 0.24 0.63 0.64 0.55 0.48 0.52


0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0


0.35 0.08 0.25 0.17 0.04 0.32 0.96 0.99 0.51 0.07 0.1 0.83


1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1


0.04 0.97 0.18 0.64 0.25 0.05 0.53 0.11 0.77 0.84 0.33 0.09


0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.04 0.31 0.49 0.11 0.99 0.5 0.2 0.22 0.04 0.28 0.54 0.25


0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0

128


0.19 0.25 0.41 0.57 0.48 0.09 0.12 0.38 0.08 0.01 0.56 0.46


0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.88 0.16 0.01 0.6 0.49 0.7 0.47 0.3 0.8 0.49 0.49 0.07


0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.1 0.78 0.31 0.58 0.66 0.89 0.07 0.13 0.14 0.44 0.51 0.97


0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0


0.96 0.88 0.25 0.33 0.56 0.8 0.5 0.8 0.81 0.21 0.29 0.81


0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1


0.1 0.04 0.93 0.04 0.76 0.99 0.38 0.04 0.56 0.35 0.55 0.65


0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.49 0.52 0.25 0.36 0.82 0.11 0.9 0.58 0.76 0.66 0.21 0.59


0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.64 0.18 0.73 0.63 0.19 0.66 0.15 0.85 0.53 0.58 0.9 0.53


1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0


0.32 0.98 0.72 0.67 0.31 0.11 0.9 0.98 0.71 0.76 0.71 0.89


0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0


0.87 0.03 0.94 0.78 0.31 0.44 0.63 0.85 0.81 0.24 0.81 0.58


0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1


0.96 0.5 0.18 0.4 0.32 0.12 0.01 0.01 0.09 0.4 0.29 0.8


0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.29 0.77 0.75 0.66 0.98 0.48 0.74 0.82 0.94 0.4 0.23 0.26


0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0


0.39 0.58 0.61 0.24 0.9 0.41 0.82 0.02 0.67 0.35 0.02 0.69

129


0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.57 0.52 0.77 0.01 0.38 0.53 0.16 0.3 0.65 0.98 0.04 0.85


1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0


0.65 0.81 0.4 0.48 0.29 0.82 0.58 0.44 0.09 0.71 0.07 0.57


0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.43 0.29 0.26 0.07 0.34 0.4 0.43 0.12 0.55 0.05 0.91 0.15


0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0


0.01 0.49 0.92 0.26 1 0 0.47 0.42 0.02 0.69 0.93 0.21


0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0


0.06 0.7 0.06 0.23 0.65 0.21 0.67 0.19 0.22 0.41 0.51 0.71


0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.27 0.7 0.02 0.34 0.2 0.1 0.09 0.9 0.7 0.21 0.46 0.22


0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1


0.21 0.74 0.6 0.61 0.18 0.61 0.73 0.54 0.39 0.68 0.55 0.82


0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.68 0.82 0.62 0.06 0.44 0.63 0.83 0.54 0.12 0.02 0.65 0.37


0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.1 0.96 0.08 0.07 0.26 0.02 0.91 0.35 0.88 0.02 0.47 0.71


0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1


0.29 0.4 0.15 0.75 0.98 0.06 0.5 0.09 0.14 0.72 0.29 0.42


0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.32 0.97 0.72 0.1 0.95 0.57 0.23 0.48 0.94 0.8 0.61 0.71


0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0

130


0.37 0.39 0.99 0.35 0.95 0.34 0.75 0.71 0.26 0.39 0.65 0.22


0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.7 0.91 0.77 0.12 0.8 0.69 0.96 0.47 0.78 0.85 0.06 0.31


0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0


0.44 0.99 0.16 0.72 0.44 0.68 0.05 0.91 0.91 0.85 0.36 0.48


0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0


0.94 0.57 0.04 0.83 0.21 0.67 0.66 0.09 0.51 0.84 0.05 0.41


0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.99 0.33 0.37 0.71 0.18 0.81 0.41 0.79 0.35 0.39 0.79 0.41


0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.67 0.4 0.19 0.03 0 0.85 0.42 0.71 0.3 0.05 0.1 0.42


0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.7 0.61 0.82 0.41 0.57 0.68 0.12 0.56 0.04 0.05 0.39 0.21


1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.22 0.68 0.35 0.89 0.15 0.66 0.19 0.47 0.4 0.5 0.18 0.54


0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0


0.62 0.22 0.9 0.82 0.09 0.97 0.5 0.57 0.33 0.66 0.22 0.7


1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.78 0.89 0.3 0.95 0.54 0.45 0.87 0.14 0.97 0.23 0.56 0.1


0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0


0.37 0.3 0.57 0.44 0.57 0.56 0.2 0.11 0.77 0.2 0.42 0.04


1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.68 0.78 0.23 0.97 0.48 0.45 0.39 0.51 0.23 0.67 0.04 0.14

131


0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.89 0.46 0.81 0.32 0.07 0.26 0.06 0.33 0.57 0.22 0.93 0.05


1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0


0.1 0.23 0.31 0.44 0.87 0.4 0.21 0.35 0.75 0.21 0 0.42


0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0


0.45 0.12 0.79 0.77 0.06 0.59 0.8 0.98 0.72 0.26 0.14 0.6


1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0


0.16 0.13 0.87 0.43 0.35 0.63 0.14 0.1 0.82 0.93 0.16 0.34


1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0


0.71 0.6 0.37 0.04 0.43 0.76 0.66 0.21 0.54 0.38 0.39 0.72


0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.2 0.44 0.69 0.63 0.94 0.26 0.05 0.49 0.17 0.01 0.37 0.66


0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1


0.03 0.14 0.54 0.99 0.96 0.58 0.2 0.22 0.2 0.14 0.25 0.1


0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0


0.31 0.29 0.25 0.67 0.41 0 0.42 0.09 0.3 0.02 1 0.71


0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0


0.75 0.55 0.57 0.63 0.46 0.52 0.6 0.33 0.24 0.29 0.55 0.72


1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.8 0.02 0.67 0.17 0.84 0.21 0.33 0.87 0.55 0.69 0.93 0.41


1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0


0.09 0.34 0.55 0.81 0.78 0.28 0.86 0.65 0.33 0.31 0.2 0.74


0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0

132


0.19 0.53 0.9 0.91 0.02 0.99 0.43 0.57 0.42 0.5 0.36 0.89


0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.64 0.45 0.71 0.87 0.24 0.39 0.57 0.86 0.77 0.51 0.71 0.18


1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0


0.11 0.93 0.08 0.67 0.78 0.86 0.38 0.08 0.14 0.52 0.83 0.51


0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.01 0.13 0.26 0.04 0.82 0.33 0.75 0.88 0.52 0.74 0.14 0.47


0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.22 0.46 0.33 0.29 0.22 0.52 0.28 0.09 0.48 0.51 0.25 0.46


0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.68 0.01 0.45 0.24 0.98 0.5 0.01 0.38 0.77 0.61 0.88 0.61


1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0


0.12 0.17 0.47 0.04 0.52 0.02 0.69 0.44 0.73 0.49 0.45 0.28


0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.89 0.96 0.36 0.54 0.95 0.12 0.26 0.92 0.34 0.24 0.39 0.59


0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1


0.15 0.75 0.64 0.02 0.73 0.99 0.76 0.35 0.96 0.58 0.25 0.65


0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0


0.68 0.74 0.6 0.55 0.77 0.24 0.2 0.92 0.14 0.3 0.22 0.29


0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0


0.62 0.04 0.96 0.17 0.37 0.95 0.24 0.63 0.96 0.84 0.09 0.88


0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0


0.25 0.99 0.15 0.86 0.94 0.46 0.25 0.71 0.35 0.33 0.66 0.69

133


0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1


0.43 0.28 0.33 0.74 0.46 0.75 0.31 0.15 0.43 0.02 0.97 0.89


1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0


0.89 0.96 0.15 0.49 0.18 0.73 0.89 0.01 0.6 0.25 0.77 0.43


0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.86 0.13 0.97 0.64 0.33 0.23 0.18 0.25 0.5 0.41 0.16 0.53


0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0


0.26 0.07 0.9 0.6 0.84 0.75 0.52 0.35 0.56 0.45 0.61 0.98


1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0


0.41 0.16 0.63 0.68 0.82 0.23 0.3 0.03 0.39 0.66 0.62 0.85


1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.73 0.36 0.91 0.14 0.73 0.36 0.01 0.4 0.96 0.76 0.27 0.35


0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0


0.93 0.33 0.76 0.81 0.31 0.04 0.24 0.63 0.92 0.19 0.91 0.43


0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0


0.01 0.88 0.12 0.23 0.82 0.18 0.59 0.81 0.35 0.27 0.15 0.78


0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.35 0.8 0.41 0.47 0.65 0.91 0.01 0.97 0.24 0.05 0.91 0.1


0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0


0.91 0.26 0.69 0.39 0.76 0.91 0.85 0.93 0.03 0.82 0.23 0.76


0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0


0.42 0.33 0.4 0.12 0.55 0.41 0.66 0.5 0.56 0.73 0.34 0.25


1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0

134


0.16 0.3 0.1 0.94 0.89 0.29 0.86 0.47 0.84 0.18 0.39 0.58


0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.25 0.21 0.82 0.21 0.84 0.94 0.96 0.34 0.09 0.2 0.83 0.51


1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1


0.82 0 0.46 0.74 0.43 0.47 0.81 0.91 0.62 0.81 0.12 0.03


1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0


0.01 0.14 0.19 0.3 0.57 0.22 0.64 0.19 0.11 0.93 0.29 0.62


0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0


0.98 0.58 0.13 0.31 0.24 0.34 0.77 0.7 0.64 0.21 0.64 0.36


0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.1 0.69 0.8 0.26 0.63 0.4 0.21 0.19 0.19 0.37 0.43 0.46


0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.16 0.57 0.71 0.25 0.21 0.34 0.85 0.98 0.63 0.6 0.15 0.62


0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0


0.57 0.7 0.67 0.9 0.88 0.93 0.03 0.78 0.98 0.57 0.69 0.82


0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1


0.56 0.34 0.48 0.41 0.7 0.26 0.58 0.9 0 0.72 0.36 0.61


1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.6 0.29 0.5 0.32 0.51 0.82 0.78 0.88 0.76 0.07 0.71 0.58


1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.17 0.53 0.15 0.54 0.18 0.93 0.53 0.37 0.32 0.7 0.8 0.6


0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.06 0.75 0.75 0.84 0.62 0.44 0.57 0.58 0.61 0.53 0.6 0.64

135


0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1


0.97 0.92 0.99 0.99 0.33 0.82 0.8 0.49 0 0.57 0.19 0.39


0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.4 0.66 0.91 0.73 0.66 0.02 0.3 0.87 0.74 0.04 0.58 0.89


0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1


0.11 0.93 0.85 0.49 0.99 0.63 0.05 0.82 0.43 0.73 0.58 0.54


0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0


0.53 0.96 0.37 0.99 0.39 0.29 0.33 0.53 0.49 0.1 0.49 0.58


0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1


0.38 0.14 0.44 0.3 0.81 0.15 0.44 0.89 0.17 0.64 0.35 0.13


1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.52 0.69 0.26 0.44 0.51 0.4 0.43 0.81 0.26 0.06 0.18 0.02


0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.74 0.98 0.96 0.04 0.86 0.77 0.61 0.54 0.93 0.56 0.31 0.94


0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0


0.01 0.19 0.25 0.59 0.09 0.43 0.72 0.82 0.9 0.74 0.26 0.76


0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0


0.89 0.21 0.12 0.24 0.62 0.66 0.69 0.1 0.36 0.58 0.75 0.97


0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0


0.67 0.02 0.08 0.05 0.69 0.94 0.18 0.36 0.16 0.47 0.38 0.12


1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.7 0.47 0.62 0.52 0.78 0.39 0.37 0.61 0.36 0.69 0.03 0.08


1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0

136


0.93 0.19 0.76 0.64 0.54 0.7 0.04 0.68 0.02 0.27 0.4 0.85


0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.23 0.99 0.73 0.53 0.83 0.9 0.82 0.48 0.23 0.58 0.3 0.2


0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.37 0.56 0.93 0.38 0.64 0.9 0.43 0.38 0.5 0.51 0.6 0.18


0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.7 0.2 0.38 0.09 0.77 0.06 0.72 0.5 0.96 0.81 0.94 0.64


1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0


0.05 0.09 0.27 0.64 0.82 0.11 0.38 0.68 0.57 0.15 0.99 0.03


0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0


0.1 0.14 0.07 0.43 0.41 0.52 0.93 0.75 0.83 0.76 0.34 0.07


0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0


0.81 0.38 0.66 0.04 0.57 0.26 0.78 0.39 0.62 0.64 0.41 0.12


1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.25 0.53 0.85 0.12 0.9 0.51 0.09 0.74 0.45 0.7 0.18 0.96


0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0


0.9 0.74 0.7 0.29 0.21 0.89 0.03 0.14 0.24 0.34 0.16 0.31


0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0


0.44 0.69 0.97 0.31 0.9 0.28 0.35 0.28 0.78 0.48 0.22 0.88


0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.6 0.24 0.32 0.95 0.43 0.38 0.59 0.23 0.57 0.92 0.59 0.56


1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0


0.76 0.93 0.78 0.15 0.06 0.02 0.08 0.71 0.83 0.3 0.81 0.29

137


0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0


0.29 0.74 0.46 0.47 0.34 0.85 0.03 0.4 0.97 0.88 0.77 0.43


0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0


0.59 0.25 0.63 0.2 0.33 0.41 0.96 0.31 0.49 0.52 0.36 0.49


1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0


0.24 0.29 0.7 0.13 0.58 0.52 0.15 0.89 0.63 0.94 0.65 0.64


0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0


0.64 0.27 0.57 0.02 0.35 0.98 0.61 0.26 0.61 0.67 0.07 0.22


1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.96 0.93 0.2 0.44 0.82 0.55 0.87 0.94 0.37 0.87 0.09 0.7


0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0


0.74 0.87 0.19 0.82 0.87 0.87 0.78 0.05 0.91 0.56 0.54 0.04


0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0


0.54 0.66 1 0.74 0.95 0.03 0.28 0.77 0.69 0.2 0.09 0.84


0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0


0.82 0.59 0.78 0.71 0.38 0.47 0.83 0.07 0.71 0.69 0.96 0.29


1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0


0.69 0.17 0.54 0.8 0.67 0.84 0.96 0.39 0.88 0.06 0.6 0.42


1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1


0.19 0.04 0.38 0.33 0.91 0.18 0.08 0.86 0.65 0.05 0.22 0.22


1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1


0.19 0.27 0.04 0.73 0.33 0.15 0.52 0.7 0.85 0.02 0.73 0.91


0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0

138


0.5 0.72 0.97 0.24 0.51 0.05 0.1 0.97 0.39 0.82 0.06 0.72


0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0


0.46 0.57 0.7 0.97 0.35 0.18 0.29 0.87 0.58 0.04 0.75 0.68


0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1


0.28 0.06 0.46 0.21 0.74 0.09 0.7 0.32 0.91 0.5 0.55 0.5


1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0


0.63 0.73 0.98 0.16 0.37 0.7 0.24 0.31 0.85 0.1 0.91 0.12


0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0


0.9 0.63 0.86 0.69 0.61 0.15 0.68 0.4 0.51 0.2 0.44 0.19


1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.67 1 0.53 0.34 0.84 0.86 0.08 0.09 0.05 0.71 0.72 0.08


0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.88 0.28 0.64 0.9 0.01 0.78 0.61 0.28 0.14 0.4 0.55 0.29


1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.62 0.9 0.75 0.16 0.45 0.36 0.51 0.29 0.53 0.41 0.29 0.24


0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.68 0.16 0.12 0.62 0.32 0.98 0.71 0.08 0.02 0.47 0.31 0.03


0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.88 0.8 0.6 0.67 0.29 0.61 0.85 0.42 0.84 0.9 0.8 0.79


0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.48 0.68 0.04 0.95 0.15 0.87 0.46 0.67 0.13 0.37 0.06 0.14


0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.09 0.04 0.86 0.14 0.27 0.84 0.07 0.18 0.01 0.19 0.75 0.25

139


1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.18 0.99 0.21 0.46 0.6 0.73 0.51 0.11 0.62 0.32 0.14 0.62


0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.13 0.58 0.38 0.43 0.3 0.71 0.4 0.82 0.66 0.31 0.22 0.88


0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0


0.86 0.27 0.44 0.19 0.82 0.76 0.27 0.41 0.64 0.1 0.96 0.73


1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0


0.35 0.95 0.05 0.6 0.01 0.91 0.08 0.24 0.87 0.93 0.42 0.28


0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0


0.83 0.2 0.65 0.68 0.82 0.87 0.77 0.96 0.42 0.18 0.15 0.56


1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0


0.27 0.09 0.22 0.35 0.55 0.96 0.47 0.97 0.11 0.64 0.18 0.25


1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0


0.61 0.87 0.07 0.6 0.71 0.6 0.05 0.99 0.21 0.34 0.87 0.05


0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0


0.18 0.14 0.62 0.4 0.65 0.23 0.99 0.18 0.75 0.73 0.19 0.44


1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0


0.88 0.17 0.28 0.15 0.14 0.43 0.73 0.88 0.24 0.41 0.9 0.11


1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.08 0.44 1 0.75 0.67 0.38 0.31 0.17 0.66 0.97 0.41 0.85


0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0


0.18 0.44 0.71 0.08 0.09 0.48 0.31 0.45 0 0.3 0.36 0.95


0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0

140


0.8 1 0.02 0.36 0.05 0.05 0.26 0.76 0.74 0.3 0.22 0.01


0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0


0.73 0.95 0.75 0.19 0.88 0.49 0.44 0.83 0.66 0.57 0.08 0.06


0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0


0.92 0.31 0.99 0.96 0.98 0.13 0.77 0.14 0.76 0.33 0.4 0.33


0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0


0.1 0.68 0.8 0.04 0.86 0.46 0.83 0.19 0.9 0.28 0.02 0.04


0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.76 0.73 0.31 0.86 0.34 0.57 0.46 0.67 0.1 0.32 0.55 0.94


0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0


0.39 0.24 0.24 0.69 0.12 0.35 0.92 0.53 0.77 0.49 0.91 0.87


1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0


0.75 0.61 0.48 0.3 0.35 0.53 0.57 0.99 0.65 0.59 0.02 0.91


0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0


0.16 0.96 0.51 0.4 0.95 0.38 0.38 0.56 0.67 0.46 0.47 0.1


0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0


0.08 0.03 0.71 0.63 0.3 0.31 0.31 0.44 0.53 0.19 0.87 0.78


1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1


0.91 0.48 0.21 0.88 0.9 0.76 0.22 0.38 0.46 0.36 0.09 0.45


0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0


0.43 0.76 0.12 0.48 0.55 0.62 0.09 0.23 0.57 0.87 0.32 0.79


0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0


0.1 0.03 0.07 0.14 0.22 0.15 0.61 0.84 0.12 0.87 0.48 0.17

141


1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0

# Input pattern 228: # Input pattern 456: # Input pattern 684:

0.76 0.85 0.69 0.29 0.42 0.76 0.76 0.5 0.3

# Output pattern 228: # Output pattern 456: # Output pattern 684:

0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0

142

H ARQUIVO DE VALIDAÇÃO DA RNA

A seguir é apresentado o arquivo de validação utilizado no processo de validação das RNAs

validadas pelo ambiente JavaNNS.

SNNS pattern definition file V4.2 generated at Sun Jun 14 23:10:00 2009

No. of patterns : 200

No. of input units : 3

No. of output units : 8


0.6 0.02 0.63 0.46 0.56 0.01 0.46 0.25 0.51 0.31 0.16 0.34


1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.89 0.26 0.33 0.07 0.49 0.49 0.61 0.88 0.61 0.88 0.22 0.48


1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0


0.75 0.09 0.48 0.97 0.51 0.44 0.28 0.45 0.49 0.56 0.59 0.92


1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0


0.21 0.5 0.86 0.81 0.29 0.21 0.59 0.39 0.24 0.29 0.81 0.3


0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.24 0.61 0.77 0.65 0.55 0.35 0.65 0.25 0.58 0.43 0.77 0.88


0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.56 0.96 0.51 0.59 0.21 0.66 0.29 0.22 0.3 0.49 0.36 0.52


0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.37 0.75 0.26 0.53 0.9 0.58 0.88 0.09 0.84 0.64 0.65 0.94


0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0


0.67 0.39 0.74 0.89 0.71 0.76 0.69 0.66 0.33 0.22 0.07 0.67


1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0

143


0.04 0.92 0.03 0.58 0.81 0.24 0.89 0.97 0.02 0.7 0.09 0.87


0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0


0.31 0.6 0.26 0.8 0.29 0.4 0.43 0.77 0.25 0.04 0.54 0.56


0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.73 0.44 0.84 0.26 0.23 0.4 0.53 0.16 0.41 0.84 0.09 0.2


1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.24 0.09 0.77 0.69 0.02 0.35 0.98 0.61 0.45 0.29 0.96 0.69


1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0


0.34 0.45 0.28 0.85 0.04 0.98 0.85 0.62 0.66 0.42 0.6 0.06


0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.49 0.33 0.84 0.57 0.07 0.71 0.35 0.27 0.76 0.22 0.22 0.05


1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.56 0.7 0.4 0.15 0.91 0.05 0.43 0.91 0.19 0.91 0.73 0.02


0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0


1 0.99 0.84 0.21 0.93 0.69 0.78 0.15 0.27 0.72 0.06 0.82


0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.26 0.95 0.59 0.71 0.51 0.41 0.1 0.91 0.05 0.68 0.75 0.04


0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0


0.84 0.31 0.56 0.22 0.46 0.21 0.76 0.23 0.82 0.5 0.55 0.5


1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0


0.32 0.79 0.55 0.82 0.55 0.68 0.25 0.34 0.73 0.12 0.91 0.1


0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0


0.11 0.01 0.98 0.37 0.65 0.02 0.58 0.39 0.18 0.19 0.44 0.2

144


0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.07 0.36 0.12 0.71 0.47 0.02 0.51 0.83 0.2 0.08 0.72 0.71


0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.92 0.54 0.5 0.42 0.29 0.72 0.03 0.12 0.81 0.29 0.55 0.4


0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1


0.66 0.43 0.57 0.71 0.61 0.8 0.62 0.29 0.93 0.24 0.29 0.41


1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1


0.34 0.13 0.26 0.22 0.65 0.39 0.36 0.64 0.21 0.03 0.31 0.47


1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.9 0.77 0.77 0.31 0.06 0.85 0.46 0.43 0.37 0.79 0.8 0.9


1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.17 0.22 0.3 0.48 0.36 0.85 0.62 0.15 0.6 0.14 0.06 0.37


0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.68 0.74 0.59 0.41 0.05 0.84 0.82 0.69 0.57 0.25 0.75 0.19


0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0


0.93 0.9 0.81 0.41 0.79 0.39 0.61 0.36 0.72 0.62 0.14 0.32


0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.67 0.67 0.02 0.42 0.1 0.05 0.58 0.71 0.07 0.88 0.22 0.31


0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.17 0.35 0.41 0.21 0.39 0.05 0.6 0.8 0.7 0.73 0.96 0.1


0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0


0.49 0.72 0.04 0.54 0.18 0.5 0.64 0.6 0.53 0.28 0.42 0.93


0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0

145


0.9 0.06 0.55 0.7 0.22 0.66 0.39 0.19 0.57 0.56 0.15 0.18


1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.79 0.8 0.35 0.1 0.56 0.23 0.89 0.58 0.04 0.25 0.18 0.64


0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.51 0.88 0.09 0.04 0.42 0.2 0.54 0.58 0.73 0.05 0.87 0.34


0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1


0.19 0.41 0.15 0.14 0.04 0.67 0.58 0.49 0.1 0.44 0.19 0.73


0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.51 0.56 0.51 0.05 0.93 0.22 0.13 0.35 0.64 0.11 0.9 0.41


0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1


0.85 0.55 0.01 0.42 0 0.21 0.02 0.18 0.06 0.85 0.41 0.97


0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0


0.41 0.94 0.38 0.6 0.14 0.26 0.94 0.31 0.56 0.95 0.36 0.3


0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0


0.46 0.11 0.47 0.34 0.16 0.93 0.76 0.26 0.74 0.01 0.22 0.3


1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1


0.45 0.04 0.65 0.72 0.39 0.38 0.97 0.75 0.58 0.06 0.08 0.57


1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1


0.03 0.44 0.61 0.66 0.37 0.01 0.12 0.38 0.47 0.33 0.4 0.33


0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0


0.85 0.91 0.21 0.1 0.25 0.14 0.08 0.03 0.69 0.04 0.02 0.28


0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0


0.62 0.21 0.2 0.71 1 0.02 0.85 0.4 0.27 0.94 0.55 0.32

146


0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0


0.22 0.66 0.6 0.72 0.55 0.29 0.2 0.3 0.58 0.87 0.91 0.49


0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0


0.69 0.83 0.12 0.41 0.93 0.69 0.18 0.6 0.51 0.91 0.02 0.59


0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0


0.72 0.32 0.79 0.74 0.2 0.31 0.64 0.94 0.81 0.1 0.47 0.46


1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1


0.52 0.48 0.55 0.89 0.36 0.5 0.03 0.99 0.15 0.78 0.87 0.19


1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0


0.83 0.1 0.07 0.18 0.71 0.51 0.07 0.34 0.76 0.45 0.09 0.36


0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0


0.09 0.33 0.84 0.51 0.83 0.52 0.12 0.41 0.64 0.79 0.32 0.87


0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0


0.25 0.54 0.28 0.47 0.14 0.74 0.96 0.18 0.7 0.17 0.48 0.87


0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1

147

I ARQUIVO DE RESULTADO DA RNA - VALIDAÇÃO

A seguir é apresentado os dados contidos na arquivos de resultado referente à validação da

RNA GSC200901-B gerado pelo JavaNNS.

SNNS result file V1.4-3D generated at Mon Jun 15 00:56:44 2009 No. of patterns : 911 No. of input units : 3 No. of output units : 8 startpattern : 1 endpattern : 911 #1.1 0.99789 0 0 0.02602 0 0 0 0.00066 #2.1 0 1 0 0.00821 0 0 0 0 #3.1 0 0.00001 0 0.04888 0 0.00004 0 0.99953 #4.1 0.99998 0 0.00006 0.01539 0 0 0 0 #5.1 0 1 0 0.00929 0 0.00001 0 0 #6.1 0.07767 0.96081 0 0.00689 0 0 0 0 #7.1 0 1 0 0.01108 0 0 0 0 #8.1 0 0.9998 0 0.01039 0 0 0 0.00002 #9.1 0 0 0 0.01784 0 0 0 1 #10.1 0 1 0 0.00768 0 0 0 0 #11.1 1 0 0 0.08717 0 0 0 0.00001 #12.1 0 0.99999 0.00002 0.00721 0 0.00001 0 0.00001 #13.1 0 1 0 0.01723 0 0 0 0 #14.1 0 1 0 0.0133 0 0 0 0 #15.1 0 1 0 0.00864 0 0 0 0 #16.1 1 0 0 0.02621 0 0 0 0.00004 #17.1 0.00003 0 0 0.0151 0 0 0 1 #18.1 0 0 0 0.01036 0 0 0.93178 0.09776 #19.1 0 0.99997 0.00001 0.00872 0 0 0 0 #20.1 0 1 0 0.00528 0 0 0 0 #21.1 0 0 0.00216 0.02383 0 0.02095 1 0 #22.1 0 0.02054 0 0.0202 0 0 0 0.96997 #23.1 0 0.99713 0.00425 0.00814 0 0 0 0 #24.1 0 0.00021 0.99835 0.0044 0 0.00053 0 0 #25.1 0 0 0 0.01332 0.00002 0.00001 1 0 #26.1 0 0.00001 0 0.02405 0 0.00003 0.00441 0.99984 #27.1 0.00004 0 0 0.02605 0 0 0 1 #28.1 0 1 0 0.00543 0 0 0 0 #29.1 0 1 0 0.00707 0 0 0 0 #30.1 0 0.0005 0 0.02849 0 0.00002 0.00121 0.99998 #31.1 0 1 0 0.00846 0 0 0 0 #32.1 0 0.99979 0.00006 0.00653 0 0 0 0

148

#33.1 0 0 0.99041 0.01269 0 0 0 0 #34.1 0 0.90227 0.0135 0.00762 0 0 0 0 #35.1 0 0 0 0.00685 0 0 1 0 #36.1 0 0 0 0.02834 0 0 0 1 #37.1 1 0 0 0.04101 0 0 0 0 #38.1 0.00001 0 0 0.0169 0 0 0 1 #39.1 1 0 0 0.0203 0 0 0 0 #40.1 0.00005 0 0 0.01562 0 0 0.00002 0.99987 #41.1 0 0.00004 0 0.02588 0 0.00001 0.00005 1 #42.1 0 0.00217 0 0.02596 0 0.00002 0 0.99996 #43.1 1 0.00006 0 0.01285 0 0 0 0 #44.1 0.99951 0.08965 0 0.00622 0 0 0 0 #45.1 0.91129 0 0.09515 0.01011 0 0 0 0 #46.1 0 0 0 0.01482 0 0 0 1 #47.1 0.00083 0 0 0.01672 0.00005 0 1 0 #48.1 0.02044 0.94462 0 0.01835 0 0 0 0 #49.1 0 1 0 0.01221 0 0.00001 0 0 #50.1 0 0.99998 0.00006 0.01181 0 0.00003 0 0 #51.1 0 1 0.00005 0.01093 0 0.00002 0 0 #52.1 0.00097 0 0 0.02044 0 0 0 0.99972 #53.1 1 0 0 0.04179 0 0 0 0.00003 #54.1 1 0 0 0.0077 0 0 0 0 #55.1 0 1 0 0.00683 0 0 0 0 #56.1 0.00033 0 0.99244 0.00761 0 0 0 0 #57.1 0 1 0 0.00964 0 0 0 0 #58.1 0 1 0 0.01014 0 0 0 0 #59.1 1 0 0 0.01223 0 0 0 0 #60.1 0 1 0 0.00754 0 0 0 0 #61.1 0 0.00075 0.99967 0.00752 0 0.00001 0 0 #62.1 0.98382 0 0 0.0277 0 0 0 0.04138 #63.1 0 0 0 0.05042 0 0 0 1 #64.1 0 0 1 0.00537 0 0.00161 0.0001 0 #65.1 0.00073 0 0 0.01129 0 0 0.00001 0.99996 #66.1 0.07095 0 0 0.05681 0 0.0001 0.00001 0.99984 #67.1 0 0 1 0.00945 0 0.00004 0 0 #68.1 0 0.08509 0 0.03581 0 0.00001 0.00035 1 #69.1 0 0 0 0.04085 0 0.00001 0 1 #70.1 1 0 0 0.04469 0 0 0 0 #71.1 0 1 0 0.02069 0 0 0 0 #72.1 0 0.00025 1 0.0211 0.00004 0.00042 0 0 #73.1 0 1 0 0.00849 0 0 0 0 #74.1 0 1 0 0.00646 0 0 0 0 #75.1

149

1 0.00001 0 0.01189 0 0 0 0 #76.1 0 0 0.00089 0.01567 0 0.00242 1 0 #77.1 0 0 0 0.01946 0 0 0 1 #78.1 0.00216 0 0 0.02739 0 0 0 1 #79.1 0 0.99829 0 0.00886 0 0 0 0 #80.1 0 0.00023 0 0.02576 0 0.00001 0.00037 0.99999 #81.1 0 0 1 0.00801 0 0.00009 0 0 #82.1 0.00225 0 0 0.01445 0 0 1 0 #83.1 0 1 0 0.00654 0 0 0 0 #84.1 1 0 0 0.04265 0 0 0 0 #85.1 0 0 0.02756 0.02027 0 0.0234 1 0 #86.1 0 0 0 0.02596 0.01141 0 0.9995 0 #87.1 0 0.00003 1 0.00891 0 0.00003 0 0 #88.1 0 0 0 0.02718 0 0 0 1 #89.1 0.00009 0 0 0.04067 0 0 0 1 #90.1 0.99971 0 0 0.07099 0 0 0 0.00871 #91.1 0 0.99999 0.00003 0.00795 0 0.00001 0 0 #92.1 0.09252 0.96525 0 0.01055 0 0 0 0 #93.1 0 0 0 0.00745 0 0 0.99967 0.00054 #94.1 0 1 0 0.02669 0 0.00002 0 0.00458 #95.1 0 1 0 0.01556 0 0.00002 0 0 #96.1 0 0 0 0.02158 0 0.00001 0.00002 1 #97.1 0 0.99999 0.00006 0.01086 0 0.00002 0 0 #98.1 0 0.00005 0.99837 0.00687 0 0.00108 0.09654 0 #99.1 0 1 0 0.00669 0 0 0 0 #100.1 0 0 0.01831 0.02014 0 0.02009 1 0 #101.1 0 0 0 0.01218 0.00003 0 1 0 #102.1 0 0.00043 0 0.03884 0 0.00422 0.91799 0.08873 #103.1 0 0 0.99998 0.00494 0 0.00116 0.00007 0 #104.1 0 0.03256 0.99893 0.01714 0 0.00009 0 0 #105.1 0 0 0.99996 0.01037 0 0 0 0 #106.1 0 0.99995 0.00002 0.00507 0 0 0 0 #107.1 1 0 0 0.09858 0 0 0 0.00011 #108.1 0 0.00011 0 0.02541 0 0.00002 0.00025 0.99999 #109.1 0.95151 0 0 0.03355 0 0 0.0173 0 #110.1 0 0.98801 0.00047 0.00471 0 0.00001 0 0 #111.1 1 0 0 0.03785 0 0 0 0.00002 #112.1 0 1 0 0.00519 0 0 0 0 #113.1 0.99914 0.00007 0.00263 0.01563 0 0 0 0 #114.1 0.00048 0 0 0.03182 0 0 0 1 #115.1 0.99995 0 0 0.02605 0 0 0 0 #116.1 0.99894 0 0 0.01909 0 0 0 0.00004 #117.1 0 0.99965 0.00014 0.00707 0 0 0 0

150

#118.1 0 0 0 0.01841 0 0 0 1 #119.1 0 0 0 0.01941 0 0 0 1 #120.1 0.00002 0.95528 0 0.01031 0 0 0 0 #121.1 0.91352 0.00024 0.00002 0.01268 0 0 0 0 #122.1 1 0 0 0.00683 0 0 0 0 #123.1 0 0 0 0.01836 0 0 0 1 #124.1 0.00004 0 0 0.01076 0 0 0.08057 0.90566 #125.1 1 0 0 0.07836 0 0 0 0 #126.1 0 0.00111 0.99585 0.00673 0 0.00068 0.00667 0 #127.1 0.0002 0 0 0.03081 0 0 0 1 #128.1 0 0.00001 0 0.02507 0 0.00001 0.00012 1 #129.1 1 0 0 0.00651 0 0 0 0 #130.1 0.00006 0 0 0.02018 0 0 0 0.99999 #131.1 0 0 1 0.00299 0 0.00062 0 0 #132.1 0 0 0 0.0174 0 0 0.00001 1 #133.1 0 1 0.00001 0.01041 0 0.00001 0 0 #134.1 0.00019 0 0 0.02501 0.00001 0 1 0 #135.1 0 0.00001 0.99995 0.00421 0 0.00055 0.00048 0 #136.1 1 0.00046 0 0.01312 0 0 0 0 #137.1 0 0 0.99999 0.00343 0 0.00061 0 0 #138.1 0 0 0 0.02881 0.01794 0 1 0 #139.1 0.94989 0 0 0.0198 0 0 0.08029 0 #140.1 0.99998 0 0 0.02851 0 0 0 0 #141.1 0.07406 0 0 0.05358 0.00001 0 0.92209 0 #142.1 0.00001 0 0.99966 0.0149 0 0 0 0 #143.1 0 0.00014 0 0.03409 0 0.00006 0.08955 0.99518 #144.1 0 0.00027 0 0.02964 0 0.00003 0 1 #145.1 0.00719 0 0.95783 0.01318 0 0 0 0 #146.1 1 0 0 0.02669 0 0 0 0 #147.1 0 1 0 0.01037 0 0 0 0 #148.1 0.99845 0 0 0.02335 0 0 0 0.00183 #149.1 1 0 0 0.00544 0 0 0 0 #150.1 0.00179 0 0 0.04316 0 0 0 1 #151.1 0 0.00002 1 0.01125 0 0.00006 0 0 #152.1 0.00001 0 0 0.01544 0 0 0 1 #153.1 0 0 0 0.01871 0 0 0 1 #154.1 0 0 0 0.05922 0 0.00001 0 1 #155.1 1 0.0001 0 0.01526 0 0 0 0 #156.1 1 0.00009 0 0.01414 0 0 0 0 #157.1 0 0.99999 0 0.01109 0 0 0 0.00009 #158.1 0 0 0 0.01722 0 0 0 1 #159.1 0 0 0 0.02112 0.99855 0.05369 0.05745 0 #160.1

151

0 0 0 0.01905 0 0 0.90585 0.0939 #161.1 0 0 0 0.00808 0 0.00008 1 0.00111 #162.1 0 0 1 0.00585 0 0.0024 0.0001 0 #163.1 1 0 0 0.04476 0 0 0 0 #164.1 0 1 0 0.00691 0 0 0 0 #165.1 0 0 0 0.01593 0 0.05242 1 0 #166.1 0.00012 0 0 0.03527 0 0 0 1 #167.1 0 0.98752 0 0.00532 0 0 0 0 #168.1 1 0 0 0.00722 0 0 0 0 #169.1 0.99999 0 0 0.01768 0 0 0 0 #170.1 0.00001 0 0.99966 0.01351 0 0 0 0 #171.1 0 0 0.01829 0.01357 0 0.00775 1 0 #172.1 0 0 0 0.01438 0 0 0.99999 0.00001 #173.1 1 0 0 0.0075 0 0 0 0 #174.1 0.04965 0 0 0.03067 0 0 0 0.99867 #175.1 0 0.99995 0 0.02726 0 0 0 0 #176.1 1 0 0.00003 0.01296 0 0 0 0 #177.1 0.00005 0 0 0.0157 0 0 0 1 #178.1 0 0.90984 0.01321 0.00981 0 0 0 0 #179.1 0 0 0 0.01562 0.00004 0.00001 1 0 #180.1 1 0.00004 0 0.00978 0 0 0 0 #181.1 0 0.00001 0 0.01986 0 0.03403 0.9999 0 #182.1 0 0.00014 0 0.02813 0 0.00002 0.00002 1 #183.1 1 0 0 0.05374 0 0 0 0 #184.1 0.00005 0 0 0.01961 0 0 0 0.99999 #185.1 1 0.00002 0 0.01514 0 0 0 0 #186.1 0 0 1 0.00438 0 0.00661 0 0 #187.1 0 0.99998 0 0.00535 0 0 0 0 #188.1 0 0 0 0.01585 0.0001 0.00001 1 0 #189.1 1 0 0 0.02155 0 0 0 0 #190.1 1 0.00001 0 0.01 0 0 0 0 #191.1 1 0 0 0.02942 0 0 0 0 #192.1 0 1 0 0.01432 0 0 0 0 #193.1 0 0 0 0.01725 0.00006 0.00001 1 0 #194.1 0.00009 0 0 0.04304 0 0 0 1 #195.1 1 0 0 0.0286 0 0 0 0 #196.1 0 0 0 0.02214 0.00014 0.00002 1 0 #197.1 0.99952 0.00051 0.00011 0.02012 0.00003 0 0 0 #198.1 0 0 1 0.00496 0 0.00521 0.00019 0 #199.1 0.99917 0 0.00307 0.01197 0 0 0 0 #200.1 0 0.0001 0 0.04542 0 0.00123 0.06306 0.91396 #201.1 0.0056 0.99728 0 0.00477 0 0 0 0 #202.1 0 0.9718 0.04151 0.00836 0 0 0 0

152

#203.1 0 1 0 0.01194 0 0 0 0 #204.1 0.9996 0 0 0.01991 0 0 0 0.00005 #205.1 0 0 0.073 0.01048 0 0.002 0.99997 0 #206.1 0 0.00006 0 0.02339 0 0.00001 0.0007 0.99999 #207.1 1 0 0.00001 0.00895 0 0 0 0 #208.1 0 0.00068 0.99778 0.00768 0 0.00277 0.00094 0 #209.1 1 0 0 0.00973 0 0 0 0 #210.1 1 0 0 0.0161 0 0 0 0 #211.1 0 1 0 0.00752 0 0.00001 0 0 #212.1 0.99218 0 0 0.02445 0 0 0 0.00209 #213.1 1 0 0.00001 0.00651 0 0 0 0 #214.1 0 0 0 0.00646 0 0 1 0 #215.1 0 0 0 0.01805 0 0 0 1 #216.1 0 0.00003 0.96067 0.00699 0 0.00249 0.00017 0 #217.1 0 0 0.03285 0.01769 0 0.07964 1 0 #218.1 0 0 0 0.0334 0.97487 0.00002 0.01773 0 #219.1 0.00001 0 0 0.01542 0 0 0 1 #220.1 0 0.99981 0.00004 0.00676 0 0 0 0 #221.1 0.99717 0.04298 0 0.01175 0 0 0 0 #222.1 0 0.99965 0.00007 0.00835 0 0 0 0 #223.1 0 0 0.00041 0.01526 0 0.00337 1 0 #224.1 0.99728 0 0 0.02501 0 0 0 0.0024 #225.1 0 0.09587 0.97413 0.00743 0 0 0 0 #226.1 0 1 0 0.00893 0 0 0 0 #227.1 1 0 0 0.04591 0 0 0 0 #228.1 0 1 0.00004 0.00844 0 0.00003 0 0 #229.1 0.08499 0 0 0.02329 0 0 0 0.98853 #230.1 0.00105 0.99993 0 0.00589 0 0 0 0 #231.1 0 1 0 0.00742 0 0 0 0 #232.1 0 1 0 0.00883 0 0 0 0 #233.1 0 0 0 0.05279 0 0.00001 0 1 #234.1 0 0.00042 0.99994 0.00844 0 0 0 0 #235.1 0 0.09547 0 0.02903 0 0.00001 0.00009 0.99952 #236.1 0 0 1 0.00569 0 0.00135 0.00002 0 #237.1 0 0.00011 1 0.00896 0 0.00002 0 0 #238.1 0 0 0.00174 0.00909 0.09431 0.91368 1 0 #239.1 0.99988 0.01013 0 0.00877 0 0 0 0 #240.1 0 0.01598 0.99946 0.00929 0 0 0 0 #241.1 0 1 0 0.00802 0 0 0 0 #242.1 1 0 0 0.03285 0 0 0 0 #243.1 0 0 0 0.01842 0 0 0 1 #244.1 0 0 0 0.01793 0 0 0 1 #245.1

153

0 0.00005 0.99974 0.01034 0 0 0 0 #246.1 0.99999 0 0 0.03171 0 0 0 0 #247.1 0 0.99998 0.00029 0.01104 0 0.00003 0 0 #248.1 1 0.00011 0 0.01208 0 0 0 0 #249.1 0 1 0 0.01559 0 0.00001 0 0 #250.1 1 0 0 0.04071 0 0 0 0 #251.1 0.9959 0 0 0.02388 0 0 0 0.00423 #252.1 1 0 0 0.04084 0 0 0 0 #253.1 0 1 0 0.00658 0 0 0 0 #254.1 1 0 0 0.00926 0 0 0 0 #255.1 0 0.00002 0 0.02653 0 0.00001 0.00001 1 #256.1 0 0 0 0.03415 0 0.00004 0.00001 0.99999 #257.1 0 0.99997 0.00001 0.00579 0 0 0 0 #258.1 0.99992 0 0 0.02455 0 0 0 0 #259.1 0 0.99992 0.00002 0.00575 0 0 0 0 #260.1 0.00022 0 0 0.02854 0 0 0 1 #261.1 0 0 0 0.01872 0 0 0 1 #262.1 0 0 0 0.0092 0 0 1 0 #263.1 0 0.99941 0.00011 0.00892 0 0 0 0 #264.1 0 1 0 0.0111 0 0.00001 0 0 #265.1 0 0.90698 0.00028 0.00717 0 0 0 0 #266.1 0 0.99976 0.00007 0.00635 0 0 0 0 #267.1 0 1 0 0.0197 0 0 0 0 #268.1 0 0 0 0.01911 0 0 0 1 #269.1 0.00359 0 0 0.02321 0 0 0 0.99983 #270.1 0.00229 0 0.97519 0.00686 0 0 0 0 #271.1 0 0.99958 0.00029 0.00694 0 0 0 0 #272.1 0 1 0 0.00645 0 0 0 0 #273.1 0.02286 0 0.90328 0.01175 0 0 0 0 #274.1 1 0 0 0.00671 0 0 0 0 #275.1 0 1 0 0.01348 0 0 0 0 #276.1 0.00027 0.00002 0 0.0363 0 0.00038 0.00922 0.91754 #277.1 0 0 0 0.02017 0 0 0 1 #278.1 0.99778 0 0 0.02548 0 0 0 0.00054 #279.1 1 0.00001 0 0.03047 0 0 0 0 #280.1 0 0 0 0.01772 0 0 0 1 #281.1 0.95052 0 0 0.02076 0 0 0 0.09417 #282.1 0 0 0 0.01827 0 0 0 1 #283.1 1 0 0 0.05683 0 0 0 0.00151 #284.1 0 0 0.00012 0.00553 0 0.00301 1 0 #285.1 1 0.00016 0 0.01392 0 0 0 0 #286.1 0 0.00255 0 0.02714 0 0.00001 0.00051 1 #287.1 0 0.00093 0 0.08018 0 0 0 0.99971

154

#288.1 0 1 0 0.00752 0 0 0 0 #289.1 0 0 0 0.01766 0 0 0 1 #290.1 1 0 0 0.01587 0 0 0 0 #291.1 0 0.99999 0 0.01338 0 0 0 0 #292.1 0 0.00025 0 0.04869 0 0.00029 0.07489 0.91749 #293.1 0 0 0 0.01719 0 0 0 1 #294.1 0 0 0 0.01034 0 0 0.05245 0.90801 #295.1 1 0 0 0.02956 0 0 0 0 #296.1 0 0 1 0.01473 0 0 0 0 #297.1 0 0 0 0.0203 0 0 0 1 #298.1 0 0.00003 0 0.02578 0 0.00002 0.00001 1 #299.1 0.99166 0.00008 0 0.02111 0 0 0 0 #300.1 0.00569 0 0 0.0356 0 0 0 1 #301.1 0.99999 0 0 0.03164 0 0 0 0 #302.1 0.00025 0 0 0.0132 0 0 1 0 #303.1 1 0 0 0.03528 0 0 0 0 #304.1 0 0.99999 0 0.00784 0 0 0 0 #305.1 0 0 0.00095 0.01435 0 0.00336 1 0 #306.1 0 1 0 0.00834 0 0 0 0 #307.1 1 0 0 0.07935 0 0 0 0.00006 #308.1 0 0 0 0.04051 0 0.00001 0.00224 0.98346 #309.1 0 0 0 0.02118 0 0 0 1 #310.1 0 0 0 0.00717 0 0 1 0 #311.1 0 1 0 0.0095 0 0.00001 0 0 #312.1 1 0 0 0.04903 0 0 0 0 #313.1 0 0.99997 0 0.00583 0 0 0 0 #314.1 1 0 0 0.00857 0 0 0 0 #315.1 0 1 0 0.0104 0 0 0 0 #316.1 0 0 1 0.0048 0 0.00517 0.00016 0 #317.1 0 0 0 0.02369 0 0.00015 0.08509 0.92269 #318.1 0 0 0 0.01928 0 0 0 1 #319.1 0.99996 0 0 0.03053 0 0 0 0 #320.1 0 0 0 0.02399 0 0 0 1 #321.1 0 0.00258 0.99553 0.00958 0 0.00516 0.00904 0 #322.1 0 0.99998 0 0.00911 0 0 0 0.00005 #323.1 0 1 0 0.01227 0 0 0 0 #324.1 1 0 0 0.04348 0 0 0 0 #325.1 0 0 0 0.01801 0 0 0 1 #326.1 0 1 0 0.02227 0 0 0 0 #327.1 0 0.00001 0.99507 0.00541 0 0.00169 0.00011 0 #328.1 0 0 0.00027 0.01241 0 0.00131 1 0 #329.1 0 0 0.99638 0.00627 0 0.00099 0.00814 0 #330.1

155

0 0 0 0.01616 0 0 0.00001 1 #331.1 0.99999 0 0 0.02498 0 0 0 0 #332.1 1 0 0 0.01019 0 0 0 0 #333.1 1 0 0 0.04103 0 0 0 0 #334.1 0.999 0 0 0.02013 0 0 0 0.00047 #335.1 0.00006 0 0 0.03693 0 0 0 1 #336.1 0.99764 0 0.00632 0.01 0 0 0 0 #337.1 0.00001 0 0 0.02864 0.0017 0 1 0 #338.1 0 0.0009 0.99989 0.00918 0 0 0 0 #339.1 0 0 0 0.04206 0 0 0 1 #340.1 0 0.00002 0.99996 0.00974 0 0 0 0 #341.1 1 0 0 0.01377 0 0 0 0 #342.1 0 0.99999 0.00001 0.00985 0 0.00001 0 0 #343.1 1 0 0 0.00711 0 0 0 0 #344.1 1 0 0 0.04184 0 0 0 0.00007 #345.1 0 0 0 0.01634 0 0 0 1 #346.1 0 0 1 0.00385 0 0.00339 0.00003 0 #347.1 0 0 1 0.00435 0 0.02313 0 0 #348.1 0 1 0 0.01164 0 0 0 0 #349.1 0.99999 0.00038 0 0.01537 0 0 0 0 #350.1 0 0.00275 0 0.02324 0 0.00002 0.00002 0.99982 #351.1 0 0.99975 0.00006 0.0069 0 0 0 0 #352.1 0 0 0 0.02391 0.94783 0 0.0831 0 #353.1 1 0 0.00001 0.00823 0 0 0 0 #354.1 0.00066 0 0 0.06666 0 0.00005 0 0.99999 #355.1 0 0.00044 0 0.02613 0 0.00001 0.00038 0.99999 #356.1 0.99997 0 0 0.03095 0 0 0 0 #357.1 0 0 0.00112 0.01734 0 0.00636 1 0 #358.1 0 1 0 0.02897 0 0.00002 0 0.00001 #359.1 0 0 0.99998 0.00478 0 0.00288 0.00006 0 #360.1 0 0 0 0.00687 0 0 1 0 #361.1 0 1 0 0.00702 0 0 0 0 #362.1 0 0 0 0.00836 0 0 1 0 #363.1 0 0 0.99999 0.00317 0 0.00072 0 0 #364.1 1 0 0 0.06537 0 0 0 0 #365.1 0.99996 0 0 0.02908 0 0 0 0 #366.1 0 0.99999 0 0.00509 0 0 0 0 #367.1 0 0.00053 0 0.05332 0 0.00014 0 0.9992 #368.1 0 1 0 0.00547 0 0 0 0 #369.1 0 0.00013 0 0.02514 0 0.00002 0.00036 0.99999 #370.1 0 0.99999 0 0.00938 0 0 0 0 #371.1 0 1 0 0.00735 0 0 0 0 #372.1 0 0 0 0.02336 0 0.00001 0.93238 0.0807

156

#373.1 0 0 0 0.01955 0 0.00001 0.93436 0.06751 #374.1 0 0 0 0.02245 0 0.00001 0.00023 1 #375.1 0 0 1 0.00679 0 0.00009 0 0 #376.1 0 0 0 0.01159 0 0 1 0 #377.1 0.99997 0.00023 0 0.00948 0 0 0 0 #378.1 0 1 0 0.0064 0 0 0 0 #379.1 1 0 0 0.04688 0 0 0 0 #380.1 0 0.00009 0 0.02552 0 0.00002 0.00017 0.99999 #381.1 1 0 0 0.04514 0 0 0 0.00004 #382.1 0 0 0 0.03581 0.0511 0.00053 0.91545 0 #383.1 0 1 0 0.00704 0 0 0 0 #384.1 0 0 0 0.01932 0 0 0 1 #385.1 0.00388 0 0 0.02602 0 0 0.99997 0 #386.1 0 0.99659 0.00126 0.00808 0 0 0 0 #387.1 0 0 0.99999 0.01611 0.00152 0 0 0 #388.1 0 1 0 0.01243 0 0 0 0 #389.1 0 0 0.081 0.02592 0 0.03297 1 0 #390.1 0 0.00055 0.99994 0.00813 0 0 0 0 #391.1 0 1 0 0.00775 0 0 0 0 #392.1 0 1 0 0.00865 0 0 0 0 #393.1 0 0 0 0.01406 0 0 0.00002 1 #394.1 1 0 0 0.01052 0 0 0 0 #395.1 0 0 0 0.02328 0 0 0 1 #396.1 0 0 0 0.00742 0 0 1 0 #397.1 0 1 0 0.00913 0 0.00001 0 0 #398.1 0.99999 0 0 0.09005 0 0 0 0.00008 #399.1 0 0 0 0.0339 0 0.00002 0.08669 0.91391 #400.1 0 0 0 0.01846 0 0 0.06841 0.91159 #401.1 0 1 0 0.01555 0 0.00001 0 0 #402.1 0 1 0 0.00617 0 0 0 0 #403.1 0.99999 0 0 0.05108 0 0 0 0.0721 #404.1 0 0.0024 0 0.02735 0 0.00001 0.00054 1 #405.1 0 0 0 0.0213 0 0.00007 0.06936 0.9818 #406.1 0.99909 0 0 0.02066 0 0 0.00188 0 #407.1 0 0.90087 0.00624 0.00636 0 0.00003 0 0 #408.1 0 0.00048 0.99969 0.00879 0 0 0 0 #409.1 0.00386 0.99896 0 0.02899 0 0 0 0 #410.1 0.99997 0 0 0.03089 0 0 0 0.00001 #411.1 0.00039 0 0 0.0304 0 0 0 1 #412.1 0 0 0 0.02126 0 0 0 1 #413.1 0 0 0 0.00646 0 0 1 0 #414.1 0 0.00002 0 0.04039 0 0.00009 0.00001 1 #415.1

157

0.00002 0.00043 0 0.04095 0 0.00037 0.00066 0.9996 #416.1 0 0.00006 0.94071 0.0064 0 0.00181 0.00009 0 #417.1 1 0.00001 0 0.00996 0 0 0 0 #418.1 1 0 0 0.0731 0 0 0 0.00043 #419.1 0 0.09937 0.90086 0.00499 0 0.0001 0 0 #420.1 0 0.99996 0 0.00513 0 0 0 0 #421.1 0 1 0 0.01268 0 0 0 0 #422.1 0 0.00063 0.99983 0.007 0 0.00001 0 0 #423.1 0 1 0 0.00998 0 0.00001 0 0 #424.1 0 0 0 0.01768 0 0 0 1 #425.1 0 0.99998 0 0.00604 0 0 0 0 #426.1 0 0 0 0.02416 0 0 0.0002 0.99987 #427.1 0.9136 0 0.02784 0.00792 0 0 0 0 #428.1 0 0 0 0.02692 0 0 0 1 #429.1 0.00001 0 0 0.02723 0.00064 0 1 0 #430.1 1 0 0 0.01629 0 0 0 0 #431.1 0 0 0.99499 0.01508 0.01009 0 0 0 #432.1 0.00001 0 0 0.01436 0 0 0 1 #433.1 0.00001 0 0 0.04275 0 0 0 1 #434.1 0.99991 0 0 0.03122 0 0 0 0.00001 #435.1 0 0 0 0.01968 0 0 0 1 #436.1 0.08121 0 0 0.02718 0 0 0.93212 0 #437.1 0.00021 0 0 0.06276 0 0.00007 0.00002 0.99998 #438.1 0 0 0 0.01169 0 0 1 0 #439.1 0 0.09184 0 0.02787 0 0.00002 0 0.08828 #440.1 0 1 0 0.00676 0 0 0 0 #441.1 0.92188 0 0 0.02508 0 0 0 0.0148 #442.1 0 0.99771 0.00104 0.00766 0 0 0 0 #443.1 0.08954 0 0 0.02275 0 0 0 0.90659 #444.1 0.94553 0.09513 0 0.01886 0 0 0 0 #445.1 0 0.00001 0 0.02664 0 0.00004 0.0002 0.99996 #446.1 0 0 1 0.00426 0 0.03073 0 0 #447.1 0 0.00006 0 0.02249 0 0.00001 0.00069 0.99999 #448.1 0.99999 0 0.00013 0.01161 0 0 0 0 #449.1 1 0 0 0.00642 0 0 0 0 #450.1 0.00449 0 0 0.02895 0 0 0 1 #451.1 0 0 0.99978 0.00628 0 0.00127 0.001 0 #452.1 0.99929 0.09483 0 0.00768 0 0 0 0 #453.1 0 1 0.03003 0.00669 0 0.0004 0 0 #454.1 0.00429 0 0 0.04934 0 0 0 1 #455.1 0 0.00078 0 0.03079 0 0 0 0.91431 #456.1 0 0 0 0.01911 0 0 0 1 #457.1 0 0.99922 0.00031 0.00659 0 0 0 0

158

#458.1 0 1 0 0.00827 0 0 0 0 #459.1 0 0 0 0.02247 0 0 0 1 #460.1 0 0.00214 0 0.02791 0 0.00001 0.00055 0.99999 #461.1 0.0001 0 0 0.03695 0.08096 0 0.99999 0 #462.1 0 0 0 0.00738 0 0 1 0 #463.1 0 0 0 0.03947 0 0.00002 0.00207 0.99714 #464.1 0 0.94191 0.07917 0.01032 0 0 0 0 #465.1 0.99781 0 0 0.03236 0 0 0.00012 0 #466.1 0.99959 0 0.00026 0.0073 0 0 0 0 #467.1 0 1 0 0.00789 0 0 0 0 #468.1 0.99995 0 0 0.02455 0 0 0 0 #469.1 0 0 1 0.01049 0 0.00006 0 0 #470.1 0 0.00107 0.99196 0.00944 0 0.00938 0.00068 0 #471.1 0 0 0 0.02061 0.00003 0.00001 1 0 #472.1 1 0 0 0.03136 0 0 0 0 #473.1 1 0 0 0.01435 0 0 0 0 #474.1 0 0 0 0.03467 0 0.00362 0.9622 0.0045 #475.1 0.92106 0 0 0.01825 0 0 0.00172 0.00002 #476.1 0.00018 0 0 0.0095 0 0 0.00281 0.99378 #477.1 0 0 0 0.01797 0 0 0 1 #478.1 0.99999 0 0 0.03217 0 0 0 0 #479.1 1 0 0 0.008 0 0 0 0 #480.1 0.99946 0.00242 0 0.00492 0 0 0 0 #481.1 0 0 0 0.01525 0 0 0 1 #482.1 1 0.00047 0 0.01241 0 0 0 0 #483.1 0.00001 0 0 0.02416 0 0 0 1 #484.1 0 0 0 0.01008 0.00001 0.00001 1 0 #485.1 0.00004 0 0 0.04175 0.00007 0 0.99998 0 #486.1 1 0 0 0.04859 0 0 0 0 #487.1 0.99995 0.00016 0 0.01028 0 0 0 0 #488.1 1 0 0 0.00905 0 0 0 0 #489.1 0.00025 0 0 0.03528 0 0 0 1 #490.1 0 0.0001 0 0.02607 0 0.00002 0.00005 1 #491.1 0 0 1 0.00951 0 0.00005 0 0 #492.1 1 0 0 0.03732 0 0 0 0.00001 #493.1 0 0 0 0.02472 0 0.00108 0.96758 0.00451 #494.1 0.02376 0 0 0.0492 0.00367 0 0.92177 0 #495.1 0 0.00003 0 0.02467 0 0.00001 0.00023 0.99999 #496.1 0 0.99997 0 0.00608 0 0 0 0 #497.1 0 1 0 0.00749 0 0 0 0 #498.1 0.00011 0.99954 0 0.0046 0 0 0 0 #499.1 0 0.97506 0.07846 0.00762 0 0.00009 0 0 #500.1

159

0.00001 0 0 0.0344 0.09581 0 0.99999 0 #501.1 1 0 0 0.03362 0 0 0 0 #502.1 0 0 0 0.03158 0 0 0 1 #503.1 0 0.00003 0 0.03739 0 0.00006 0.00001 1 #504.1 0 0 0 0.0225 0 0 0 1 #505.1 0 1 0 0.01116 0 0 0 0 #506.1 0.00006 0 0 0.03278 0.00005 0 1 0 #507.1 0.0014 0 0 0.01529 0.00004 0 1 0 #508.1 0.9997 0 0 0.0438 0 0 0 0 #509.1 0 1 0 0.0075 0 0 0 0 #510.1 0 0.99804 0.00075 0.00713 0 0 0 0 #511.1 0 0.00002 1 0.00911 0 0.00002 0 0 #512.1 1 0 0 0.01124 0 0 0 0 #513.1 1 0 0 0.01605 0 0 0 0 #514.1 0 0.99471 0.00239 0.00787 0 0 0 0 #515.1 0.99996 0 0 0.02554 0 0 0 0 #516.1 0 0.00013 0 0.02725 0 0.00002 0.00005 1 #517.1 0 1 0 0.0075 0 0 0 0 #518.1 1 0 0 0.00708 0 0 0 0 #519.1 0 1 0 0.01596 0 0.00002 0 0 #520.1 0.99987 0 0 0.02408 0 0 0 0 #521.1 0 0 0 0.02249 0 0.00001 0.93472 0.07681 #522.1 0 0.99947 0 0.01376 0 0.00001 0 0.00147 #523.1 1 0 0 0.01003 0 0 0 0 #524.1 0 0.9935 0.00392 0.00799 0 0 0 0 #525.1 0 1 0.00001 0.00989 0 0.00002 0 0 #526.1 0 0.05223 0.98699 0.00868 0 0 0 0 #527.1 0 1 0 0.00777 0 0 0 0 #528.1 0 0.08785 0 0.04031 0 0.00291 0.94694 0.01159 #529.1 0 0 0 0.01857 0 0 0 1 #530.1 0 0 0 0.02459 0 0 0 1 #531.1 0 0 1 0.00346 0 0.04528 0 0 #532.1 0.99996 0 0 0.02788 0 0 0 0 #533.1 0 1 0 0.01522 0 0 0 0 #534.1 0 1 0 0.01442 0 0 0 0 #535.1 0.99992 0 0 0.0308 0 0 0 0.00001 #536.1 0.0056 0 0 0.05265 0 0 0 0.99996 #537.1 0 0 0 0.05675 0 0.00001 0 1 #538.1 0.99999 0 0 0.0262 0 0 0 0 #539.1 0.95121 0 0.07246 0.01482 0 0 0 0 #540.1 0 0.00006 0 0.02455 0 0.00002 0.00008 0.99999 #541.1 0 0 1 0.00335 0 0.09433 0.00003 0 #542.1 0 0.00237 0 0.05982 0 0.00015 0.00002 0.9995

160

#543.1 0.99919 0 0 0.07526 0 0 0 0.06832 #544.1 0 0 0 0.04546 0.00006 0.0001 1 0 #545.1 1 0 0 0.00676 0 0 0 0 #546.1 0 0 0 0.01777 0 0 0 1 #547.1 0 1 0 0.00809 0 0 0 0 #548.1 1 0 0 0.03552 0 0 0 0 #549.1 0 1 0 0.01572 0 0 0 0 #550.1 0.99999 0.00044 0 0.00562 0 0 0 0 #551.1 0 0 0 0.01246 0 0.00001 0.0691 0.9951 #552.1 0 0.99992 0.00002 0.00672 0 0 0 0 #553.1 0 0.99993 0.00002 0.00772 0 0 0 0 #554.1 0.08566 0 0 0.02949 0.00083 0 0 0 #555.1 1 0.00002 0 0.01024 0 0 0 0 #556.1 0 0 0 0.00959 0 0 1 0 #557.1 0 0.99984 0.00004 0.00656 0 0 0 0 #558.1 0 0 0.99998 0.01593 0.00015 0 0 0 #559.1 0.00002 0 0 0.00766 0 0 0.99994 0.00969 #560.1 1 0 0 0.00941 0 0 0 0 #561.1 0 1 0 0.00806 0 0 0 0 #562.1 0 1 0 0.00723 0 0 0 0 #563.1 0 1 0 0.01587 0 0.00001 0 0 #564.1 0 0 0 0.02817 0 0 0 1 #565.1 0 1 0 0.00678 0 0 0 0 #566.1 0 0 0 0.02919 0.04289 0 0.99999 0 #567.1 0.99921 0 0 0.02464 0 0 0 0.00034 #568.1 0 1 0 0.00613 0 0 0 0 #569.1 0 0 0 0.0183 0 0 0 1 #570.1 0 0 0 0.01764 0 0 0 1 #571.1 0 0.00001 1 0.00384 0 0.03079 0.04473 0 #572.1 0.99845 0 0 0.02235 0 0 0 0.00146 #573.1 1 0.00002 0 0.01184 0 0 0 0 #574.1 0 0.01826 0 0.03221 0 0.00001 0.00044 1 #575.1 0.00046 0 0 0.02882 0 0 0 0.01422 #576.1 1 0.00001 0 0.01169 0 0 0 0 #577.1 0 0.99999 0 0.00597 0 0 0 0 #578.1 0 0.00002 0 0.03431 0 0.00006 0.00001 0.99999 #579.1 0 0.97254 0.01796 0.00805 0 0 0 0 #580.1 0 0.99191 0 0.01418 0 0 0 0.01744 #581.1 0 0.00253 0 0.05282 0 0.00021 0.00005 0.99859 #582.1 1 0.00003 0 0.01286 0 0 0 0 #583.1 0 0.9982 0.00331 0.00632 0 0.00005 0 0.00003 #584.1 0.99999 0 0 0.02849 0 0 0 0 #585.1

161

0 0 0 0.01603 0 0 0 1 #586.1 1 0 0 0.07812 0 0 0 0 #587.1 0 0 0 0.01807 0 0.00103 0.99955 0.00004 #588.1 0 0 0 0.041 0.00164 0 1 0 #589.1 0 0.0022 0.99708 0.00468 0 0.0002 0.00003 0 #590.1 0 0 0 0.00952 0 0 1 0 #591.1 0 0.00012 0 0.02609 0 0.00002 0.00013 1 #592.1 1 0 0 0.04058 0 0 0 0 #593.1 0.99996 0 0.00029 0.00672 0 0 0 0 #594.1 0.00001 0 0 0.02021 0 0 0 1 #595.1 1 0 0 0.05724 0 0 0 0 #596.1 1 0 0 0.03543 0 0 0 0 #597.1 0 0 0 0.00672 0 0 1 0 #598.1 0 0 0 0.01101 0 0 0.99856 0.00129 #599.1 0 1 0.00001 0.00873 0 0.00001 0 0 #600.1 0 0 0.00117 0.01485 0 0.00202 1 0 #601.1 0 0.00012 0.9024 0.00697 0 0.00147 0.00001 0 #602.1 0.99994 0.00007 0 0.01672 0 0 0 0 #603.1 1 0 0 0.03323 0 0 0 0 #604.1 0 0.00135 0.99925 0.00916 0 0.00002 0 0 #605.1 0 0.0735 0.9115 0.00493 0 0.00034 0 0 #606.1 0.00001 0.99992 0 0.00515 0 0 0 0 #607.1 0 0.99371 0.0001 0.01059 0 0 0 0 #608.1 0.90687 0 0 0.02401 0 0 0 0 #609.1 0 0 1 0.00314 0 0.01169 0.00017 0 #610.1 0 0 0 0.00722 0 0 1 0 #611.1 0 0.96471 0.00063 0.0077 0 0.00048 0 0 #612.1 0 1 0 0.01254 0 0.00021 0 0.00001 #613.1 0.00023 0.99991 0 0.00958 0 0 0 0 #614.1 0.07548 0 0 0.06213 0 0 0 0.99529 #615.1 0 1 0 0.01353 0 0 0 0 #616.1 0 0 0 0.02739 0 0.00003 0.0001 0.99998 #617.1 0 0.00014 0 0.02363 0 0.00001 0.00044 0.99999 #618.1 0 0 0 0.03377 0 0 0 1 #619.1 0 0.99945 0.00191 0.00682 0 0.00003 0 0 #620.1 0 1 0 0.00774 0 0 0 0 #621.1 0.00002 0 0 0.04231 0.00113 0 1 0 #622.1 0.00003 0 0 0.05629 0 0.00009 0.01777 0.98283 #623.1 1 0 0 0.00628 0 0 0 0 #624.1 0 0.99999 0 0.01221 0 0 0 0.00001 #625.1 0 0.99513 0 0.01262 0 0 0 0.02394 #626.1 0 1 0 0.0254 0 0.00002 0 0 #627.1 0 0.99974 0.00006 0.00593 0 0 0 0

162

#628.1 1 0 0 0.05305 0 0 0 0.00011 #629.1 0 0 0 0.04354 0.00676 0 1 0 #630.1 0 0.00001 0 0.03246 0 0.00001 0 1 #631.1 0.00278 0.00017 0.99145 0.01565 0.001 0.00001 0 0 #632.1 1 0 0.00001 0.0126 0 0 0 0 #633.1 0 0.00008 0 0.02225 0 0.00001 0.00061 0.99999 #634.1 0.00158 0 0 0.03513 0 0 0 1 #635.1 0.99906 0 0 0.02693 0 0 0 0.00092 #636.1 1 0 0 0.03307 0 0 0 0 #637.1 0.00009 0 0 0.01293 0 0 0 1 #638.1 0 0 0 0.00663 0 0 1 0 #639.1 0 0 0.99999 0.01328 0 0 0 0 #640.1 0 0 0 0.01855 0 0.00002 0.00178 0.99973 #641.1 1 0 0 0.04648 0 0 0 0 #642.1 0 0 0.99994 0.00308 0 0.0003 0 0 #643.1 0.08323 0 0 0.02966 0 0 0.9461 0 #644.1 0 0 0 0.02628 0 0 0 1 #645.1 1 0 0 0.00793 0 0 0 0 #646.1 0 0 0.99325 0.0169 0.09472 0.00001 0 0 #647.1 0 0 0 0.01418 0 0 0.00109 0.99998 #648.1 0 0 0 0.04396 0 0.00001 0 1 #649.1 0 0 0.00094 0.01423 0 0.00289 1 0 #650.1 0 0.00002 0 0.03212 0 0.00005 0.00002 0.99999 #651.1 0.03379 0 0 0.04731 0 0 0.92098 0 #652.1 0.00027 0 0 0.01613 0 0 0 0.99996 #653.1 1 0.00002 0 0.01233 0 0 0 0 #654.1 0 0.9111 0 0.03868 0 0 0 0 #655.1 0 0.99998 0 0.00543 0 0 0 0 #656.1 1 0 0 0.05146 0 0 0 0 #657.1 0.00001 0.99994 0 0.0074 0 0 0 0 #658.1 1 0 0 0.04162 0 0 0 0 #659.1 0 1 0 0.00781 0 0 0 0 #660.1 0 1 0 0.02228 0 0 0 0 #661.1 1 0 0 0.03491 0 0 0 0 #662.1 0 0.00001 0 0.04057 0 0.00007 0 0.99999 #663.1 0 0 0 0.0202 0 0 0 1 #664.1 0.00001 0 0 0.01188 0 0 0 0.99998 #665.1 0 0 1 0.00313 0 0.00499 0.00007 0 #666.1 0 0.00001 0.9999 0.00564 0 0.00201 0.0001 0 #667.1 0 0 0.00123 0.01484 0 0.00246 1 0 #668.1 0 0 1 0.01422 0.00001 0 0 0 #669.1 0 0.99944 0.00004 0.00504 0 0.00001 0 0 #670.1

163

0.99979 0 0 0.02561 0 0 0 0 #671.1 0 1 0 0.01565 0 0 0 0 #672.1 0 0 0 0.02461 0 0 0 1 #673.1 0 0.00001 0 0.04444 0 0.00011 0.00001 0.99999 #674.1 1 0 0 0.03112 0 0 0 0.00001 #675.1 0.92277 0 0 0.04018 0.00001 0 0.07514 0 #676.1 0 1 0 0.0089 0 0 0 0 #677.1 0.00595 0 0.97304 0.01531 0 0 0 0 #678.1 0 0 0.09003 0.02579 0 0.03792 1 0 #679.1 0.00003 0 0 0.03311 0 0 0 1 #680.1 0.00044 0 0 0.03259 0 0 0 1 #681.1 0.00013 0 0 0.02891 0 0 0 1 #682.1 0 0 0 0.01812 0 0 0 1 #683.1 0 1 0 0.00626 0 0 0 0 #684.1 0 0.99987 0.00003 0.00582 0 0 0 0 #685.1 0 0 0 0.01731 0 0 0 1 #686.1 0.99993 0 0 0.02985 0 0 0 0.00001 #687.1 0 1 0 0.00818 0 0 0 0 #688.1 0 0 0.08987 0.01689 0.90681 0.00002 0 0 #689.1 1 0.00023 0 0.0119 0 0 0 0 #690.1 0 0 1 0.01506 0 0 0 0 #691.1 1 0.00002 0 0.01468 0 0 0 0 #692.1 0 0 0 0.01447 0.00004 0 1 0 #693.1 0 1 0 0.02534 0 0 0 0 #694.1 0 0 0.00539 0.02267 0 0.03875 1 0 #695.1 1 0.00004 0 0.01306 0 0 0 0 #696.1 1 0 0 0.00628 0 0 0 0 #697.1 0.99984 0 0 0.02557 0 0 0 0 #698.1 0 1 0 0.00799 0 0 0 0 #699.1 0 0.00064 0 0.0234 0 0.00001 0.00005 0.99996 #700.1 0 0 0 0.02765 0.99914 0.00003 0 0 #701.1 0 0 0 0.0273 0.99946 0.00003 0 0 #702.1 0 0 0 0.02678 0.99961 0.00003 0 0 #703.1 0 0 0 0.02609 0.99968 0.00004 0 0 #704.1 0 0 0 0.02819 0.99954 0.00004 0 0 #705.1 0 0 0 0.02527 0.99972 0.00004 0 0 #706.1 0 0 0 0.02663 0.99935 0.00003 0 0 #707.1 0 0 0 0.02569 0.99962 0.00004 0 0 #708.1 0 0 0 0.02146 0.99951 0.00003 0 0 #709.1 0 0 0 0.02906 0.99927 0.00004 0 0 #710.1 0 0 0 0.02431 0.9995 0.00003 0 0 #711.1 0 0 0 0.02799 0.99924 0.00004 0 0 #712.1 1 0 0 0.02226 0 0 0 0

164

#713.1 0.99931 0 0 0.02175 0 0 0.00199 0 #714.1 0.99994 0 0 0.02623 0 0 0 0 #715.1 0 0.9982 0.00068 0.00658 0 0 0 0 #716.1 0 0.99916 0.00027 0.0066 0 0 0 0 #717.1 0 0 0.09444 0.02432 0 0.02249 1 0 #718.1 0 0.00013 0 0.02694 0 0.00002 0.00006 1 #719.1 1 0 0 0.01639 0 0 0 0 #720.1 0 0.00003 0.00753 0.0176 0 0.00192 0.95301 0 #721.1 0 0.00022 0 0.02406 0 0.00001 0.00018 0.99998 #722.1 0.99998 0 0.00009 0.01421 0 0 0 0 #723.1 1 0 0 0.00527 0 0 0 0 #724.1 0 0.00001 0 0.02536 0 0 0.00002 0.99998 #725.1 1 0 0.00001 0.01004 0 0 0 0 #726.1 0 0.00005 0 0.03277 0 0.00002 0 1 #727.1 0 0 0 0.01129 0 0.05994 1 0 #728.1 0 0 1 0.00445 0 0.00321 0.00007 0 #729.1 0.99999 0 0 0.03528 0 0 0 0 #730.1 0 1 0 0.0084 0 0.00001 0 0 #731.1 0 0 0.90107 0.00778 0 0 0 0 #732.1 0 1 0 0.01437 0 0 0 0 #733.1 0 0 0 0.02559 0 0 0.99971 0 #734.1 1 0 0 0.06691 0 0 0 0.00001 #735.1 1 0 0 0.04524 0 0 0 0 #736.1 0.91011 0 0 0.06721 0.00001 0.00004 0.03095 0.00075 #737.1 0.00029 0.99356 0 0.01082 0 0 0 0 #738.1 0 0 0 0.05496 0 0.00002 0 0.99996 #739.1 0 0 0 0.03543 0.00001 0.0005 1 0.00001 #740.1 0 0 0 0.01817 0 0 0 1 #741.1 0 1 0 0.0086 0 0 0 0 #742.1 0 0.00002 0 0.01675 0 0 0.00262 0.99998 #743.1 0.90165 0 0 0.02668 0 0 0.036 0 #744.1 0 0 0 0.03361 0 0 0 1 #745.1 0 0.00001 0 0.02205 0 0.00002 0.0012 0.99993 #746.1 0 0.00367 0 0.02589 0 0.00001 0.00026 0.99993 #747.1 0 0.00108 0 0.02503 0 0 0 0.08482 #748.1 0.00021 0 0 0.01064 0 0 0 0.99998 #749.1 0 0 0.00784 0.01601 0 0.00408 0.99943 0 #750.1 1 0 0 0.03505 0 0 0 0 #751.1 1 0 0 0.00784 0 0 0 0 #752.1 0 1 0 0.01063 0 0 0 0 #753.1 0 0 0 0.014 0 0.00002 0.9518 0.94201 #754.1 0.05418 0 0 0.02181 0 0 0 0.97285 #755.1

165

0 1 0 0.00503 0 0 0 0 #756.1 0 0 0 0.01519 0 0 0.00007 1 #757.1 1 0 0 0.01481 0 0 0 0 #758.1 0.99997 0 0 0.02385 0 0 0 0 #759.1 0.08539 0 0 0.01803 0 0 0 0.97028 #760.1 0 0.99997 0 0.00726 0 0 0 0 #761.1 0 0.99999 0 0.00815 0 0 0 0.00001 #762.1 0 0 0 0.0179 0 0 0.00002 1 #763.1 0 1 0 0.01006 0 0 0 0 #764.1 0 0 0 0.01484 0.00002 0 1 0 #765.1 0.00001 0 0 0.01702 0 0 0 1 #766.1 0.00002 0 0 0.03088 0 0 0 1 #767.1 1 0.00001 0 0.01415 0 0 0 0 #768.1 0 0.95952 0.05887 0.01055 0 0.0001 0 0 #769.1 0.99998 0 0 0.08019 0.00001 0.00002 0.0014 0.00001 #770.1 0 0.00007 0 0.02683 0 0.00002 0.00002 1 #771.1 0.99976 0 0 0.0283 0 0 0 0.00014 #772.1 0.99998 0.00141 0 0.01243 0 0 0 0 #773.1 0.99993 0 0 0.02374 0 0 0 0 #774.1 0 0 0.99973 0.01164 0.00167 0 0 0 #775.1 1 0 0 0.00831 0 0 0 0 #776.1 0 0 0 0.02064 0 0.00057 0.99996 0.00008 #777.1 0 0 0.99998 0.00328 0 0.00105 0 0 #778.1 0.00001 0 0 0.0296 0 0 0 1 #779.1 0 0.09251 0 0.01853 0 0.00001 0 0.98314 #780.1 1 0 0 0.09356 0 0 0 0.00001 #781.1 0 0.00039 0 0.02282 0 0.00001 0.00105 0.99999 #782.1 0 0 0 0.0174 0 0 0 1 #783.1 1 0 0 0.00841 0 0 0 0 #784.1 0.99994 0 0.00009 0.01574 0 0 0 0 #785.1 0 1 0 0.00675 0 0 0 0 #786.1 1 0 0 0.00546 0 0 0 0 #787.1 1 0 0.00002 0.01051 0 0 0 0 #788.1 1 0 0 0.00571 0 0 0 0 #789.1 0 0.03575 0 0.0235 0 0.00002 0 0.99899 #790.1 0.00011 0 0 0.02168 0 0 0 0.99999 #791.1 0 0.00415 0 0.02999 0 0.00001 0.00026 1 #792.1 1 0 0 0.04776 0 0 0 0 #793.1 1 0 0 0.05105 0 0 0 0 #794.1 0 1 0 0.0091 0 0 0 0 #795.1 0 1 0 0.01397 0 0 0 0 #796.1 1 0 0 0.00563 0 0 0 0 #797.1 0 0.00444 0.99607 0.00739 0 0.00143 0.00164 0

166

#798.1 0.99999 0 0 0.0253 0 0 0 0 #799.1 0.99981 0 0 0.02522 0 0 0 0 #800.1 0.01472 0 0.90511 0.00769 0 0 0 0 #801.1 0.09927 0 0 0.0266 0 0 0 0.99471 #802.1 0 0 0 0.01807 0 0 0 1 #803.1 0 1 0 0.01319 0 0 0 0 #804.1 0 0 0.00376 0.00657 0 0.00056 1 0 #805.1 0 0 0 0.02165 0 0 0 1 #806.1 0 0 1 0.00413 0 0.00263 0 0 #807.1 0.99943 0 0 0.02592 0 0 0 0.00008 #808.1 0.99929 0 0 0.03084 0 0 0.00084 0 #809.1 0 1 0 0.00685 0 0 0 0 #810.1 0 0.9819 0 0.01868 0 0.00003 0 0.00205 #811.1 1 0 0 0.00729 0 0 0 0 #812.1 1 0 0 0.01749 0 0 0 0 #813.1 0 0.05595 0 0.0239 0 0.00011 0 0.02326 #814.1 0 1 0 0.008 0 0 0 0 #815.1 0 0 0 0.02039 0 0 0 1 #816.1 1 0 0 0.05191 0 0 0 0 #817.1 1 0 0 0.0323 0 0 0 0 #818.1 0.99996 0 0 0.03091 0 0 0 0 #819.1 0 0 0 0.03116 0 0 0 1 #820.1 0 0 0 0.00433 0 0.00074 1 0 #821.1 0 0.00013 0 0.02748 0 0.00002 0.00004 1 #822.1 1 0 0 0.03877 0 0 0 0 #823.1 0 0 0 0.01485 0.00004 0.00001 1 0 #824.1 0.99993 0 0 0.08703 0 0 0 0.00038 #825.1 1 0.00001 0 0.00731 0 0 0 0 #826.1 0 0 0 0.02063 0 0.00029 0.91142 0.06933 #827.1 0.99955 0 0 0.02502 0 0 0 0.0001 #828.1 0 0 0 0.02332 0 0.00098 0.99993 0 #829.1 1 0 0 0.01471 0 0 0 0 #830.1 0.00001 0.99999 0 0.00481 0 0 0 0 #831.1 0 0 0 0.01899 0 0 0 1 #832.1 0 0.00011 0 0.02707 0 0.00002 0.00003 1 #833.1 0 0.99998 0 0.00729 0 0 0 0 #834.1 0.00001 0 0.99975 0.01356 0 0 0 0 #835.1 0 0.0001 0 0.02494 0 0.00002 0.00036 0.99999 #836.1 0.00778 0 0 0.03894 0 0 0 1 #837.1 1 0 0 0.04581 0 0 0 0 #838.1 0.00002 0 0 0.06186 0 0.00001 0 1 #839.1 1 0 0 0.01327 0 0 0 0 #840.1

167

0 0 0 0.01506 0 0 0.00018 1 #841.1 0 0.99999 0.0001 0.00931 0 0.00002 0 0 #842.1 0.0001 0 0 0.05783 0 0 0 1 #843.1 1 0.00003 0 0.01194 0 0 0 0 #844.1 0.0013 0 0 0.00865 0 0 0.00701 0.98549 #845.1 0.00001 0.97872 0.00001 0.01051 0 0 0 0 #846.1 0 0 0 0.01876 0 0 0 1 #847.1 0 0.99997 0.00001 0.00563 0 0 0 0 #848.1 0 1 0 0.02597 0 0 0 0 #849.1 0.0002 0 0 0.02854 0.00006 0 1 0 #850.1 1 0 0 0.05184 0 0 0 0.00001 #851.1 0 0 0 0.02058 0.00008 0.00002 1 0 #852.1 0 1 0 0.00996 0 0 0 0 #853.1 1 0.00001 0 0.007 0 0 0 0 #854.1 0.00002 0 0 0.01596 0 0 0 1 #855.1 0 0.99999 0 0.00603 0 0 0 0 #856.1 0 1 0 0.00626 0 0 0 0 #857.1 0 0 1 0.00368 0 0.00469 0.00001 0 #858.1 0 0.00267 0.99861 0.00817 0 0.00257 0.01818 0 #859.1 0 0.99999 0 0.00793 0 0 0 0 #860.1 0 0.99998 0.00001 0.00613 0 0 0 0 #861.1 0.00001 0 0 0.03261 0.00013 0 1 0 #862.1 1 0 0 0.02272 0 0 0 0 #863.1 0.99993 0 0 0.02715 0 0 0 0 #864.1 0 0.00177 0.91215 0.00976 0 0 0 0 #865.1 0 0.99988 0 0.01078 0 0 0 0.00071 #866.1 0 0.90185 0.09423 0.00832 0 0 0 0 #867.1 1 0 0 0.02458 0 0 0 0 #868.1 0 0 0.99924 0.01085 0 0 0 0 #869.1 1 0 0 0.00531 0 0 0 0 #870.1 1 0 0.00002 0.00863 0 0 0 0 #871.1 0 1 0 0.00963 0 0 0 0 #872.1 0.99981 0 0 0.02256 0 0 0 0.00006 #873.1 0 0 1 0.00326 0 0.0051 0.00009 0 #874.1 0 0.00002 0 0.01978 0 0 0.00116 0.99999 #875.1 0.00003 0 0 0.0414 0 0 0 1 #876.1 0.00063 0 0 0.00765 0 0 0.92131 0.09061 #877.1 1 0 0 0.00789 0 0 0 0 #878.1 0 0 0 0.01701 0 0 0 1 #879.1 0 0.00103 0 0.02457 0 0 0 0.08304 #880.1 0 0 0.00019 0.01345 0 0.00043 0.90789 0 #881.1 0 0.99656 0 0.01321 0 0 0 0.01036 #882.1 0 1 0 0.00727 0 0 0 0

168

#883.1 0 1 0 0.00636 0 0 0 0 #884.1 0.00035 0.99884 0 0.00987 0 0 0 0 #885.1 0 1 0 0.01599 0 0 0 0 #886.1 0.00002 0.99854 0.08871 0.01197 0 0.00001 0 0 #887.1 1 0.00001 0 0.01279 0 0 0 0 #888.1 0 0.0003 0 0.02505 0 0.00002 0.00017 0.99999 #889.1 0.99991 0 0 0.02555 0 0 0 0 #890.1 0.99982 0 0 0.022 0 0 0.00005 0 #891.1 0 0 0.0008 0.00756 0 0.00065 1 0 #892.1 0 0.01853 0.99663 0.00746 0 0 0 0 #893.1 0.98202 0 0 0.02413 0 0 0 0.00289 #894.1 1 0 0 0.00667 0 0 0 0 #895.1 0 1 0 0.01287 0 0.00003 0 0 #896.1 1 0 0 0.00766 0 0 0 0 #897.1 0 0.93958 0.09029 0.00707 0 0.00012 0 0 #898.1 0 0 0.99991 0.01638 0.01153 0.00001 0 0 #899.1 0 0 0 0.01142 0 0 1 0 #900.1 0 1 0 0.02061 0 0 0 0 #901.1 0.09095 0.9077 0 0.00796 0 0 0 0 #902.1 0 0.00306 0 0.01908 0 0 0 0.0616 #903.1 0.99954 0.00771 0 0.023 0 0 0 0 #904.1 0 0 0 0.01182 0 0 1 0 #905.1 0 0 0 0.0308 0 0.0003 0.90852 0.09324 #906.1 0.09444 0 0 0.0271 0 0 0.9242 0 #907.1 0 1 0 0.00884 0 0 0 0 #908.1 0 0 0 0.01781 0 0 0.00004 1 #909.1 1 0 0 0.03869 0 0 0 0 #910.1 0.99994 0 0.00021 0.01466 0 0 0 0 #911.1 0 0.99824 0.00073 0.00669 0 0 0 0

169

J CÓDIGO FONTE DO APLICATIVO VALIDADOR DA RNA

A seguir é apresentado o código fonte do aplicativo validador de redes neurais , o aplicativo

contem o código fonte da RNA GSC200901-B gerado pelo aplicativo snns2c.exe.

/********************************************************* RNA.c -------------------------------------------------------- generated at Tue Jun 16 23:40:05 2009 by snns2c ( Bernward Kett 1995 ) *********************************************************/ #include <math.h> #include <stdio.h> #define Act_Logistic(sum, bias) ( (sum+bias<10000.0) ? ( 1.0/(1.0 + exp(-sum-bias) ) ) : 0.0 ) #define Act_Identity(sum, bias) ( sum ) #ifndef NULL #define NULL (void *)0 #endif typedef struct UT { float act; /* Activation */ float Bias; /* Bias of the Unit */ int NoOfSources; /* Number of predecessor units */ struct UT **sources; /* predecessor units */ float *weights; /* weights from predecessor units */ } UnitType, *pUnit; /* Forward Declaration for all unit types */ static UnitType Units[29]; /* Sources definition section */ static pUnit Sources[] = { Units + 1, Units + 2, Units + 3, Units + 1, Units + 2, Units + 3, Units + 1, Units + 2, Units + 3, Units + 1, Units + 2, Units + 3, Units + 1, Units + 2, Units + 3, Units + 1, Units + 2, Units + 3, Units + 1, Units + 2, Units + 3, Units + 1, Units + 2, Units + 3, Units + 1, Units + 2, Units + 3, Units + 1, Units + 2, Units + 3, Units + 1, Units + 2, Units + 3, Units + 1, Units + 2, Units + 3, Units + 1, Units + 2, Units + 3, Units + 1, Units + 2, Units + 3, Units + 1, Units + 2, Units + 3, Units + 1, Units + 2, Units + 3, Units + 1, Units + 2, Units + 3, Units + 4, Units + 5, Units + 6, Units + 7, Units + 8, Units + 9, Units + 10, Units + 11, Units + 12, Units + 13, Units + 14, Units + 15, Units + 16, Units + 17, Units + 18, Units + 19, Units + 20, Units + 4, Units + 5, Units + 6, Units + 7, Units + 8, Units + 9, Units + 10, Units + 11, Units + 12, Units + 13, Units + 14, Units + 15, Units + 16, Units + 17, Units + 18, Units + 19, Units + 20, Units + 4, Units + 5, Units + 6, Units + 7, Units + 8, Units + 9, Units + 10, Units + 11, Units + 12, Units + 13, Units + 14, Units + 15, Units + 16, Units + 17, Units + 18, Units + 19, Units + 20, Units + 4, Units + 5, Units + 6, Units + 7, Units + 8, Units + 9, Units + 10, Units + 11, Units + 12, Units + 13, Units + 14, Units + 15, Units + 16, Units + 17, Units + 18, Units + 19, Units + 20, Units + 4, Units + 5, Units + 6, Units + 7, Units + 8, Units + 9, Units + 10, Units + 11, Units + 12, Units + 13, Units + 14, Units + 15, Units + 16, Units + 17, Units + 18, Units + 19, Units + 20, Units + 4, Units + 5, Units + 6, Units + 7, Units + 8, Units + 9, Units + 10, Units + 11, Units + 12, Units + 13, Units + 14, Units + 15, Units + 16, Units + 17, Units + 18, Units + 19, Units + 20, Units + 4, Units + 5, Units + 6, Units + 7, Units + 8, Units + 9, Units + 10, Units + 11, Units + 12, Units + 13, Units + 14, Units + 15, Units + 16, Units + 17, Units + 18, Units + 19, Units + 20, Units + 4, Units + 5, Units + 6, Units + 7, Units + 8, Units + 9, Units + 10, Units + 11, Units + 12, Units + 13, Units + 14, Units + 15, Units + 16, Units + 17, Units + 18, Units + 19, Units + 20, };

170

/* Weigths definition section */ static float Weights[] = { -2.697980, -3.151080, -25.210899, 3.968060, 31.241920, -33.122879, 62.066269, 2.647630, -63.468349, -7.463170, -5.524840, -3.441340, 53.176048, -1.333430, -0.141320, -0.103780, 0.076290, 23.691320, -15.254840, -12.395110, -8.643120, 22.911280, -19.931400, -12.234780, 25.058550, -0.458840, -8.305130, -3.137810, 2.215350, 21.342840, 4.059160, -25.332050, 25.506620, -13.218460, -2.055080, -5.721960, 0.191940, 72.142807, -2.894430, -15.410860, -7.675940, 20.334330, 4.301910, -15.817540, -5.751450, -35.093800, 36.284241, -1.786390, 1.176160, -1.482980, 64.152657, -7.296000, -30.247690, -5.254930, 0.359240, -31.029051, 7.411190, 9.146040, 2.362280, 5.887150, 11.611230, 8.629180, 2.876830, 0.324670, -10.894670, 3.835130, -22.185930, -27.557030, -24.520960, 28.612049, 25.793060, -2.173260, -17.753000, -7.311670, 5.735980, 6.719840, -5.433370, -3.592840, 6.315320, 10.625830, -29.417950, -3.509090, -7.475300, 9.539540, -0.274550, 3.947710, -3.641910, 17.852579, 4.323410, 22.979490, 6.813470, -7.080890, -10.572310, 2.969300, -8.182690, -7.683220, -2.815800, 24.532431, 2.493870, -4.299080, -11.607320, -17.397141, -0.140040, -0.499880, -1.413580, -0.410250, 0.136820, -1.213430, -0.419550, -0.058770, -0.796160, -1.381960, -0.019040, 0.493110, -0.685200, -0.787300, -0.340630, -0.403260, 0.073780, -10.479780, -3.075770, -0.412490, -1.923050, 11.304590, -3.781010, -3.455410, -3.088600, 2.473300, -1.776250, -3.208870, 0.195500, -6.068210, -0.078550, 2.594690, -5.294650, 10.092630, -4.179970, 2.853000, -2.296600, -1.148260, 5.360080, -3.355930, -1.680750, -4.251740, 1.238880, -0.566210, -2.052700, -0.711940, 5.024230, -2.299190, 0.071920, 1.587590, 0.553900, -17.317070, 11.936430, -23.947350, 9.195400, -31.321390, -3.082180, -3.914230, -2.537760, 0.068190, 9.970860, -7.537340, -3.353370, 26.727270, 3.585490, 4.070420, -1.535530, 26.721479, 5.626100, -18.650560, -28.874969, -2.956700, 3.562850, 3.802390, 2.693810, -11.241080, 13.761910, -13.652430, -9.792960, 2.345680, -31.432980, -2.139670, -3.130600, 24.893869, -26.590019, }; /* unit definition section (see also UnitType) */ static UnitType Units[29] = { { 0.0, 0.0, 0, NULL , NULL }, { /* unit 1 (sEsq) */ 0.0, -0.997500, 0, &Sources[0] , &Weights[0] , }, { /* unit 2 (sCnt) */ 0.0, 0.127170, 0, &Sources[0] , &Weights[0] , }, { /* unit 3 (sDir) */ 0.0, -0.613390, 0, &Sources[0] , &Weights[0] , }, { /* unit 4 (oculto) */ 0.0, 24.020309, 3, &Sources[0] , &Weights[0] , }, { /* unit 5 (oculto) */ 0.0, -2.205380, 3, &Sources[3] , &Weights[3] , }, { /* unit 6 (oculto) */ 0.0, -1.550680, 3, &Sources[6] , &Weights[6] , }, { /* unit 7 (oculto) */ 0.0, 7.870630, 3, &Sources[9] , &Weights[9] ,

171

}, { /* unit 8 (oculto) */ 0.0, -47.650021, 3, &Sources[12] , &Weights[12] , }, { /* unit 9 (oculto) */ 0.0, -1.673870, 3, &Sources[15] , &Weights[15] , }, { /* unit 10 (oculto) */ 0.0, 21.430500, 3, &Sources[18] , &Weights[18] , }, { /* unit 11 (oculto) */ 0.0, 4.945720, 3, &Sources[21] , &Weights[21] , }, { /* unit 12 (oculto) */ 0.0, -12.529290, 3, &Sources[24] , &Weights[24] , }, { /* unit 13 (oculto) */ 0.0, -19.608810, 3, &Sources[27] , &Weights[27] , }, { /* unit 14 (oculto) */ 0.0, 0.073180, 3, &Sources[30] , &Weights[30] , }, { /* unit 15 (oculto) */ 0.0, 2.608470, 3, &Sources[33] , &Weights[33] , }, { /* unit 16 (oculto) */ 0.0, -64.471123, 3, &Sources[36] , &Weights[36] , }, { /* unit 17 (oculto) */ 0.0, -3.606060, 3, &Sources[39] , &Weights[39] , }, { /* unit 18 (oculto) */ 0.0, 0.695030, 3, &Sources[42] , &Weights[42] , }, { /* unit 19 (oculto) */ 0.0, 0.311930, 3, &Sources[45] , &Weights[45] , }, { /* unit 20 (oculto) */ 0.0, -58.485451, 3, &Sources[48] , &Weights[48] , }, { /* unit 21 (grau0) */ 0.0, -0.645410, 17, &Sources[51] , &Weights[51] , }, { /* unit 22 (grau30) */ 0.0, -19.726070, 17, &Sources[68] , &Weights[68] , }, { /* unit 23 (grau90) */ 0.0, -22.198441, 17, &Sources[85] , &Weights[85] , }, { /* unit 24 (grau120) */ 0.0, -0.659430, 17, &Sources[102] , &Weights[102] ,

172

}, { /* unit 25 (grau180) */ 0.0, -5.328110, 17, &Sources[119] , &Weights[119] , }, { /* unit 26 (grau220) */ 0.0, -5.299750, 17, &Sources[136] , &Weights[136] , }, { /* unit 27 (grau270) */ 0.0, -1.491560, 17, &Sources[153] , &Weights[153] , }, { /* unit 28 (grau330) */ 0.0, -3.975220, 17, &Sources[170] , &Weights[170] , } }; float separa( char strent[], char separador, int pos ) { long inicial, localseparador, achouseparador, acumulador, divisor, contador, achouponto; float resultado; inicial = 0; achouseparador = pos; acumulador = 0; divisor = 1; achouponto = 0; for( localseparador = 0; achouseparador; localseparador++) if( ( strent[ localseparador ] == separador ) | ( strent[ localseparador] == 0 ) ) { achouseparador--; if( achouseparador > 0) inicial = localseparador + 1; } for( contador = inicial; contador < localseparador - 1; contador++) { if( strent[ contador] == '.') { achouponto = 1; } else { if( achouponto ) divisor *= 10; acumulador = acumulador * 10 + strent[ contador] - '0'; } } resultado = ((float) acumulador) / ((float) divisor); return (resultado); } int main() { int i; FILE *arqe, *arqs; float ent[4]; float sai[9]; char buf[250]; if( !(arqe = fopen( "C:\\SNNSv4.2\\bin\\entrada.txt", "r" )) ){ printf( "arq n pode ser aberto!\n" ); system("PAUSE"); exit(1); } arqs = fopen( "C:\\SNNSv4.2\\bin\\saida.txt", "w" ); while( fgets(buf, 250, arqe)!=NULL ) { ent[0] = separa( buf, ' ', 1 ); ent[1] = separa( buf, ' ', 2 ); ent[2] = separa( buf, ' ', 3 ); RNA( ent,sai, 0 ); for( i = 0; i < 8; i++ ) { fprintf( arqs, "%2.0f", sai[i] ); } fprintf( arqs, "\n" ); } printf( "\n\n" );

173

system("PAUSE"); return(0); } float separa2( char strent[], char separador, int pos ) { } int RNA(float *in, float *out, int init) { int member, source; float sum; enum{OK, Error, Not_Valid}; pUnit unit; /* layer definition section (names & member units) */ static pUnit Input[3] = {Units + 1, Units + 2, Units + 3}; /* members */ static pUnit Hidden1[17] = {Units + 4, Units + 5, Units + 6, Units + 7, Units + 8, Units + 9, Units + 10, Units + 11, Units + 12, Units + 13, Units + 14, Units + 15, Units + 16, Units + 17, Units + 18, Units + 19, Units + 20}; /* members */ static pUnit Output1[8] = {Units + 21, Units + 22, Units + 23, Units + 24, Units + 25, Units + 26, Units + 27, Units + 28}; /* members */ static int Output[8] = {21, 22, 23, 24, 25, 26, 27, 28}; for(member = 0; member < 3; member++) { Input[member]->act = in[member]; } for (member = 0; member < 17; member++) { unit = Hidden1[member]; sum = 0.0; for (source = 0; source < unit->NoOfSources; source++) { sum += unit->sources[source]->act * unit->weights[source]; } unit->act = Act_Logistic(sum, unit->Bias); }; for (member = 0; member < 8; member++) { unit = Output1[member]; sum = 0.0; for (source = 0; source < unit->NoOfSources; source++) { sum += unit->sources[source]->act * unit->weights[source]; } unit->act = Act_Logistic(sum, unit->Bias); }; for(member = 0; member < 8; member++) { out[member] = Units[Output[member]].act; } return(OK); }

174

K PLANILHA COM OS PADRÕES DE ENTRADA E SAÍDA

A seguir é apresentada a planilha contendo os padrões de entrada apresentados ao aplicativo validador contruído para utilizar a RNA GSC200901-B, os padrões de saída gerados pela rede e a especificação se a saída está correta ou incorreta.

Direções Graus

Esquerdo Central Direito 000 030 090 120 180 240 270 330 Resultado

0.6 0.02 0.63 1 0 0 0 0 0 0 0 Correto

0.89 0.26 0.33 1 0 0 0 0 0 0 0 Correto

0.75 0.09 0.48 1 0 0 0 0 0 0 0 Correto

0.21 0.5 0.86 0 0 0 0 0 0 0 1 Correto

0.24 0.61 0.77 0 0 0 0 0 0 0 1 Correto

0.56 0.96 0.51 0 0 1 0 0 0 0 0 Correto

0.37 0.75 0.26 0 1 0 0 0 0 0 0 Correto

0.67 0.39 0.74 1 0 0 0 0 0 0 0 Correto

0.04 0.92 0.03 0 0 0 0 0 0 0 0 Não Reconhecido

0.31 0.6 0.26 0 1 0 0 0 0 0 0 Correto

0.73 0.44 0.84 1 0 0 0 0 0 0 0 Correto

0.24 0.09 0.77 1 0 0 0 0 0 0 0 Correto

0.34 0.45 0.28 0 1 0 0 0 0 0 0 Correto

0.49 0.33 0.84 1 0 0 0 0 0 0 0 Correto

0.56 0.7 0.4 0 1 0 0 0 0 0 0 Correto

1 0.99 0.84 0 0 1 0 0 1 0 0 Errado - Duas Direções - Certo e Errado

0.26 0.95 0.59 0 0 0 0 0 0 1 0 Correto

0.84 0.31 0.56 1 0 0 0 0 0 0 0 Correto

0.32 0.79 0.55 0 0 0 0 0 0 0 1 Correto

0.11 0.01 0.98 0 0 0 0 0 0 1 0 Correto

0.07 0.36 0.12 0 0 0 0 0 0 0 1 Correto

0.92 0.54 0.5 0 0 1 0 0 0 0 0 Correto

0.66 0.43 0.57 1 0 0 0 0 0 0 0 Correto

0.34 0.13 0.26 1 0 0 0 0 0 0 0 Correto

0.9 0.77 0.77 0 1 0 0 0 0 0 0 Errado - Direção Errada

0.17 0.22 0.3 0 0 0 0 0 0 0 1 Correto

0.68 0.74 0.59 0 1 0 0 0 0 0 0 Correto

0.93 0.9 0.81 0 1 1 0 0 0 0 0 Errado - Duas Direções - Angulo Menor

0.67 0.67 0.02 0 1 0 0 0 0 0 0 Correto

0.17 0.35 0.41 0 0 0 0 0 0 0 1 Correto

0.49 0.72 0.04 0 1 0 0 0 0 0 0 Correto

0.9 0.06 0.55 1 0 0 0 0 0 0 0 Correto

0.79 0.8 0.35 0 1 0 0 0 0 0 0 Correto

0.51 0.88 0.09 0 1 0 0 0 0 0 0 Correto

0.19 0.41 0.15 0 1 0 0 0 0 0 0 Correto

0.51 0.56 0.51 0 0 0 0 0 0 0 0 Não Reconhecido

0.85 0.55 0.01 0 1 0 0 0 0 0 0 Correto

0.41 0.94 0.38 0 0 1 0 0 0 0 0 Correto

0.46 0.11 0.47 1 0 0 0 0 0 0 0 Correto

0.45 0.04 0.65 1 0 0 0 0 0 0 0 Correto

0.03 0.44 0.61 0 0 0 0 0 0 0 1 Correto

175

0.85 0.91 0.21 0 0 1 0 0 0 0 0 Correto

0.62 0.21 0.2 1 1 0 0 0 0 0 0 Errado - Duas Direções - Certo e Errado

0.22 0.66 0.6 0 0 0 0 0 0 0 1 Correto

0.69 0.83 0.12 0 1 0 0 0 0 0 0 Correto

0.72 0.32 0.79 1 0 0 0 0 0 0 0 Correto

0.52 0.48 0.55 1 0 0 0 0 0 0 0 Correto

0.83 0.1 0.07 0 1 0 0 0 0 0 0 Correto

0.09 0.33 0.84 0 0 0 0 0 0 0 1 Correto

0.25 0.54 0.28 0 0 0 0 0 0 0 1 Correto

0.46 0.56 0.01 0 1 0 0 0 0 0 0 Correto

0.07 0.49 0.49 0 0 0 0 0 0 0 1 Correto

0.97 0.51 0.44 0 0 1 0 0 0 0 0 Correto

0.81 0.29 0.21 0 1 0 0 0 0 0 0 Correto

0.65 0.55 0.35 0 1 0 0 0 0 0 0 Correto

0.59 0.21 0.66 1 0 0 0 0 0 0 0 Correto

0.53 0.9 0.58 0 0 0 0 0 0 0 1 Correto

0.89 0.71 0.76 1 0 0 0 0 0 0 0 Correto

0.58 0.81 0.24 0 1 0 0 0 0 0 0 Correto

0.8 0.29 0.4 1 0 0 0 0 0 0 0 Correto

0.26 0.23 0.4 1 0 0 0 0 0 0 0 Correto

0.69 0.02 0.35 1 0 0 0 0 0 0 0 Correto

0.85 0.04 0.98 0 0 0 0 0 0 1 0 Correto

0.57 0.07 0.71 1 0 0 0 0 0 0 0 Correto

0.15 0.91 0.05 0 1 1 0 0 0 0 0 Errado - Duas Direções - Ângulo Menor

0.21 0.93 0.69 0 0 0 0 0 0 1 0 Correto

0.71 0.51 0.41 0 1 0 0 0 0 0 0 Correto

0.22 0.46 0.21 0 1 0 0 0 0 0 0 Correto

0.82 0.55 0.68 1 0 0 0 0 0 0 0 Correto

0.37 0.65 0.02 0 1 0 0 0 0 0 0 Correto

0.71 0.47 0.02 0 1 0 0 0 0 0 0 Correto

0.42 0.29 0.72 1 0 0 0 0 0 0 0 Correto

0.71 0.61 0.8 1 0 0 0 0 0 0 0 Correto

0.22 0.65 0.39 0 0 0 0 0 0 0 1 Correto

0.31 0.06 0.85 1 0 0 0 0 0 0 0 Correto

0.48 0.36 0.85 1 0 0 0 0 0 0 0 Correto

0.41 0.05 0.84 1 0 0 0 0 0 0 0 Correto

0.41 0.79 0.39 0 1 0 0 0 0 0 0 Correto

0.42 0.1 0.05 0 1 0 0 0 0 0 0 Correto

0.21 0.39 0.05 0 1 0 0 0 0 0 0 Correto

0.54 0.18 0.5 1 0 0 0 0 0 0 0 Correto

0.7 0.22 0.66 1 0 0 0 0 0 0 0 Correto

0.1 0.56 0.23 0 0 0 0 0 0 0 1 Correto

0.04 0.42 0.2 0 0 0 0 0 0 0 1 Correto

0.14 0.04 0.67 1 0 0 0 0 0 0 0 Correto

0.05 0.93 0.22 0 0 0 0 0 0 1 0 Correto

0.42 0 0.21 1 0 0 0 0 0 0 0 Correto

0.6 0.14 0.26 1 0 0 0 0 0 0 0 Correto

0.34 0.16 0.93 0 0 0 0 0 0 1 0 Correto

0.72 0.39 0.38 1 1 0 0 0 0 0 0 Errado - Duas Direções - Certo e Errado

0.66 0.37 0.01 0 1 0 0 0 0 0 0 Correto

0.1 0.25 0.14 0 0 0 0 0 0 0 1 Correto

176

0.71 1 0.02 0 0 1 0 0 0 0 0 Correto

0.72 0.55 0.29 0 1 0 0 0 0 0 0 Correto

0.41 0.93 0.69 0 0 0 0 0 0 1 0 Correto

0.74 0.2 0.31 1 0 0 0 0 0 0 0 Correto

0.89 0.36 0.5 1 0 0 0 0 0 0 0 Correto

0.18 0.71 0.51 0 0 0 0 0 0 0 1 Correto

0.51 0.83 0.52 0 0 0 0 0 0 0 1 Correto

0.47 0.14 0.74 1 0 0 0 0 0 0 0 Correto

0.46 0.25 0.51 1 0 0 0 0 0 0 0 Correto

0.61 0.88 0.61 0 0 0 0 0 0 0 0 Não Reconhecido

0.28 0.45 0.49 0 0 0 0 0 0 0 1 Correto

0.59 0.39 0.24 0 1 0 0 0 0 0 0 Correto

0.65 0.25 0.58 1 0 0 0 0 0 0 0 Correto

0.29 0.22 0.3 1 0 0 0 0 0 0 0 Correto

0.88 0.09 0.84 1 0 0 0 0 0 0 0 Correto

0.69 0.66 0.33 0 1 0 0 0 0 0 0 Correto

0.89 0.97 0.02 0 0 1 0 0 0 0 0 Correto

0.43 0.77 0.25 0 1 0 0 0 0 0 0 Correto

0.53 0.16 0.41 1 0 0 0 0 0 0 0 Correto

0.98 0.61 0.45 0 0 1 0 0 0 0 0 Correto

0.85 0.62 0.66 1 0 0 0 0 0 0 0 Correto

0.35 0.27 0.76 1 0 0 0 0 0 0 0 Correto

0.43 0.91 0.19 0 0 1 0 0 0 0 0 Correto

0.78 0.15 0.27 1 0 0 0 0 0 0 0 Correto

0.1 0.91 0.05 0 1 1 0 0 0 0 0 Errado - Duas Direções - Angulo Menor

0.76 0.23 0.82 1 0 0 0 0 0 0 0 Correto

0.25 0.34 0.73 0 0 0 0 0 0 0 1 Correto

0.58 0.39 0.18 0 1 0 0 0 0 0 0 Correto

0.51 0.83 0.2 0 1 0 0 0 0 0 0 Correto

0.03 0.12 0.81 0 0 0 0 0 0 0 1 Correto

0.62 0.29 0.93 0 0 0 0 0 0 1 0 Correto

0.36 0.64 0.21 0 1 0 0 0 0 0 0 Correto

0.46 0.43 0.37 0 1 0 0 0 0 0 0 Correto

0.62 0.15 0.6 1 0 0 0 0 0 0 0 Correto

0.82 0.69 0.57 0 1 0 0 0 0 0 0 Correto

0.61 0.36 0.72 1 0 0 0 0 0 0 0 Correto

0.58 0.71 0.07 0 1 0 0 0 0 0 0 Correto

0.6 0.8 0.7 0 0 0 0 0 0 0 1 Correto

0.64 0.6 0.53 0 1 0 0 0 0 0 0 Correto

0.39 0.19 0.57 1 0 0 0 0 0 0 0 Correto

0.89 0.58 0.04 0 1 0 0 0 0 0 0 Correto

0.54 0.58 0.73 0 0 0 0 0 0 0 1 Correto

0.58 0.49 0.1 0 1 0 0 0 0 0 0 Correto

0.13 0.35 0.64 0 0 0 0 0 0 0 1 Correto

0.02 0.18 0.06 0 1 0 0 0 0 0 1 Errado - Duas Direções Opostas

0.94 0.31 0.56 0 0 1 0 0 0 0 0 Correto

0.76 0.26 0.74 1 0 0 0 0 0 0 0 Correto

0.97 0.75 0.58 0 0 1 0 0 0 0 0 Correto

0.12 0.38 0.47 0 0 0 0 0 0 0 1 Correto

0.08 0.03 0.69 1 0 0 0 0 0 0 0 Correto

0.85 0.4 0.27 0 1 0 0 0 0 0 0 Correto

177

0.2 0.3 0.58 0 0 0 0 0 0 0 1 Correto

0.18 0.6 0.51 0 0 0 0 0 0 0 1 Correto

0.64 0.94 0.81 0 0 0 0 0 0 1 0 Correto

0.03 0.99 0.15 0 0 0 0 0 0 1 0 Correto

0.07 0.34 0.76 0 0 0 0 0 0 0 1 Correto

0.12 0.41 0.64 0 0 0 0 0 0 0 1 Correto

0.96 0.18 0.7 0 0 1 0 0 0 0 0 Correto

0.31 0.16 0.34 1 0 0 0 0 0 0 0 Correto

0.88 0.22 0.48 1 0 0 0 0 0 0 0 Correto

0.56 0.59 0.92 0 0 0 0 0 0 1 0 Correto

0.29 0.81 0.3 0 1 0 0 0 0 0 1 Errado - Duas Direções Opostas

0.43 0.77 0.88 0 0 0 0 0 0 0 1 Correto

0.49 0.36 0.52 1 0 0 0 0 0 0 0 Correto

0.64 0.65 0.94 0 0 0 0 0 0 1 0 Correto

0.22 0.07 0.67 1 0 0 0 0 0 0 0 Correto

0.7 0.09 0.87 1 0 0 0 0 0 0 0 Correto

0.04 0.54 0.56 0 0 0 0 0 0 0 1 Correto

0.84 0.09 0.2 1 0 0 0 0 0 0 0 Correto

0.29 0.96 0.69 0 0 0 0 0 0 1 0 Correto

0.42 0.6 0.06 0 1 0 0 0 0 0 0 Correto

0.22 0.22 0.05 0 1 0 0 0 0 0 0 Correto

0.91 0.73 0.02 0 1 0 0 0 0 0 0 Errado - Angulo Menor

0.72 0.06 0.82 1 0 0 0 0 0 0 0 Correto

0.68 0.75 0.04 0 1 0 0 0 0 0 0 Correto

0.5 0.55 0.5 0 0 0 0 0 0 0 0 Não Reconhecido

0.12 0.91 0.1 0 0 1 0 0 0 0 0 Correto

0.19 0.44 0.2 0 0 0 0 0 0 0 1 Correto

0.08 0.72 0.71 0 0 0 0 0 0 0 1 Correto

0.29 0.55 0.4 0 0 0 0 0 0 0 1 Correto

0.24 0.29 0.41 0 0 0 0 0 0 0 1 Correto

0.03 0.31 0.47 0 0 0 0 0 0 0 1 Correto

0.79 0.8 0.9 1 0 0 0 0 0 0 0 Correto

0.14 0.06 0.37 1 0 0 0 0 0 0 0 Correto

0.25 0.75 0.19 0 1 0 0 0 0 0 0 Correto

0.62 0.14 0.32 1 0 0 0 0 0 0 0 Correto

0.88 0.22 0.31 1 0 0 0 0 0 0 0 Correto

0.73 0.96 0.1 0 0 1 0 0 0 0 0 Correto

0.28 0.42 0.93 0 0 0 0 0 0 1 0 Correto

0.56 0.15 0.18 1 0 0 0 0 0 0 0 Correto

0.25 0.18 0.64 1 0 0 0 0 0 0 0 Correto

0.05 0.87 0.34 0 0 0 0 0 0 0 1 Correto

0.44 0.19 0.73 1 0 0 0 0 0 0 0 Correto

0.11 0.9 0.41 0 0 0 0 0 0 0 1 Correto

0.85 0.41 0.97 0 0 0 0 0 0 1 0 Correto

0.95 0.36 0.3 0 0 1 0 0 0 0 0 Correto

0.01 0.22 0.3 0 0 0 0 0 0 0 1 Correto

0.06 0.08 0.57 0 0 0 0 0 0 0 1 Correto

0.33 0.4 0.33 0 0 0 0 0 0 0 0 Não Reconhecido

0.04 0.02 0.28 1 0 0 0 0 0 0 0 Correto

0.94 0.55 0.32 0 0 1 0 0 0 0 0 Correto

0.87 0.91 0.49 0 0 1 0 0 0 0 0 Correto

178

0.91 0.02 0.59 1 0 0 0 0 0 0 0 Errado - Direção Errada

0.1 0.47 0.46 0 0 0 0 0 0 0 1 Correto

0.78 0.87 0.19 0 1 0 0 0 0 0 0 Correto

0.45 0.09 0.36 1 0 0 0 0 0 0 0 Correto

0.79 0.32 0.87 1 0 0 0 0 0 0 0 Correto

0.17 0.48 0.87 0 0 0 0 0 0 0 1 Correto

179

L CÓDIGO FONTE DO ARQUIVO PDRNA.DLL

#include "D:\Meus Documentos\Softwares\Dev-C++\PDRNA\PDRNA.h"

#include <windows.h>

#include <math.h>

#include <stdio.h>

#define Act_Logistic(sum, bias) ( (sum+bias<10000.0) ? ( 1.0/(1.0 + exp(-sum-bias) ) ) :

0.0 )

#define Act_Identity(sum, bias) ( sum )

#ifndef NULL

#define NULL (void *)0

#endif

typedef struct UT {

float act; /* Activation */

float Bias; /* Bias of the Unit */

int NoOfSources; /* Number of predecessor units */

struct UT **sources; /* predecessor units */

float *weights; /* weights from predecessor units */

} UnitType, *pUnit;

/* Forward Declaration for all unit types */

static UnitType Units[29];

/* Sources definition section */

static pUnit Sources[] = {

Units + 1, Units + 2, Units + 3,


180
















Units + 4, Units + 5, Units + 6, Units + 7, Units + 8, Units + 9, Units + 10, Units + 11,

Units + 12, Units + 13,

Units + 14, Units + 15, Units + 16, Units + 17, Units + 18, Units + 19, Units + 20,














181









};

/* Weigths definition section */

static float Weights[] = {

-2.697980, -3.151080, -25.210899,

3.968060, 31.241920, -33.122879,

62.066269, 2.647630, -63.468349,

-7.463170, -5.524840, -3.441340,

53.176048, -1.333430, -0.141320,

-0.103780, 0.076290, 23.691320,

-15.254840, -12.395110, -8.643120,

22.911280, -19.931400, -12.234780,

25.058550, -0.458840, -8.305130,

-3.137810, 2.215350, 21.342840,

4.059160, -25.332050, 25.506620,

-13.218460, -2.055080, -5.721960,

0.191940, 72.142807, -2.894430,

-15.410860, -7.675940, 20.334330,

4.301910, -15.817540, -5.751450,

-35.093800, 36.284241, -1.786390,

182

1.176160, -1.482980, 64.152657,

-7.296000, -30.247690, -5.254930, 0.359240, -31.029051, 7.411190, 9.146040, 2.362280,

5.887150, 11.611230,

8.629180, 2.876830, 0.324670, -10.894670, 3.835130, -22.185930, -27.557030,

-24.520960, 28.612049, 25.793060, -2.173260, -17.753000, -7.311670, 5.735980, 6.719840, -

5.433370, -3.592840,

6.315320, 10.625830, -29.417950, -3.509090, -7.475300, 9.539540, -0.274550,

3.947710, -3.641910, 17.852579, 4.323410, 22.979490, 6.813470, -7.080890, -10.572310,

2.969300, -8.182690,

-7.683220, -2.815800, 24.532431, 2.493870, -4.299080, -11.607320, -17.397141,

-0.140040, -0.499880, -1.413580, -0.410250, 0.136820, -1.213430, -0.419550, -0.058770, -

0.796160, -1.381960,

-0.019040, 0.493110, -0.685200, -0.787300, -0.340630, -0.403260, 0.073780,

-10.479780, -3.075770, -0.412490, -1.923050, 11.304590, -3.781010, -3.455410, -3.088600,

2.473300, -1.776250,

-3.208870, 0.195500, -6.068210, -0.078550, 2.594690, -5.294650, 10.092630,

-4.179970, 2.853000, -2.296600, -1.148260, 5.360080, -3.355930, -1.680750, -4.251740,

1.238880, -0.566210,

-2.052700, -0.711940, 5.024230, -2.299190, 0.071920, 1.587590, 0.553900,

-17.317070, 11.936430, -23.947350, 9.195400, -31.321390, -3.082180, -3.914230, -2.537760,

0.068190, 9.970860,

-7.537340, -3.353370, 26.727270, 3.585490, 4.070420, -1.535530, 26.721479,

5.626100, -18.650560, -28.874969, -2.956700, 3.562850, 3.802390, 2.693810, -11.241080,

13.761910, -13.652430,

-9.792960, 2.345680, -31.432980, -2.139670, -3.130600, 24.893869, -26.590019,

};

/* unit definition section (see also UnitType) */

static UnitType Units[29] =

{

{ 0.0, 0.0, 0, NULL , NULL },

183

{ /* unit 1 (sEsq) */

0.0, -0.997500, 0,

&Sources[0] ,

&Weights[0] ,

},

{ /* unit 2 (sCnt) */

0.0, 0.127170, 0,

&Sources[0] ,

&Weights[0] ,

},

{ /* unit 3 (sDir) */

0.0, -0.613390, 0,

&Sources[0] ,

&Weights[0] ,

},

{ /* unit 4 (oculto) */

0.0, 24.020309, 3,

&Sources[0] ,

&Weights[0] ,

},


0.0, -2.205380, 3,

&Sources[3] ,

&Weights[3] ,

},


0.0, -1.550680, 3,

&Sources[6] ,

184

&Weights[6] ,

},


0.0, 7.870630, 3,

&Sources[9] ,

&Weights[9] ,

},


0.0, -47.650021, 3,

&Sources[12] ,

&Weights[12] ,

},


0.0, -1.673870, 3,

&Sources[15] ,

&Weights[15] ,

},


0.0, 21.430500, 3,

&Sources[18] ,

&Weights[18] ,

},


0.0, 4.945720, 3,

&Sources[21] ,

&Weights[21] ,

},


185

0.0, -12.529290, 3,

&Sources[24] ,

&Weights[24] ,

},


0.0, -19.608810, 3,

&Sources[27] ,

&Weights[27] ,

},


0.0, 0.073180, 3,

&Sources[30] ,

&Weights[30] ,

},


0.0, 2.608470, 3,

&Sources[33] ,

&Weights[33] ,

},


0.0, -64.471123, 3,

&Sources[36] ,

&Weights[36] ,

},


0.0, -3.606060, 3,

&Sources[39] ,

&Weights[39] ,

186

},


0.0, 0.695030, 3,

&Sources[42] ,

&Weights[42] ,

},


0.0, 0.311930, 3,

&Sources[45] ,

&Weights[45] ,

},


0.0, -58.485451, 3,

&Sources[48] ,

&Weights[48] ,

},

{ /* unit 21 (grau0) */

0.0, -0.645410, 17,

&Sources[51] ,

&Weights[51] ,

},

{ /* unit 22 (grau30) */

0.0, -19.726070, 17,

&Sources[68] ,

&Weights[68] ,

},

{ /* unit 23 (grau90) */

0.0, -22.198441, 17,

187

&Sources[85] ,

&Weights[85] ,

},

{ /* unit 24 (grau120) */

0.0, -0.659430, 17,

&Sources[102] ,

&Weights[102] ,

},

{ /* unit 25 (grau180) */

0.0, -5.328110, 17,

&Sources[119] ,

&Weights[119] ,

},

{ /* unit 26 (grau220) */

0.0, -5.299750, 17,

&Sources[136] ,

&Weights[136] ,

},

{ /* unit 27 (grau270) */

0.0, -1.491560, 17,

&Sources[153] ,

&Weights[153] ,

},

{ /* unit 28 (grau330) */

0.0, -3.975220, 17,

&Sources[170] ,

&Weights[170] ,

}

188

};

//---------------------------------------------------------------------------

// Rede Neural Artificial (Essa função pode ser acessada externamente por uma aplicação).

//---------------------------------------------------------------------------

__declspec(dllexport) int rede(float *in, float *out, int init)

{

int member, source;

float sum;

enum{OK, Error, Not_Valid};

pUnit unit;

/* layer definition section (names & member units) */

static pUnit Input[3] = {Units + 1, Units + 2, Units + 3}; /* members */

static pUnit Hidden1[17] = {Units + 4, Units + 5, Units + 6, Units + 7, Units + 8, Units

+ 9, Units + 10, Units + 11, Units + 12, Units + 13, Units + 14, Units + 15, Units + 16, Units +

17, Units + 18, Units + 19, Units + 20}; /* members */

static pUnit Output1[8] = {Units + 21, Units + 22, Units + 23, Units + 24, Units + 25,

Units + 26, Units + 27, Units + 28}; /* members */

static int Output[8] = {21, 22, 23, 24, 25, 26, 27, 28};

for(member = 0; member < 3; member++) {

Input[member]->act = in[member];

}

189

for (member = 0; member < 17; member++) {

unit = Hidden1[member];

sum = 0.0;

for (source = 0; source < unit->NoOfSources; source++) {

sum += unit->sources[source]->act

* unit->weights[source];

}

unit->act = Act_Logistic(sum, unit->Bias);

};

for (member = 0; member < 8; member++) {

unit = Output1[member];

sum = 0.0;

for (source = 0; source < unit->NoOfSources; source++) {

sum += unit->sources[source]->act

* unit->weights[source];

}

unit->act = Act_Logistic(sum, unit->Bias);

};

for(member = 0; member < 8; member++) {

out[member] = Units[Output[member]].act;

}

return(OK);

}

190

M CÓDIGO FONTE DO MUNDO MARLOSOBSTACULO

public MarlosObstaculo() { /** Paredes Externas. */ Wall w1 = new Wall(new Vector3d(9, 0, 0), 18, 2, this); w1.rotate90(1); add(w1); Wall w2 = new Wall(new Vector3d(-9, 0, 0), 18, 2, this); w2.rotate90(1); add(w2); Wall w3 = new Wall(new Vector3d(0, 0, 9), 18, 2, this); add(w3); Wall w4 = new Wall(new Vector3d(0, 0, -9), 18, 2, this); add(w4); /** Obstáculos */ add(new Box(new Vector3d(2,0,2),new Vector3f(2,1,2),this)); add(new Box(new Vector3d(-2,0,-2),new Vector3f(3,1,2),this)); add(new Box(new Vector3d(6,0,6),new Vector3f(2,1,3),this)); add(new Box(new Vector3d(-6,0,-6),new Vector3f(3,1,2),this)); add(new Box(new Vector3d(3,0,6),new Vector3f(2,1,3),this)); add(new Box(new Vector3d(-2,0,6),new Vector3f(3,1,2),this)); add(new Box(new Vector3d(2,0,-6),new Vector3f(2,1,2),this)); add(new Box(new Vector3d(-2,0,-6),new Vector3f(3,1,2),this)); add(new Box(new Vector3d(4,0,-2),new Vector3f(3,1,2),this)); add(new Box(new Vector3d(6,0,-6),new Vector3f(3,1,2),this)); add(new Box(new Vector3d(-6,0,2),new Vector3f(2,1,11),this)); /** Robô */ add(new Robot(new Vector3d(5, 0, -8.2), "RNAn1")); }

191

N CÓDIGO FONTE DO MUNDO MARLOSLABERINTO

public MarlosLaberinto() { /** Paredes Externas. */ Wall w1 = new Wall(new Vector3d(9, 0, 0), 18, 2, this); w1.rotate90(1); add(w1); Wall w2 = new Wall(new Vector3d(-9, 0, 0), 18, 2, this); w2.rotate90(1); add(w2); Wall w3 = new Wall(new Vector3d(0, 0, 9), 18, 2, this); add(w3); Wall w4 = new Wall(new Vector3d(0, 0, -9), 18, 2, this); add(w4); /** Paredes Internas. */ Wall w5 = new Wall(new Vector3d(4, 0, 7), 6, 2, this); add(w5); Wall w6 = new Wall(new Vector3d(-4, 0, 7), 6, 2, this); add(w6); Wall w7 = new Wall(new Vector3d(7, 0, 0), 14, 2, this); w7.rotate90(1); add(w7); Wall w8 = new Wall(new Vector3d(-1, 0, 8), 2, 2, this); w8.rotate90(1); add(w8); Wall w9 = new Wall(new Vector3d(-7, 0, 0), 14, 2, this); w9.rotate90(1); add(w9); Wall w10 = new Wall(new Vector3d(-1, 0, -7), 12, 2, this); add(w10); Wall w11 = new Wall(new Vector3d(5, 0, -4), 6, 2, this); w11.rotate90(1); add(w11); Wall w12 = new Wall(new Vector3d(2, 0, 5), 6, 2, this); add(w12); Wall w13 = new Wall(new Vector3d(-1, 0, 6), 2, 2, this); w13.rotate90(1); add(w13); Wall w14 = new Wall(new Vector3d(5, 0, 3), 4, 2, this); w14.rotate90(1); add(w14); Wall w15 = new Wall(new Vector3d(-5, 0, 5), 4, 2, this); add(w15); Wall w16 = new Wall(new Vector3d(0, 0, 1), 10, 2, this); add(w16); Wall w17 = new Wall(new Vector3d(-1, 0, 3), 8, 2, this); add(w17); Wall w18 = new Wall(new Vector3d(-5, 0, -1), 8, 2, this); w18.rotate90(1); add(w18); Wall w19 = new Wall(new Vector3d(3, 0, -3), 4, 2, this); w19.rotate90(1); add(w19); Wall w20 = new Wall(new Vector3d(-3, 0, -3), 4, 2, this); w20.rotate90(1);

192

add(w20); Wall w21 = new Wall(new Vector3d(-2, 0, -5), 6, 2, this); add(w21); Wall w22 = new Wall(new Vector3d(-1, 0, -1), 4, 2, this); add(w22); Wall w23 = new Wall(new Vector3d(4, 0, -1), 2, 2, this); add(w23); Wall w24 = new Wall(new Vector3d(1, 0, -4), 2, 2, this); w24.rotate90(1); add(w24); Wall w25 = new Wall(new Vector3d(-1, 0, -2), 2, 2, this); w25.rotate90(1); add(w25); /** Robô */ add(new Robot(new Vector3d(5, 0, -8.2), "RNAn1"));

}

193

O ALTERAÇÕES PARA ADAPTAR O ROBÔ À RNA

static public RangeSensorBelt addSonarBeltSensor(Agent agent,int nbSonars) { double agentHeight = agent.getHeight(); double agentRadius = agent.getRadius(); /** Declaração dos Meus Vetores 3D */ Vector3d minhaPosicao1 = new Vector3d(0.29,0,0); Vector3d minhaDirecao1 = new Vector3d(2.5,0,0); Vector3d minhaPosicao2 = new Vector3d(0,0,0.29); Vector3d minhaDirecao2 = new Vector3d(2.5,0,0); Vector3d minhaPosicao3 = new Vector3d(0,0,-0.29); Vector3d minhaDirecao3 = new Vector3d(2.5,0,0); Vector3d pos3d[] = new Vector3d[nbSonars]; Vector3d dir3d[] = new Vector3d[nbSonars]; pos3d[0] = minhaPosicao1; dir3d[0] = minhaDirecao1; pos3d[1] = minhaPosicao2; dir3d[1] = minhaDirecao2; pos3d[2] = minhaPosicao3; dir3d[2] = minhaDirecao3; RangeSensorBelt sonarBelt = new RangeSensorBelt(pos3d, dir3d, RangeSensorBelt.TYPE_SONAR,0); sonarBelt.setUpdatePerSecond(6); sonarBelt.setName("sonars"); Vector3d pos = new Vector3d(0, agentHeight / 2, 0.0); agent.addSensorDevice(sonarBelt, pos, 0); return sonarBelt; } --------------------------------------//--------------------------------------- /** reads the three front quadrants */ double front = sonars.getMeasurement(0); double right = sonars.getMeasurement(1); double left = sonars.getMeasurement(2); /** Realiza o ajuste de valores para atender os critérios da rede neural */ public void restringeFaixa() { for (int i = 0; i < 3; i++) { if (VetorEntrada[i] > 1.00f) { VetorEntrada[i] = 1.00f; } } } /** Responsável por realizar a inversão entre 0 e 1 para atender a RNA */ public void inverteExtremos() { for (int i = 0; i < 3; i++) { VetorEntrada[i] = (VetorEntrada[i] - 1); if (VetorEntrada[i] < 0) { VetorEntrada[i] = (VetorEntrada[i] * (-1)); } } }

194

/** Função Responsável por converter os valores de VetorSaida para 0 ou 1 */ public void converteSaida() { for (int x = 0; x < 8; x++){ float maior = VetorSaida[x]; for (int y = 0; y < 8; y++){ if (VetorSaida[y] < maior) { VetorSaida[y] = 0; } } } for (int i = 0; i < 8; i++){ if (VetorSaida [i] > 0){ VetorSaida[i] = 1; } } }

Área de inteligência artificial por marlos roberto de ...siaibib01.univali.br/pdf/marlos roberto...

Documents