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
"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
ii
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.
iii
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.
iv
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.
v
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
vi
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
3.2
3.3
3.4
3.5
METODOLOGIA.............................................................................................. 44
REQUISITOS FUNCIONAIS .......................................................................... 46
REQUISITOS NÃO FUNCIONAIS ................................................................ 46
REGRAS DE DECISÃO DA REDE NEURAL ARTIFICIAL..................... 47
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
vii
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
viii
LISTA DE ABREVIATURAS
BP
CA
CC
DLL
GSC
GNU
GPL
IPVR
IA
JavaNNS
JNA
JNI
JOONE
MLP
Quickprop
PRNA
PDRNA
RBF
RCS
RProp
RNA
SNA
SNNS
TCC
TDNN
WSI
UNIVALI
VSC
VSD
VSE
X11R4
X11R5
XGUI
Backpropagation
Corrente Alternada
Corrente Contínua
Dynamic Link Library
Graduation in Science of the Computation
GNU is Not Unix
General Public Licence
Institute for Parallel and Distributed High Performance Systems
Inteligência Artificial
Java Neural Network Simulator
Java Native Access
Java Native Interface
Java Object Oriented Neural Engine
Multilayer Perceptron
Quickpropagation
Projeto Rede Neural Artificial
Projeto Dev Rede Neural Artificial
Generalized Radial Basis functions
Revision Control System
Resilient Backpropagation
Rede Neural Artificial
Sistema de Navegação Autônoma
Stuttgart Neural Network Simulator
Trabalho de Conclusão de Curso
time-delay neural networks
Wilhelm-Schickard-Institute for Computer Science
Universidade do Vale do Itajaí
Valor do Sensor Central
Valor do Sensor Direito
Valor do Sensor Esquerdo
X Window System - Version 11 release 4 of the X protocol
X Window System - Version 11 release 5 of the X protocol
X Graphical User Interface
ix
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
x
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
xi
Figura 96. Fluxo genérico de carregamento dinâmico de uma DLL................................................117
xii
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
xiii
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.
xiv
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.
xv
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).
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
2
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;
3
·
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
4
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
5
·
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).
6
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
7
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;
8
·
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.
9
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.
10
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
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 KTeam, 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
12
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;
13
·
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
14
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.
15
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.
16
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.
17
Figura 3. Feedforward de uma camada.
Figura 4. Feedforward de duas camadas.
Fonte: Braga, Carvalho e Ludermir, 2007
Fonte: Braga, Carvalho e Ludermir, 2007
Figura 5. Recorrência entre saída e intermediária.
Figura 6. Recorrência auto-associativa.
Fonte: Braga, Carvalho e Ludermir, 2007
Fonte: Braga, Carvalho e Ludermir, 2007
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;
18
·
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.
19
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
Fonte: Braga, Carvalho e Ludermir, 2007
20
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
Fonte: Braga, Carvalho e Ludermir, 2007
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.
21
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).
22
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 hillclimbing, ou seja, ao problema de mínimos locais. A figura também ilustra o processo de redução
dos erros utilizando o backpropagation.
23
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.
Fonte: (REIS; ALBUQUERQUE; CASTRO, 2001)
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.
24
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.
Fonte: (REIS; ALBUQUERQUE; CASTRO, 2001)
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
25
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).
26
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).
27
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.
28
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;
29
·
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.
30
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.
31
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).
32
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).
33
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)
turnLeft(double degree)
Ahead(double distance)
back(double distance)
turnGunRight(double degree)
turnGunLeft(double degree)
setAdjustGunForRobotTurn(boolean flag)
setAdjustRadarForRobotTurn(boolean flag)
setAdjustRadarForGunTurn(boolean flag)
Virar o robô
Move o robô e finaliza caso bata em uma parede
Move o canhão independente do veiculo
Se verdadeiro, vira o canhão junto com o veiculo
Se verdadeiro, vira o radar junto com o veiculo
Se verdadeiro, vira o radar junto com o canhão
Tabela 1. Principais comandos do robô.
Fonte: (PASSOS, 2008).
Os principais eventos realizados pelo robô são descritos na Tabela 2.
DESCRIÇÃO
MÉTODO
Chamado quando o robô é detectado pelo radar
Chamado quando o robô é atingido por uma bala
Chamado quando ocorre uma colisão entre robôs
Chamado quando o robô colide contra uma parede
onScannedRobot(ScannedRobotEvent)
onHitByBullet(HitByBulletEvent)
onHitRobot(HiRobotEvent)
onHitWall(HitWallEvent)
Tabela 2. Principais eventos utilizados pelo robô.
Fonte: (PASSOS, 2008).
As principais funções para se obter informações são descritas na tabela 3.
34
DESCRIÇÃO
Coordenadas correntes do robô
Direção corrente do robô
Dimensões do campo de batalha
MÉTODO
get(x)
get(y)
getHeading()
getGunHeading()
getRadarHeading()
getBattleFieldWidth()
getBattleFieldHeight()
Tabela 3. Principais funções utilizadas para a obtenção de informações.
Fonte: (PASSOS, 2008).
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).
35
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).
36
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).
37
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
38
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).
39
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
Cria um objeto caixa no ambiente
Classe que auxilia na construção de robôs e sensores
Define a velocidade translacional em metro por
segundo
Define a velocidade rotacional em radianos por
segundo
Retorna a posição do robô em coordenadas
setWorldSize(float size)
Box(Vector3d, Vector3f, EnvironmentDescription)
RobotFactory()
setTranslationalVelocity(double TV)
setRotationalVelocity(double TV)
getCoords(javax.vecmath.Point3d cood)
Tabela 4. Principais funções disponibilizadas pelo Simbad 3D.
Fonte: (PASSOS, 2008).
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 multiagente 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).
40
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).
41
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, optouse 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
42
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.
43
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
44
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;
45
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.
46
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.
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.
A Figura 23 apresenta um conjunto de entradas e saídas que obedecem as regras
apresentadas na Caixa de Texto 1:
47
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
A (<= 0.90)
>= 0.98
>= 0.98
<= 0.98
>= 0.91
>= 0.91
<= 0.90
>= 0.91
<= 0.90
Sensor Central
>= 91º
>= 0.98
>= 0.98
>= 0.98
>= 0.91
<= 0.90
>= 0.91
>= 0.91
Sensor Direito
A (<= 0.90)
>= 0.98
<= 0.98
>= 0.98
>= 0.91
>= 0.91
>= 0.91
<= 0.90
>= 0.91
VSE < VSD
VSD < VSE
Direção
90º
180º
120º
240º
180º
180º
270º
90º
<= 0.90
270º
90º
<= 0.90
>= 0.91
<= 0.90
<= 0.90
>= 0.91
<= 0.90
<= 0.90
<= 0.90
<= 0.90
VSD > VSE
VSD = VSE
VSD < VSE
VSD = VSE
VSC < VSD
VSC < VSE
VSC = VSD
VSC = VSE
VSC = VSD
VSC = VSE
VSC > VSD
VSC > VSD
VSC > VSE
VSC < VSE
VSD < VSE
VSD > VSE
VSC > VSE
VSC > VSD
VSC < VSE
VSC < VSD
Tabela 5. Regras de decisão da Rede Neural Artificial.
48
270º
90º
330º
90º
30º
0º
0º
0º
330º
30º
0º
0º
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).
49
Figura 25. Primeira seqüência de valores para análise.
Figura 26. Segunda seqüência de valores para análise.
50
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
51
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.
52
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
53
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.
Ambiente
JavaNNS
SNNS
JOONE
ANNeF
FANN
Scilab
Recursos Oferecidos
(1 a 3)
3
3
2
2
2
2
Simplicidade de Uso
(1 a 3)
3
2
2
1
1
1
Reconhecimento Acadêmico
(1 a 3)
3
3
2
2
2
3
Tabela 6. Análise e Pontuação dos Ambientes de Criação de RNAs.
54
Total
9
8
6
5
5
6
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
55
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:
4.1.2.1
·
.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).
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:
56
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.
57
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
58
·
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.
59
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. Podese 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.
60
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.
61
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.
62
Figura 39. RNA GSC200901-A Treinada.
Figura 40. Arquivo log de Treinamento e Validação da RNA GSC200901-A.
63
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.
·
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.
64
·
Ciclos: 30000 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.
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.
65
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.
66
·
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 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.
·
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: 50000 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.
Figura 45. RNA GSC200901-C Treinada.
67
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.
68
É 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
69
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 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 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.
·
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.
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.
70
Figura 48. RNA GSC200901-D Treinada.
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
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
72
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.
73
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;
74
·
-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.
75
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).
RNA
Total de
Padrões
A
B
C
D
911
911
911
911
Padrões
Reconhecidos
Corretos Incorretos
902
1
901
1
905
0
904
0
Padrões Ñ
Reconhecidos
% de
Acertos
8
9
6
7
99,01
98,90
99,34
99,23
Erro da RNA
No
Treinamento
10,712665
11,604062
8,208152
7,444362
Tabela 7. Resultados obtidos pelo Analyzer quanto ao Treinamento da RNA.
RNA
Total de
Padrões
A
B
C
D
200
200
200
200
Padrões
Reconhecidos
Corretos Incorretos
182
3
185
4
185
10
186
7
Padrões Ñ
Reconhecidos
% de
Acertos
15
11
5
7
91,00
92,50
92,50
93,00
Tabela 8. Resultados obtidos pelo Analyzer quanto a Validação da RNA.
76
Erro da RNA
Na
Validação
17,447292
16,745084
24,464050
21,461576
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.
77
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.
78
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.
79
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:
80
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.
81
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/enus/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/.
82
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.
Ambiente
Simbad 3D
Robocode
Khepera
Webots
RDS
Simulator Bob
Multiplataforma
(1 a 3)
3
3
2
1
1
1
Código Aberto Atualizado Reconhecimento Acadêmico Total
(1 a 3)
(1 a 3)
8
3
2
7
3
1
5
2
1
5
1
3
4
1
2
3
1
1
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).
83
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.
84
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.
85
Figura 68. Mundo virtual MarlosObstaculos.
Fonte: Simbad 3D.
Figura 69. Mundo virtual MarlosLaberinto.
Fonte: Simbad 3D.
86
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,
87
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).
88
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%.
89
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.
90
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.
91
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.
92
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
93
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.
94
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.
95
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
96
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.
97
APÊNDICES
98
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).
99
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).
100
Figura 77. Vários programas em execução usando a mesma dll simultaneamente.
Fonte: (MESSIAS A, 2009).
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.
Fonte: (MESSIAS A, 2009).
101
Figura 79. Chamando uma dll dinamicamente em C++.
Fonte: (MESSIAS A, 2009).
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).
102
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;
103
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.
Fonte: Embarcadero RAD Studio 2010.
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;
104
Figura 82. Código fonte gerado automaticamente para começar o desenvolvimento de uma dll.
Fonte: Embarcadero RAD Studio 2010.
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.
105
Comando
extern "C"
__declspec(dllexport) ou _export ou __export
_stdcall ou __stdcall ou WINAPI
Função
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;
Comandos usados para exportar as funções da DLL
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.
Fonte: (MESSIAS B, 2009).
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:
106
Tipo Redefinido
BYTE
WORD
DWORD
Tipo original
unsigned char
unsigned int short
unsigned int
Tabela 11. Tipos redefinidos.
Fonte: (MESSIAS B, 2009).
O C++Builder permite o uso dos tipos redefinidos na Tabela 11 livremente em nosso código
fonte, sem nenhum erro de sintaxe.
107
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”;
108
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.
109
Figura 87. Conteúdo alterado do arquivo PDRNA.dev.
Fonte: Bloodshed Dev-C++ 4.
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.
Fonte: Bloodshed Dev-C++ 4.
110
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.
111
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;
112
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:
113
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.
114
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.
Fonte: (MESSIAS C, 2009).
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.
115
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 MinhaFunc(int a, int b);
char MinhaFunc(void);
unsigned char MinhaFunc(int x, char *texto);
char *MinhaFunc( unsigned char *s);
int *Ponteiro; ou int (*Ponteiro);
char *Ponteiro;
void *Ponteiro;
unsigned char (*Ponteiro);
Tabela 13. Ponteiros para Variáveis.
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.
Fonte: (MESSIAS C, 2009).
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;
MinhaSoma = Soma;
Valor = MinhaSoma(10, 60);
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'.
Não se usa os parênteses quando o objetivo é passar o endereço da função.
Executa a função Soma() indiretamente através do ponteiro 'MinhaSoma'.
Tabela 15. Declaração de Ponteiro para Função.
116
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:
LoadLibrary():
Sintaxe:
Descrição:
Carrega um arquivo DLL na memória dinamicamente;
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().
117
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().
Função:
FreeLibrary():
Descrição:
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().
Função:
GetProcAddress():
Descrição:
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.
118
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
119
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
------|---------------------------------------------------------------------------------------------------------------------------
120
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:
0.3 0.24 0.68
# Output pattern 1:
10000000
# Input pattern 2:
0.56 0.61 0.05
# Output pattern 2:
01000000
# Input pattern 3:
0.62 0.76 0.67
# Output pattern 3:
00000001
# Input pattern 4:
0.82 0.58 0.73
# Output pattern 4:
10000000
# Input pattern 5:
0.45 0.87 0.11
# Output pattern 5:
01000000
# Input pattern 6:
0.72 0.06 0.05
# Output pattern 6:
01000000
# Input pattern 7:
0.55 0.26 0.02
# Output pattern 7:
01000000
# Input pattern 8:
0.31 0.44 0.29
# Output pattern 8:
01000000
# Input pattern 229:
0.4 0.43 0.85
# Output pattern 229:
00000001
# Input pattern 230:
0.7 0.4 0.35
# Output pattern 230:
01000000
# Input pattern 231:
0.55 0.77 0.1
# Output pattern 231:
01000000
# Input pattern 232:
0.23 0.76 0.11
# Output pattern 232:
01000000
# Input pattern 233:
0.51 0.77 0.83
# Output pattern 233:
00000001
# Input pattern 234:
0.99 0.4 0.32
# Output pattern 234:
00100000
# Input pattern 235:
0.12 0.36 0.15
# Output pattern 235:
00000001
# Input pattern 236:
0.51 0.94 0.33
# Output pattern 236:
00100000
# Input pattern 457:
0.86 0.86 0.51
# Output pattern 457:
01000000
# Input pattern 458:
0.46 0.77 0.14
# Output pattern 458:
01000000
# Input pattern 459:
0.24 0.56 0.64
# Output pattern 459:
00000001
# Input pattern 460:
0.12 0.52 0.18
# Output pattern 460:
00000001
# Input pattern 461:
0.88 0.46 0.98
# Output pattern 461:
00000010
# Input pattern 462:
0.17 0.36 0.98
# Output pattern 462:
00000010
# Input pattern 463:
0.57 0.7 0.89
# Output pattern 463:
00000001
# Input pattern 464:
0.89 0.78 0.13
# Output pattern 464:
01000000
121
# Input pattern 685:
0.19 0.36 0.76
# Output pattern 685:
00000001
# Input pattern 686:
0.31 0.24 0.56
# Output pattern 686:
10000000
# Input pattern 687:
0.26 0.66 0.12
# Output pattern 687:
01000000
# Input pattern 688:
0.97 0.61 0.91
# Output pattern 688:
00001000
# Input pattern 689:
0.5 0.21 0.27
# Output pattern 689:
10000000
# Input pattern 690:
0.97 0.38 0.68
# Output pattern 690:
00100000
# Input pattern 691:
0.54 0.21 0.47
# Output pattern 691:
10000000
# Input pattern 692:
0.39 0.4 0.97
# Output pattern 692:
00000010
# Input pattern 9:
0.03 0.54 0.68
# Output pattern 9:
00000001
# Input pattern 10:
0.28 0.73 0.14
# Output pattern 10:
01000000
# Input pattern 11:
0.64 0.5 0.73
# Output pattern 11:
10000000
# Input pattern 12:
0.63 0.84 0.31
# Output pattern 12:
01000000
# Input pattern 13:
0.33 0.15 0.04
# Output pattern 13:
01000000
# Input pattern 14:
0.49 0.18 0.02
# Output pattern 14:
01000000
# Input pattern 15:
0.64 0.33 0.05
# Output pattern 15:
01000000
# Input pattern 16:
0.84 0.05 0.85
# Output pattern 16:
10000000
# Input pattern 17:
0.17 0.62 0.83
# Output pattern 17:
00000001
# Input pattern 18:
0.19 0.43 0.91
# Output pattern 18:
00000010
# Input pattern 19:
0.85 0.48 0.09
# Output pattern 19:
01000000
# Input pattern 20:
0.69 0.68 0.24
# Input pattern 237:
0.94 0.84 0.29
# Output pattern 237:
00100000
# Input pattern 238:
0.96 0.99 0.99
# Output pattern 238:
00000100
# Input pattern 239:
0.57 0.23 0.25
# Output pattern 239:
10000000
# Input pattern 240:
0.94 0.77 0.65
# Output pattern 240:
00100000
# Input pattern 241:
0.19 0.7 0.14
# Output pattern 241:
01000000
# Input pattern 242:
0.38 0.12 0.53
# Output pattern 242:
10000000
# Input pattern 243:
0.04 0.42 0.58
# Output pattern 243:
00000001
# Input pattern 244:
0.12 0.25 0.59
# Output pattern 244:
00000001
# Input pattern 245:
0.95 0.69 0.66
# Output pattern 245:
00100000
# Input pattern 246:
0.63 0.12 0.81
# Output pattern 246:
10000000
# Input pattern 247:
0.63 0.86 0.54
# Output pattern 247:
01000000
# Input pattern 248:
0.57 0.27 0.36
# Input pattern 465:
0.63 0.16 0.89
# Output pattern 465:
10000000
# Input pattern 466:
0.89 0.21 0.31
# Output pattern 466:
10000000
# Input pattern 467:
0.41 0.59 0.12
# Output pattern 467:
01000000
# Input pattern 468:
0.41 0.04 0.66
# Output pattern 468:
10000000
# Input pattern 469:
1 0.61 0.16
# Output pattern 469:
00100000
# Input pattern 470:
0.46 0.96 0
# Output pattern 470:
00100000
# Input pattern 471:
0.52 0.64 0.95
# Output pattern 471:
00000010
# Input pattern 472:
0.38 0.17 0.57
# Output pattern 472:
10000000
# Input pattern 473:
0.56 0.08 0.5
# Output pattern 473:
10000000
# Input pattern 474:
0.59 0.92 0.66
# Output pattern 474:
00000010
# Input pattern 475:
0.28 0.28 0.89
# Output pattern 475:
10000000
# Input pattern 476:
0.08 0.47 0.89
122
# Input pattern 693:
0.21 0.07 0
# Output pattern 693:
01000000
# Input pattern 694:
0.39 0.96 0.75
# Output pattern 694:
00000010
# Input pattern 695:
0.41 0.18 0.32
# Output pattern 695:
10000000
# Input pattern 696:
0.86 0.06 0.48
# Output pattern 696:
10000000
# Input pattern 697:
0.24 0.14 0.55
# Output pattern 697:
10000000
# Input pattern 698:
0.42 0.8 0.34
# Output pattern 698:
01000000
# Input pattern 699:
0.25 0.68 0.29
# Output pattern 699:
00000001
# Input pattern 700:
0.96 0 0.96
# Output pattern 700:
00001000
# Input pattern 701:
0.97 0 0.97
# Output pattern 701:
00001000
# Input pattern 702:
0.98 0 0.98
# Output pattern 702:
00001000
# Input pattern 703:
0.99 0 0.99
# Output pattern 703:
00001000
# Input pattern 704:
0.99 0.06 0.97
# Output pattern 20:
01000000
# Input pattern 21:
0.38 0.95 0.73
# Output pattern 21:
00000010
# Input pattern 22:
0.38 0.51 0.39
# Output pattern 22:
00000001
# Input pattern 23:
0.85 0.8 0.62
# Output pattern 23:
01000000
# Input pattern 24:
0.65 0.91 0.27
# Output pattern 24:
00100000
# Input pattern 25:
0.29 0.87 0.96
# Output pattern 25:
00000010
# Input pattern 26:
0.05 0.88 0.38
# Output pattern 26:
00000001
# Input pattern 27:
0.41 0.47 0.75
# Output pattern 27:
00000001
# Input pattern 28:
0.65 0.81 0.15
# Output pattern 28:
01000000
# Input pattern 29:
0.55 0.76 0.11
# Output pattern 29:
01000000
# Input pattern 30:
0.05 0.86 0.19
# Output pattern 30:
00000001
# Input pattern 31:
0.61 0.57 0.06
# Output pattern 31:
01000000
# Output pattern 248:
10000000
# Input pattern 249:
0.23 0.59 0.02
# Output pattern 249:
01000000
# Input pattern 250:
0.41 0.09 0.42
# Output pattern 250:
10000000
# Input pattern 251:
0.13 0.09 0.77
# Output pattern 251:
10000000
# Input pattern 252:
0.86 0.21 0.86
# Output pattern 252:
10000000
# Input pattern 253:
0.58 0.56 0.27
# Output pattern 253:
01000000
# Input pattern 254:
0.55 0.06 0.3
# Output pattern 254:
10000000
# Input pattern 255:
0.27 0.71 0.56
# Output pattern 255:
00000001
# Input pattern 256:
0.34 0.85 0.71
# Output pattern 256:
00000001
# Input pattern 257:
0.7 0.35 0.12
# Output pattern 257:
01000000
# Input pattern 258:
0.33 0.08 0.65
# Output pattern 258:
10000000
# Input pattern 259:
0.77 0.48 0.17
# Output pattern 259:
01000000
# Output pattern 476:
00000001
# Input pattern 477:
0.01 0.54 0.67
# Output pattern 477:
00000001
# Input pattern 478:
0.42 0.26 0.65
# Output pattern 478:
10000000
# Input pattern 479:
0.86 0.17 0.5
# Output pattern 479:
10000000
# Input pattern 480:
0.83 0.12 0.15
# Output pattern 480:
10000000
# Input pattern 481:
0.06 0.84 0.75
# Output pattern 481:
00000001
# Input pattern 482:
0.54 0.28 0.34
# Output pattern 482:
10000000
# Input pattern 483:
0.1 0.24 0.38
# Output pattern 483:
00000001
# Input pattern 484:
0.16 0.9 1
# Output pattern 484:
00000010
# Input pattern 485:
0.7 0.28 0.93
# Output pattern 485:
00000010
# Input pattern 486:
0.49 0.25 0.58
# Output pattern 486:
10000000
# Input pattern 487:
0.73 0.45 0.49
# Output pattern 487:
10000000
123
# Output pattern 704:
00001000
# Input pattern 705:
101
# Output pattern 705:
00001000
# Input pattern 706:
0.96 0 0.98
# Output pattern 706:
00001000
# Input pattern 707:
0.98 0.01 1
# Output pattern 707:
00001000
# Input pattern 708:
1 0.05 0.96
# Output pattern 708:
00001000
# Input pattern 709:
0.96 0.07 0.99
# Output pattern 709:
00001000
# Input pattern 710:
0.99 0.03 0.96
# Output pattern 710:
00001000
# Input pattern 711:
0.96 0.09 1
# Output pattern 711:
00001000
# Input pattern 712:
0.63 0.02 0.6
# Output pattern 712:
10000000
# Input pattern 713:
0.33 0.26 0.89
# Output pattern 713:
10000000
# Input pattern 714:
0.48 0.09 0.75
# Output pattern 714:
10000000
# Input pattern 715:
0.86 0.5 0.21
# Output pattern 715:
01000000
# Input pattern 32:
0.79 0.57 0.17
# Output pattern 32:
01000000
# Input pattern 33:
0.92 0.5 0.55
# Output pattern 33:
00100000
# Input pattern 34:
0.9 0.43 0.37
# Output pattern 34:
01000000
# Input pattern 35:
0.03 0.66 0.97
# Output pattern 35:
00000010
# Input pattern 36:
0.05 0.4 0.33
# Output pattern 36:
00000001
# Input pattern 37:
0.51 0.17 0.61
# Output pattern 37:
10000000
# Input pattern 38:
0.23 0.53 0.82
# Output pattern 38:
00000001
# Input pattern 39:
0.52 0.39 0.48
# Output pattern 39:
10000000
# Input pattern 40:
0.32 0.44 0.88
# Output pattern 40:
00000001
# Input pattern 41:
0.26 0.65 0.48
# Output pattern 41:
00000001
# Input pattern 42:
0.4 0.69 0.43
# Output pattern 42:
00000001
# Input pattern 43:
0.52 0.19 0.39
# Input pattern 260:
0.23 0.35 0.46
# Output pattern 260:
00000001
# Input pattern 261:
0.01 0.39 0.58
# Output pattern 261:
00000001
# Input pattern 262:
0.26 0.42 0.96
# Output pattern 262:
00000010
# Input pattern 263:
0.81 0.72 0.62
# Output pattern 263:
01000000
# Input pattern 264:
0.56 0.84 0.01
# Output pattern 264:
01000000
# Input pattern 265:
0.9 0.24 0.08
# Output pattern 265:
01000000
# Input pattern 266:
0.71 0.62 0.29
# Output pattern 266:
01000000
# Input pattern 267:
0.3 0.22 0.02
# Output pattern 267:
01000000
# Input pattern 268:
0.17 0.81 0.77
# Output pattern 268:
00000001
# Input pattern 269:
0.25 0.28 0.54
# Output pattern 269:
00000001
# Input pattern 270:
0.95 0.09 0.32
# Output pattern 270:
00100000
# Input pattern 271:
0.82 0.82 0.55
# Input pattern 488:
0.58 0.03 0.38
# Output pattern 488:
10000000
# Input pattern 489:
0.34 0.51 0.57
# Output pattern 489:
00000001
# Input pattern 490:
0.19 0.8 0.5
# Output pattern 490:
00000001
# Input pattern 491:
0.99 0.82 0.28
# Output pattern 491:
00100000
# Input pattern 492:
0.37 0.29 0.57
# Output pattern 492:
10000000
# Input pattern 493:
0.3 0.92 0.57
# Output pattern 493:
00000010
# Input pattern 494:
0.87 0.34 0.92
# Output pattern 494:
00000010
# Input pattern 495:
0.23 0.54 0.38
# Output pattern 495:
00000001
# Input pattern 496:
0.69 0.3 0.1
# Output pattern 496:
01000000
# Input pattern 497:
0.45 0.68 0.15
# Output pattern 497:
01000000
# Input pattern 498:
0.85 0.19 0.14
# Output pattern 498:
01000000
# Input pattern 499:
0.13 0.9 0.09
124
# Input pattern 716:
0.77 0.61 0.24
# Output pattern 716:
01000000
# Input pattern 717:
0.51 0.96 0.56
# Output pattern 717:
00000010
# Input pattern 718:
0.26 0.75 0.37
# Output pattern 718:
00000001
# Input pattern 719:
0.74 0.39 0.67
# Output pattern 719:
10000000
# Input pattern 720:
0.03 0.92 0.04
# Output pattern 720:
00000010
# Input pattern 721:
0.26 0.6 0.31
# Output pattern 721:
00000001
# Input pattern 722:
0.84 0.44 0.73
# Output pattern 722:
10000000
# Input pattern 723:
0.77 0.09 0.24
# Output pattern 723:
10000000
# Input pattern 724:
0.28 0.45 0.34
# Output pattern 724:
00000001
# Input pattern 725:
0.84 0.33 0.49
# Output pattern 725:
10000000
# Input pattern 726:
0.4 0.7 0.56
# Output pattern 726:
00000001
# Input pattern 727:
0.84 0.99 1
# Output pattern 43:
10000000
# Input pattern 44:
0.77 0.29 0.31
# Output pattern 44:
10000000
# Input pattern 45:
0.9 0.17 0.61
# Output pattern 45:
10000000
# Input pattern 46:
0.05 0.29 0.81
# Output pattern 46:
00000001
# Input pattern 47:
0.37 0.23 0.96
# Output pattern 47:
00000010
# Input pattern 48:
0.4 0.05 0.03
# Output pattern 48:
01000000
# Input pattern 49:
0.5 0.84 0.05
# Output pattern 49:
01000000
# Input pattern 50:
0.66 0.84 0.61
# Output pattern 50:
01000000
# Input pattern 51:
0.58 0.8 0.48
# Output pattern 51:
01000000
# Input pattern 52:
0.17 0.2 0.56
# Output pattern 52:
00000001
# Input pattern 53:
0.23 0.19 0.36
# Output pattern 53:
10000000
# Input pattern 54:
0.58 0.04 0.1
# Output pattern 54:
10000000
# Output pattern 271:
01000000
# Input pattern 272:
0.54 0.56 0.26
# Output pattern 272:
01000000
# Input pattern 273:
0.91 0.19 0.67
# Output pattern 273:
00100000
# Input pattern 274:
0.73 0.11 0.44
# Output pattern 274:
10000000
# Input pattern 275:
0.14 0.21 0.09
# Output pattern 275:
01000000
# Input pattern 276:
0.85 0.88 0.89
# Output pattern 276:
00000001
# Input pattern 277:
0.04 0.13 0.47
# Output pattern 277:
00000001
# Input pattern 278:
0.27 0.21 0.67
# Output pattern 278:
10000000
# Input pattern 279:
0.87 0.58 0.85
# Output pattern 279:
10000000
# Input pattern 280:
0.14 0.26 0.66
# Output pattern 280:
00000001
# Input pattern 281:
0.03 0.03 0.82
# Output pattern 281:
10000000
# Input pattern 282:
0.23 0.55 0.79
# Output pattern 282:
00000001
# Output pattern 499:
01000000
# Input pattern 500:
0.88 0.37 0.98
# Output pattern 500:
00000010
# Input pattern 501:
0.3 0.1 0.29
# Output pattern 501:
10000000
# Input pattern 502:
0.25 0.46 0.42
# Output pattern 502:
00000001
# Input pattern 503:
0.38 0.82 0.6
# Output pattern 503:
00000001
# Input pattern 504:
0.26 0.75 0.79
# Output pattern 504:
00000001
# Input pattern 505:
0.33 0.48 0.06
# Output pattern 505:
01000000
# Input pattern 506:
0.62 0.29 0.94
# Output pattern 506:
00000010
# Input pattern 507:
0.39 0.15 0.98
# Output pattern 507:
00000010
# Input pattern 508:
0.57 0.43 0.87
# Output pattern 508:
10000000
# Input pattern 509:
0.44 0.76 0.2
# Output pattern 509:
01000000
# Input pattern 510:
0.77 0.6 0.34
# Output pattern 510:
01000000
125
# Output pattern 727:
00000010
# Input pattern 728:
0.59 0.95 0.26
# Output pattern 728:
00100000
# Input pattern 729:
0.56 0.31 0.84
# Output pattern 729:
10000000
# Input pattern 730:
0.55 0.79 0.32
# Output pattern 730:
01000000
# Input pattern 731:
0.98 0.01 0.11
# Output pattern 731:
00100000
# Input pattern 732:
0.12 0.36 0.07
# Output pattern 732:
01000000
# Input pattern 733:
0.5 0.54 0.92
# Output pattern 733:
00000010
# Input pattern 734:
0.57 0.43 0.66
# Output pattern 734:
10000000
# Input pattern 735:
0.26 0.13 0.34
# Output pattern 735:
10000000
# Input pattern 736:
0.77 0.77 0.9
# Output pattern 736:
10000000
# Input pattern 737:
0.3 0.22 0.17
# Output pattern 737:
01000000
# Input pattern 738:
0.59 0.74 0.68
# Output pattern 738:
00000001
# Input pattern 55:
0.72 0.67 0.12
# Output pattern 55:
01000000
# Input pattern 56:
0.96 0.14 0.33
# Output pattern 56:
00100000
# Input pattern 57:
0.71 0.81 0.04
# Output pattern 57:
01000000
# Input pattern 58:
0.45 0.27 0.12
# Output pattern 58:
01000000
# Input pattern 59:
0.81 0.06 0.76
# Output pattern 59:
10000000
# Input pattern 60:
0.49 0.77 0.18
# Output pattern 60:
01000000
# Input pattern 61:
0.96 0.34 0.13
# Output pattern 61:
00100000
# Input pattern 62:
0.36 0.33 0.7
# Output pattern 62:
10000000
# Input pattern 63:
0.49 0.61 0.62
# Output pattern 63:
00000001
# Input pattern 64:
0.44 0.99 0.34
# Output pattern 64:
00100000
# Input pattern 65:
0.07 0.77 0.85
# Output pattern 65:
00000001
# Input pattern 66:
0.79 0.82 0.85
# Input pattern 283:
0.51 0.44 0.68
# Output pattern 283:
10000000
# Input pattern 284:
0.1 0.98 0.82
# Output pattern 284:
00000010
# Input pattern 285:
0.5 0.3 0.4
# Output pattern 285:
10000000
# Input pattern 286:
0.02 0.62 0.28
# Output pattern 286:
00000001
# Input pattern 287:
0.01 0.11 0.05
# Output pattern 287:
00000001
# Input pattern 288:
0.57 0.36 0.28
# Output pattern 288:
01000000
# Input pattern 289:
0.17 0.67 0.79
# Output pattern 289:
00000001
# Input pattern 290:
0.7 0.29 0.64
# Output pattern 290:
10000000
# Input pattern 291:
0.47 0.1 0.03
# Output pattern 291:
01000000
# Input pattern 292:
0.73 0.89 0.89
# Output pattern 292:
00000001
# Input pattern 293:
0.04 0.75 0.74
# Output pattern 293:
00000001
# Input pattern 294:
0.13 0.31 0.9
# Input pattern 511:
0.99 0.51 0.32
# Output pattern 511:
00100000
# Input pattern 512:
0.33 0.02 0.24
# Output pattern 512:
10000000
# Input pattern 513:
0.82 0.3 0.76
# Output pattern 513:
10000000
# Input pattern 514:
0.82 0.75 0.4
# Output pattern 514:
01000000
# Input pattern 515:
0.39 0.23 0.86
# Output pattern 515:
10000000
# Input pattern 516:
0.22 0.81 0.39
# Output pattern 516:
00000001
# Input pattern 517:
0.51 0.48 0.24
# Output pattern 517:
01000000
# Input pattern 518:
0.87 0.04 0.63
# Output pattern 518:
10000000
# Input pattern 519:
0.23 0.8 0.02
# Output pattern 519:
01000000
# Input pattern 520:
0.27 0.04 0.74
# Output pattern 520:
10000000
# Input pattern 521:
0.44 0.82 0.91
# Output pattern 521:
00000010
# Input pattern 522:
0.42 0.84 0.41
126
# Input pattern 739:
0.81 0.9 0.93
# Output pattern 739:
00000010
# Input pattern 740:
0.02 0.67 0.67
# Output pattern 740:
00000001
# Input pattern 741:
0.41 0.35 0.17
# Output pattern 741:
01000000
# Input pattern 742:
0.04 0.72 0.49
# Output pattern 742:
00000001
# Input pattern 743:
0.55 0.06 0.9
# Output pattern 743:
10000000
# Input pattern 744:
0.35 0.8 0.79
# Output pattern 744:
00000001
# Input pattern 745:
0.09 0.88 0.51
# Output pattern 745:
00000001
# Input pattern 746:
0.15 0.41 0.19
# Output pattern 746:
00000001
# Input pattern 747:
0.51 0.56 0.51
# Output pattern 747:
00100000
# Input pattern 748:
0.01 0.55 0.85
# Output pattern 748:
00000001
# Input pattern 749:
0.38 0.94 0.41
# Output pattern 749:
00000010
# Input pattern 750:
0.47 0.11 0.46
# Output pattern 66:
00000001
# Input pattern 67:
0.99 0.69 0.37
# Output pattern 67:
00100000
# Input pattern 68:
0.03 0.43 0.15
# Output pattern 68:
00000001
# Input pattern 69:
0.44 0.69 0.62
# Output pattern 69:
00000001
# Input pattern 70:
0.37 0.12 0.41
# Output pattern 70:
10000000
# Input pattern 71:
0.38 0.24 0
# Output pattern 71:
01000000
# Input pattern 72:
1 0.75 0.04
# Output pattern 72:
00100000
# Input pattern 73:
0.62 0.65 0.45
# Output pattern 73:
01000000
# Input pattern 74:
0.54 0.73 0.19
# Output pattern 74:
01000000
# Input pattern 75:
0.35 0.08 0.25
# Output pattern 75:
10000000
# Input pattern 76:
0.04 0.97 0.18
# Output pattern 76:
00000010
# Input pattern 77:
0.04 0.31 0.49
# Output pattern 77:
00000001
# Output pattern 294:
00000001
# Input pattern 295:
0.6 0.07 0.58
# Output pattern 295:
10000000
# Input pattern 296:
0.99 0.36 0.57
# Output pattern 296:
00100000
# Input pattern 297:
0.17 0.67 0.69
# Output pattern 297:
00000001
# Input pattern 298:
0.25 0.81 0.62
# Output pattern 298:
00000001
# Input pattern 299:
0.59 0.53 0.55
# Output pattern 299:
10000000
# Input pattern 300:
0.26 0.33 0.36
# Output pattern 300:
00000001
# Input pattern 301:
0.61 0.08 0.73
# Output pattern 301:
10000000
# Input pattern 302:
0.11 0.08 0.94
# Output pattern 302:
00000010
# Input pattern 303:
0.17 0.04 0.32
# Output pattern 303:
10000000
# Input pattern 304:
0.64 0.25 0.05
# Output pattern 304:
01000000
# Input pattern 305:
0.11 0.99 0.5
# Output pattern 305:
00000010
# Output pattern 522:
01000000
# Input pattern 523:
0.48 0.02 0.28
# Output pattern 523:
10000000
# Input pattern 524:
0.84 0.78 0.52
# Output pattern 524:
01000000
# Input pattern 525:
0.74 0.83 0.69
# Output pattern 525:
01000000
# Input pattern 526:
0.91 0.79 0.42
# Output pattern 526:
00100000
# Input pattern 527:
0.63 0.51 0.38
# Output pattern 527:
01000000
# Input pattern 528:
0.73 0.91 0.85
# Output pattern 528:
00000010
# Input pattern 529:
0.1 0.65 0.7
# Output pattern 529:
00000001
# Input pattern 530:
0.24 0.63 0.64
# Output pattern 530:
00000001
# Input pattern 531:
0.96 0.99 0.51
# Output pattern 531:
00100000
# Input pattern 532:
0.53 0.11 0.77
# Output pattern 532:
10000000
# Input pattern 533:
0.2 0.22 0.04
# Output pattern 533:
01000000
127
# Output pattern 750:
10000000
# Input pattern 751:
0.65 0.04 0.45
# Output pattern 751:
10000000
# Input pattern 752:
0.61 0.44 0.03
# Output pattern 752:
01000000
# Input pattern 753:
0.21 0.91 0.85
# Output pattern 753:
00000011
# Input pattern 754:
0.2 0.21 0.62
# Output pattern 754:
00000001
# Input pattern 755:
0.6 0.66 0.22
# Output pattern 755:
01000000
# Input pattern 756:
0.12 0.83 0.69
# Output pattern 756:
00000001
# Input pattern 757:
0.79 0.32 0.72
# Output pattern 757:
10000000
# Input pattern 758:
0.55 0.48 0.52
# Output pattern 758:
10000000
# Input pattern 759:
0.07 0.1 0.83
# Output pattern 759:
00000001
# Input pattern 760:
0.84 0.33 0.09
# Output pattern 760:
01000000
# Input pattern 761:
0.28 0.54 0.25
# Output pattern 761:
01000000
# Input pattern 78:
0.19 0.25 0.41
# Output pattern 78:
00000001
# Input pattern 79:
0.88 0.16 0.01
# Output pattern 79:
01000000
# Input pattern 80:
0.1 0.78 0.31
# Output pattern 80:
00000001
# Input pattern 81:
0.96 0.88 0.25
# Output pattern 81:
00100000
# Input pattern 82:
0.1 0.04 0.93
# Output pattern 82:
00000010
# Input pattern 83:
0.49 0.52 0.25
# Output pattern 83:
01000000
# Input pattern 84:
0.64 0.18 0.73
# Output pattern 84:
10000000
# Input pattern 85:
0.32 0.98 0.72
# Output pattern 85:
00000010
# Input pattern 86:
0.87 0.03 0.94
# Output pattern 86:
00000010
# Input pattern 87:
0.96 0.5 0.18
# Output pattern 87:
00100000
# Input pattern 88:
0.29 0.77 0.75
# Output pattern 88:
00000001
# Input pattern 89:
0.39 0.58 0.61
# Input pattern 306:
0.57 0.48 0.09
# Output pattern 306:
01000000
# Input pattern 307:
0.6 0.49 0.7
# Output pattern 307:
10000000
# Input pattern 308:
0.58 0.66 0.89
# Output pattern 308:
00000001
# Input pattern 309:
0.33 0.56 0.8
# Output pattern 309:
00000001
# Input pattern 310:
0.04 0.76 0.99
# Output pattern 310:
00000010
# Input pattern 311:
0.36 0.82 0.11
# Output pattern 311:
01000000
# Input pattern 312:
0.63 0.19 0.66
# Output pattern 312:
10000000
# Input pattern 313:
0.67 0.31 0.11
# Output pattern 313:
01000000
# Input pattern 314:
0.78 0.31 0.44
# Output pattern 314:
10000000
# Input pattern 315:
0.4 0.32 0.12
# Output pattern 315:
01000000
# Input pattern 316:
0.66 0.98 0.48
# Output pattern 316:
00100000
# Input pattern 317:
0.24 0.9 0.41
# Input pattern 534:
0.12 0.38 0.08
# Output pattern 534:
01000000
# Input pattern 535:
0.47 0.3 0.8
# Output pattern 535:
10000000
# Input pattern 536:
0.07 0.13 0.14
# Output pattern 536:
00000001
# Input pattern 537:
0.5 0.8 0.81
# Output pattern 537:
00000001
# Input pattern 538:
0.38 0.04 0.56
# Output pattern 538:
10000000
# Input pattern 539:
0.9 0.58 0.76
# Output pattern 539:
10000000
# Input pattern 540:
0.15 0.85 0.53
# Output pattern 540:
00000001
# Input pattern 541:
0.9 0.98 0.71
# Output pattern 541:
00100000
# Input pattern 542:
0.63 0.85 0.81
# Output pattern 542:
00000001
# Input pattern 543:
0.01 0.01 0.09
# Output pattern 543:
10000000
# Input pattern 544:
0.74 0.82 0.94
# Output pattern 544:
00000010
# Input pattern 545:
0.82 0.02 0.67
128
# Input pattern 762:
0.01 0.56 0.46
# Output pattern 762:
00000001
# Input pattern 763:
0.49 0.49 0.07
# Output pattern 763:
01000000
# Input pattern 764:
0.44 0.51 0.97
# Output pattern 764:
00000010
# Input pattern 765:
0.21 0.29 0.81
# Output pattern 765:
00000001
# Input pattern 766:
0.35 0.55 0.65
# Output pattern 766:
00000001
# Input pattern 767:
0.66 0.21 0.59
# Output pattern 767:
10000000
# Input pattern 768:
0.58 0.9 0.53
# Output pattern 768:
01000000
# Input pattern 769:
0.76 0.71 0.89
# Output pattern 769:
10000000
# Input pattern 770:
0.24 0.81 0.58
# Output pattern 770:
00000001
# Input pattern 771:
0.4 0.29 0.8
# Output pattern 771:
10000000
# Input pattern 772:
0.4 0.23 0.26
# Output pattern 772:
10000000
# Input pattern 773:
0.35 0.02 0.69
# Output pattern 89:
00000001
# Input pattern 90:
0.57 0.52 0.77
# Output pattern 90:
10000000
# Input pattern 91:
0.65 0.81 0.4
# Output pattern 91:
01000000
# Input pattern 92:
0.43 0.29 0.26
# Output pattern 92:
01000000
# Input pattern 93:
0.01 0.49 0.92
# Output pattern 93:
00000010
# Input pattern 94:
0.06 0.7 0.06
# Output pattern 94:
01000000
# Input pattern 95:
0.27 0.7 0.02
# Output pattern 95:
01000000
# Input pattern 96:
0.21 0.74 0.6
# Output pattern 96:
00000001
# Input pattern 97:
0.68 0.82 0.62
# Output pattern 97:
01000000
# Input pattern 98:
0.1 0.96 0.08
# Output pattern 98:
00100000
# Input pattern 99:
0.29 0.4 0.15
# Output pattern 99:
01000000
# Input pattern 100:
0.32 0.97 0.72
# Output pattern 100:
00000010
# Output pattern 317:
00000001
# Input pattern 318:
0.01 0.38 0.53
# Output pattern 318:
00000001
# Input pattern 319:
0.48 0.29 0.82
# Output pattern 319:
10000000
# Input pattern 320:
0.07 0.34 0.4
# Output pattern 320:
00000001
# Input pattern 321:
0.26 1 0
# Output pattern 321:
00100000
# Input pattern 322:
0.23 0.65 0.21
# Output pattern 322:
01000000
# Input pattern 323:
0.34 0.2 0.1
# Output pattern 323:
01000000
# Input pattern 324:
0.61 0.18 0.61
# Output pattern 324:
10000000
# Input pattern 325:
0.06 0.44 0.63
# Output pattern 325:
00000001
# Input pattern 326:
0.07 0.26 0.02
# Output pattern 326:
01000000
# Input pattern 327:
0.75 0.98 0.06
# Output pattern 327:
00100000
# Input pattern 328:
0.1 0.95 0.57
# Output pattern 328:
00000010
# Output pattern 545:
10000000
# Input pattern 546:
0.16 0.3 0.65
# Output pattern 546:
00000001
# Input pattern 547:
0.58 0.44 0.09
# Output pattern 547:
01000000
# Input pattern 548:
0.43 0.12 0.55
# Output pattern 548:
10000000
# Input pattern 549:
0.47 0.42 0.02
# Output pattern 549:
01000000
# Input pattern 550:
0.67 0.19 0.22
# Output pattern 550:
10000000
# Input pattern 551:
0.09 0.9 0.7
# Output pattern 551:
00000001
# Input pattern 552:
0.73 0.54 0.39
# Output pattern 552:
01000000
# Input pattern 553:
0.83 0.54 0.12
# Output pattern 553:
01000000
# Input pattern 554:
0.91 0.35 0.88
# Output pattern 554:
00100000
# Input pattern 555:
0.5 0.09 0.14
# Output pattern 555:
10000000
# Input pattern 556:
0.23 0.48 0.94
# Output pattern 556:
00000010
129
# Output pattern 773:
10000000
# Input pattern 774:
0.98 0.04 0.85
# Output pattern 774:
00100000
# Input pattern 775:
0.71 0.07 0.57
# Output pattern 775:
10000000
# Input pattern 776:
0.05 0.91 0.15
# Output pattern 776:
00000010
# Input pattern 777:
0.69 0.93 0.21
# Output pattern 777:
00100000
# Input pattern 778:
0.41 0.51 0.71
# Output pattern 778:
00000001
# Input pattern 779:
0.21 0.46 0.22
# Output pattern 779:
00000001
# Input pattern 780:
0.68 0.55 0.82
# Output pattern 780:
10000000
# Input pattern 781:
0.02 0.65 0.37
# Output pattern 781:
00000001
# Input pattern 782:
0.02 0.47 0.71
# Output pattern 782:
00000001
# Input pattern 783:
0.72 0.29 0.42
# Output pattern 783:
10000000
# Input pattern 784:
0.8 0.61 0.71
# Output pattern 784:
10000000
# Input pattern 101:
0.37 0.39 0.99
# Output pattern 101:
00000010
# Input pattern 102:
0.7 0.91 0.77
# Output pattern 102:
00000010
# Input pattern 103:
0.44 0.99 0.16
# Output pattern 103:
00100000
# Input pattern 104:
0.94 0.57 0.04
# Output pattern 104:
00100000
# Input pattern 105:
0.99 0.33 0.37
# Output pattern 105:
00100000
# Input pattern 106:
0.67 0.4 0.19
# Output pattern 106:
01000000
# Input pattern 107:
0.7 0.61 0.82
# Output pattern 107:
10000000
# Input pattern 108:
0.22 0.68 0.35
# Output pattern 108:
00000001
# Input pattern 109:
0.62 0.22 0.9
# Output pattern 109:
10000000
# Input pattern 110:
0.78 0.89 0.3
# Output pattern 110:
01000000
# Input pattern 111:
0.37 0.3 0.57
# Output pattern 111:
10000000
# Input pattern 112:
0.68 0.78 0.23
# Input pattern 329:
0.35 0.95 0.34
# Output pattern 329:
00100000
# Input pattern 330:
0.12 0.8 0.69
# Output pattern 330:
00000001
# Input pattern 331:
0.72 0.44 0.68
# Output pattern 331:
10000000
# Input pattern 332:
0.83 0.21 0.67
# Output pattern 332:
10000000
# Input pattern 333:
0.71 0.18 0.81
# Output pattern 333:
10000000
# Input pattern 334:
0.03 0 0.85
# Output pattern 334:
10000000
# Input pattern 335:
0.41 0.57 0.68
# Output pattern 335:
00000001
# Input pattern 336:
0.89 0.15 0.66
# Output pattern 336:
10000000
# Input pattern 337:
0.82 0.09 0.97
# Output pattern 337:
00000010
# Input pattern 338:
0.95 0.54 0.45
# Output pattern 338:
00100000
# Input pattern 339:
0.44 0.57 0.56
# Output pattern 339:
00000001
# Input pattern 340:
0.97 0.48 0.45
# Input pattern 557:
0.75 0.71 0.26
# Output pattern 557:
01000000
# Input pattern 558:
0.96 0.47 0.78
# Output pattern 558:
00100000
# Input pattern 559:
0.05 0.91 0.91
# Output pattern 559:
00000010
# Input pattern 560:
0.66 0.09 0.51
# Output pattern 560:
10000000
# Input pattern 561:
0.41 0.79 0.35
# Output pattern 561:
01000000
# Input pattern 562:
0.42 0.71 0.3
# Output pattern 562:
01000000
# Input pattern 563:
0.12 0.56 0.04
# Output pattern 563:
01000000
# Input pattern 564:
0.19 0.47 0.4
# Output pattern 564:
00000001
# Input pattern 565:
0.5 0.57 0.33
# Output pattern 565:
01000000
# Input pattern 566:
0.87 0.14 0.97
# Output pattern 566:
00000010
# Input pattern 567:
0.2 0.11 0.77
# Output pattern 567:
10000000
# Input pattern 568:
0.39 0.51 0.23
130
# Input pattern 785:
0.39 0.65 0.22
# Output pattern 785:
01000000
# Input pattern 786:
0.85 0.06 0.31
# Output pattern 786:
10000000
# Input pattern 787:
0.85 0.36 0.48
# Output pattern 787:
10000000
# Input pattern 788:
0.84 0.05 0.41
# Output pattern 788:
10000000
# Input pattern 789:
0.39 0.79 0.41
# Output pattern 789:
00000001
# Input pattern 790:
0.05 0.1 0.42
# Output pattern 790:
00000001
# Input pattern 791:
0.05 0.39 0.21
# Output pattern 791:
00000001
# Input pattern 792:
0.5 0.18 0.54
# Output pattern 792:
10000000
# Input pattern 793:
0.66 0.22 0.7
# Output pattern 793:
10000000
# Input pattern 794:
0.23 0.56 0.1
# Output pattern 794:
01000000
# Input pattern 795:
0.2 0.42 0.04
# Output pattern 795:
01000000
# Input pattern 796:
0.67 0.04 0.14
# Output pattern 112:
01000000
# Input pattern 113:
0.89 0.46 0.81
# Output pattern 113:
10000000
# Input pattern 114:
0.1 0.23 0.31
# Output pattern 114:
00000001
# Input pattern 115:
0.45 0.12 0.79
# Output pattern 115:
10000000
# Input pattern 116:
0.16 0.13 0.87
# Output pattern 116:
10000000
# Input pattern 117:
0.71 0.6 0.37
# Output pattern 117:
01000000
# Input pattern 118:
0.2 0.44 0.69
# Output pattern 118:
00000001
# Input pattern 119:
0.03 0.14 0.54
# Output pattern 119:
00000001
# Input pattern 120:
0.31 0.29 0.25
# Output pattern 120:
01000000
# Input pattern 121:
0.75 0.55 0.57
# Output pattern 121:
10000000
# Input pattern 122:
0.8 0.02 0.67
# Output pattern 122:
10000000
# Input pattern 123:
0.09 0.34 0.55
# Output pattern 123:
00000001
# Output pattern 340:
00100000
# Input pattern 341:
0.32 0.07 0.26
# Output pattern 341:
10000000
# Input pattern 342:
0.44 0.87 0.4
# Output pattern 342:
01000000
# Input pattern 343:
0.77 0.06 0.59
# Output pattern 343:
10000000
# Input pattern 344:
0.43 0.35 0.63
# Output pattern 344:
10000000
# Input pattern 345:
0.04 0.43 0.76
# Output pattern 345:
00000001
# Input pattern 346:
0.63 0.94 0.26
# Output pattern 346:
00100000
# Input pattern 347:
0.99 0.96 0.58
# Output pattern 347:
00100000
# Input pattern 348:
0.67 0.41 0
# Output pattern 348:
01000000
# Input pattern 349:
0.63 0.46 0.52
# Output pattern 349:
10000000
# Input pattern 350:
0.17 0.84 0.21
# Output pattern 350:
00000001
# Input pattern 351:
0.81 0.78 0.28
# Output pattern 351:
01000000
# Output pattern 568:
01000000
# Input pattern 569:
0.06 0.33 0.57
# Output pattern 569:
00000001
# Input pattern 570:
0.21 0.35 0.75
# Output pattern 570:
00000001
# Input pattern 571:
0.8 0.98 0.72
# Output pattern 571:
00100000
# Input pattern 572:
0.14 0.1 0.82
# Output pattern 572:
10000000
# Input pattern 573:
0.66 0.21 0.54
# Output pattern 573:
10000000
# Input pattern 574:
0.05 0.49 0.17
# Output pattern 574:
00000001
# Input pattern 575:
0.2 0.22 0.2
# Output pattern 575:
00100000
# Input pattern 576:
0.42 0.09 0.3
# Output pattern 576:
10000000
# Input pattern 577:
0.6 0.33 0.24
# Output pattern 577:
01000000
# Input pattern 578:
0.33 0.87 0.55
# Output pattern 578:
00000001
# Input pattern 579:
0.86 0.65 0.33
# Output pattern 579:
01000000
131
# Output pattern 796:
10000000
# Input pattern 797:
0.22 0.93 0.05
# Output pattern 797:
00100000
# Input pattern 798:
0.21 0 0.42
# Output pattern 798:
10000000
# Input pattern 799:
0.26 0.14 0.6
# Output pattern 799:
10000000
# Input pattern 800:
0.93 0.16 0.34
# Output pattern 800:
00100000
# Input pattern 801:
0.38 0.39 0.72
# Output pattern 801:
00000001
# Input pattern 802:
0.01 0.37 0.66
# Output pattern 802:
00000001
# Input pattern 803:
0.14 0.25 0.1
# Output pattern 803:
01000000
# Input pattern 804:
0.02 1 0.71
# Output pattern 804:
00000010
# Input pattern 805:
0.29 0.55 0.72
# Output pattern 805:
00000001
# Input pattern 806:
0.69 0.93 0.41
# Output pattern 806:
00100000
# Input pattern 807:
0.31 0.2 0.74
# Output pattern 807:
10000000
# Input pattern 124:
0.19 0.53 0.9
# Output pattern 124:
00000001
# Input pattern 125:
0.64 0.45 0.71
# Output pattern 125:
10000000
# Input pattern 126:
0.11 0.93 0.08
# Output pattern 126:
00100000
# Input pattern 127:
0.01 0.13 0.26
# Output pattern 127:
00000001
# Input pattern 128:
0.22 0.46 0.33
# Output pattern 128:
00000001
# Input pattern 129:
0.68 0.01 0.45
# Output pattern 129:
10000000
# Input pattern 130:
0.12 0.17 0.47
# Output pattern 130:
00000001
# Input pattern 131:
0.89 0.96 0.36
# Output pattern 131:
00100000
# Input pattern 132:
0.15 0.75 0.64
# Output pattern 132:
00000001
# Input pattern 133:
0.68 0.74 0.6
# Output pattern 133:
01000000
# Input pattern 134:
0.62 0.04 0.96
# Output pattern 134:
00000010
# Input pattern 135:
0.25 0.99 0.15
# Input pattern 352:
0.91 0.02 0.99
# Output pattern 352:
00001000
# Input pattern 353:
0.87 0.24 0.39
# Output pattern 353:
10000000
# Input pattern 354:
0.67 0.78 0.86
# Output pattern 354:
00000001
# Input pattern 355:
0.04 0.82 0.33
# Output pattern 355:
00000001
# Input pattern 356:
0.29 0.22 0.52
# Output pattern 356:
10000000
# Input pattern 357:
0.24 0.98 0.5
# Output pattern 357:
00000010
# Input pattern 358:
0.04 0.52 0.02
# Output pattern 358:
01000000
# Input pattern 359:
0.54 0.95 0.12
# Output pattern 359:
00100000
# Input pattern 360:
0.02 0.73 0.99
# Output pattern 360:
00000010
# Input pattern 361:
0.55 0.77 0.24
# Output pattern 361:
01000000
# Input pattern 362:
0.17 0.37 0.95
# Output pattern 362:
00000010
# Input pattern 363:
0.86 0.94 0.46
# Input pattern 580:
0.43 0.57 0.42
# Output pattern 580:
01000000
# Input pattern 581:
0.57 0.86 0.77
# Output pattern 581:
00000001
# Input pattern 582:
0.38 0.08 0.14
# Output pattern 582:
10000000
# Input pattern 583:
0.75 0.88 0.52
# Output pattern 583:
01000000
# Input pattern 584:
0.28 0.09 0.48
# Output pattern 584:
10000000
# Input pattern 585:
0.01 0.38 0.77
# Output pattern 585:
00000001
# Input pattern 586:
0.69 0.44 0.73
# Output pattern 586:
10000000
# Input pattern 587:
0.26 0.92 0.34
# Output pattern 587:
00000010
# Input pattern 588:
0.76 0.35 0.96
# Output pattern 588:
00000010
# Input pattern 589:
0.2 0.92 0.14
# Output pattern 589:
00100000
# Input pattern 590:
0.24 0.63 0.96
# Output pattern 590:
00000010
# Input pattern 591:
0.25 0.71 0.35
132
# Input pattern 808:
0.5 0.36 0.89
# Output pattern 808:
10000000
# Input pattern 809:
0.51 0.71 0.18
# Output pattern 809:
01000000
# Input pattern 810:
0.52 0.83 0.51
# Output pattern 810:
01000000
# Input pattern 811:
0.74 0.14 0.47
# Output pattern 811:
10000000
# Input pattern 812:
0.51 0.25 0.46
# Output pattern 812:
10000000
# Input pattern 813:
0.61 0.88 0.61
# Output pattern 813:
00100000
# Input pattern 814:
0.49 0.45 0.28
# Output pattern 814:
01000000
# Input pattern 815:
0.24 0.39 0.59
# Output pattern 815:
00000001
# Input pattern 816:
0.58 0.25 0.65
# Output pattern 816:
10000000
# Input pattern 817:
0.3 0.22 0.29
# Output pattern 817:
10000000
# Input pattern 818:
0.84 0.09 0.88
# Output pattern 818:
10000000
# Input pattern 819:
0.33 0.66 0.69
# Output pattern 135:
00100000
# Input pattern 136:
0.43 0.28 0.33
# Output pattern 136:
10000000
# Input pattern 137:
0.89 0.96 0.15
# Output pattern 137:
00100000
# Input pattern 138:
0.86 0.13 0.97
# Output pattern 138:
00000010
# Input pattern 139:
0.26 0.07 0.9
# Output pattern 139:
10000000
# Input pattern 140:
0.41 0.16 0.63
# Output pattern 140:
10000000
# Input pattern 141:
0.73 0.36 0.91
# Output pattern 141:
00000010
# Input pattern 142:
0.93 0.33 0.76
# Output pattern 142:
00100000
# Input pattern 143:
0.01 0.88 0.12
# Output pattern 143:
00000001
# Input pattern 144:
0.35 0.8 0.41
# Output pattern 144:
00000001
# Input pattern 145:
0.91 0.26 0.69
# Output pattern 145:
00100000
# Input pattern 146:
0.42 0.33 0.4
# Output pattern 146:
10000000
# Output pattern 363:
00100000
# Input pattern 364:
0.74 0.46 0.75
# Output pattern 364:
10000000
# Input pattern 365:
0.49 0.18 0.73
# Output pattern 365:
10000000
# Input pattern 366:
0.64 0.33 0.23
# Output pattern 366:
01000000
# Input pattern 367:
0.6 0.84 0.75
# Output pattern 367:
00000001
# Input pattern 368:
0.68 0.82 0.23
# Output pattern 368:
01000000
# Input pattern 369:
0.14 0.73 0.36
# Output pattern 369:
00000001
# Input pattern 370:
0.81 0.31 0.04
# Output pattern 370:
01000000
# Input pattern 371:
0.23 0.82 0.18
# Output pattern 371:
01000000
# Input pattern 372:
0.47 0.65 0.91
# Output pattern 372:
00000010
# Input pattern 373:
0.39 0.76 0.91
# Output pattern 373:
00000010
# Input pattern 374:
0.12 0.55 0.41
# Output pattern 374:
00000001
# Output pattern 591:
00000001
# Input pattern 592:
0.31 0.15 0.43
# Output pattern 592:
10000000
# Input pattern 593:
0.89 0.01 0.6
# Output pattern 593:
10000000
# Input pattern 594:
0.18 0.25 0.5
# Output pattern 594:
00000001
# Input pattern 595:
0.52 0.35 0.56
# Output pattern 595:
10000000
# Input pattern 596:
0.3 0.03 0.39
# Output pattern 596:
10000000
# Input pattern 597:
0.01 0.4 0.96
# Output pattern 597:
00000010
# Input pattern 598:
0.24 0.63 0.92
# Output pattern 598:
00000010
# Input pattern 599:
0.59 0.81 0.35
# Output pattern 599:
01000000
# Input pattern 600:
0.01 0.97 0.24
# Output pattern 600:
00000010
# Input pattern 601:
0.85 0.93 0.03
# Output pattern 601:
00100000
# Input pattern 602:
0.66 0.5 0.56
# Output pattern 602:
10000000
133
# Output pattern 819:
00000001
# Input pattern 820:
0.02 0.97 0.89
# Output pattern 820:
00000010
# Input pattern 821:
0.25 0.77 0.43
# Output pattern 821:
00000001
# Input pattern 822:
0.41 0.16 0.53
# Output pattern 822:
10000000
# Input pattern 823:
0.45 0.61 0.98
# Output pattern 823:
00000010
# Input pattern 824:
0.66 0.62 0.85
# Output pattern 824:
10000000
# Input pattern 825:
0.76 0.27 0.35
# Output pattern 825:
10000000
# Input pattern 826:
0.19 0.91 0.43
# Output pattern 826:
00000010
# Input pattern 827:
0.27 0.15 0.78
# Output pattern 827:
10000000
# Input pattern 828:
0.05 0.91 0.1
# Output pattern 828:
00000010
# Input pattern 829:
0.82 0.23 0.76
# Output pattern 829:
10000000
# Input pattern 830:
0.73 0.34 0.25
# Output pattern 830:
01000000
# Input pattern 147:
0.16 0.3 0.1
# Output pattern 147:
01000000
# Input pattern 148:
0.25 0.21 0.82
# Output pattern 148:
10000000
# Input pattern 149:
0.82 0 0.46
# Output pattern 149:
10000000
# Input pattern 150:
0.01 0.14 0.19
# Output pattern 150:
00000001
# Input pattern 151:
0.98 0.58 0.13
# Output pattern 151:
00100000
# Input pattern 152:
0.1 0.69 0.8
# Output pattern 152:
00000001
# Input pattern 153:
0.16 0.57 0.71
# Output pattern 153:
00000001
# Input pattern 154:
0.57 0.7 0.67
# Output pattern 154:
00000001
# Input pattern 155:
0.56 0.34 0.48
# Output pattern 155:
10000000
# Input pattern 156:
0.6 0.29 0.5
# Output pattern 156:
10000000
# Input pattern 157:
0.17 0.53 0.15
# Output pattern 157:
01000000
# Input pattern 158:
0.06 0.75 0.75
# Input pattern 375:
0.94 0.89 0.29
# Output pattern 375:
00100000
# Input pattern 376:
0.21 0.84 0.94
# Output pattern 376:
00000010
# Input pattern 377:
0.74 0.43 0.47
# Output pattern 377:
10000000
# Input pattern 378:
0.3 0.57 0.22
# Output pattern 378:
01000000
# Input pattern 379:
0.31 0.24 0.34
# Output pattern 379:
10000000
# Input pattern 380:
0.26 0.63 0.4
# Output pattern 380:
00000001
# Input pattern 381:
0.25 0.21 0.34
# Output pattern 381:
10000000
# Input pattern 382:
0.9 0.88 0.93
# Output pattern 382:
00000010
# Input pattern 383:
0.41 0.7 0.26
# Output pattern 383:
01000000
# Input pattern 384:
0.32 0.51 0.82
# Output pattern 384:
00000001
# Input pattern 385:
0.54 0.18 0.93
# Output pattern 385:
00000010
# Input pattern 386:
0.84 0.62 0.44
# Input pattern 603:
0.86 0.47 0.84
# Output pattern 603:
10000000
# Input pattern 604:
0.96 0.34 0.09
# Output pattern 604:
00100000
# Input pattern 605:
0.81 0.91 0.62
# Output pattern 605:
00100000
# Input pattern 606:
0.64 0.19 0.11
# Output pattern 606:
01000000
# Input pattern 607:
0.77 0.7 0.64
# Output pattern 607:
01000000
# Input pattern 608:
0.21 0.19 0.19
# Output pattern 608:
10000000
# Input pattern 609:
0.85 0.98 0.63
# Output pattern 609:
00100000
# Input pattern 610:
0.03 0.78 0.98
# Output pattern 610:
00000010
# Input pattern 611:
0.58 0.9 0
# Output pattern 611:
01000000
# Input pattern 612:
0.78 0.88 0.76
# Output pattern 612:
01000000
# Input pattern 613:
0.53 0.37 0.32
# Output pattern 613:
01000000
# Input pattern 614:
0.57 0.58 0.61
134
# Input pattern 831:
0.18 0.39 0.58
# Output pattern 831:
00000001
# Input pattern 832:
0.2 0.83 0.51
# Output pattern 832:
00000001
# Input pattern 833:
0.81 0.12 0.03
# Output pattern 833:
01000000
# Input pattern 834:
0.93 0.29 0.62
# Output pattern 834:
00100000
# Input pattern 835:
0.21 0.64 0.36
# Output pattern 835:
00000001
# Input pattern 836:
0.37 0.43 0.46
# Output pattern 836:
00000001
# Input pattern 837:
0.6 0.15 0.62
# Output pattern 837:
10000000
# Input pattern 838:
0.57 0.69 0.82
# Output pattern 838:
00000001
# Input pattern 839:
0.72 0.36 0.61
# Output pattern 839:
10000000
# Input pattern 840:
0.07 0.71 0.58
# Output pattern 840:
00000001
# Input pattern 841:
0.7 0.8 0.6
# Output pattern 841:
01000000
# Input pattern 842:
0.53 0.6 0.64
# Output pattern 158:
00000001
# Input pattern 159:
0.97 0.92 0.99
# Output pattern 159:
00001000
# Input pattern 160:
0.4 0.66 0.91
# Output pattern 160:
00000010
# Input pattern 161:
0.11 0.93 0.85
# Output pattern 161:
00000010
# Input pattern 162:
0.53 0.96 0.37
# Output pattern 162:
00100000
# Input pattern 163:
0.38 0.14 0.44
# Output pattern 163:
10000000
# Input pattern 164:
0.52 0.69 0.26
# Output pattern 164:
01000000
# Input pattern 165:
0.74 0.98 0.96
# Output pattern 165:
00000010
# Input pattern 166:
0.01 0.19 0.25
# Output pattern 166:
00000001
# Input pattern 167:
0.89 0.21 0.12
# Output pattern 167:
01000000
# Input pattern 168:
0.67 0.02 0.08
# Output pattern 168:
10000000
# Input pattern 169:
0.7 0.47 0.62
# Output pattern 169:
10000000
# Output pattern 386:
01000000
# Input pattern 387:
0.99 0.33 0.82
# Output pattern 387:
00100000
# Input pattern 388:
0.73 0.66 0.02
# Output pattern 388:
01000000
# Input pattern 389:
0.49 0.99 0.63
# Output pattern 389:
00000010
# Input pattern 390:
0.99 0.39 0.29
# Output pattern 390:
00100000
# Input pattern 391:
0.3 0.81 0.15
# Output pattern 391:
01000000
# Input pattern 392:
0.44 0.51 0.4
# Output pattern 392:
01000000
# Input pattern 393:
0.04 0.86 0.77
# Output pattern 393:
00000001
# Input pattern 394:
0.59 0.09 0.43
# Output pattern 394:
10000000
# Input pattern 395:
0.24 0.62 0.66
# Output pattern 395:
00000001
# Input pattern 396:
0.05 0.69 0.94
# Output pattern 396:
00000010
# Input pattern 397:
0.52 0.78 0.39
# Output pattern 397:
01000000
# Output pattern 614:
00000001
# Input pattern 615:
0.8 0.49 0
# Output pattern 615:
01000000
# Input pattern 616:
0.3 0.87 0.74
# Output pattern 616:
00000001
# Input pattern 617:
0.05 0.82 0.43
# Output pattern 617:
00000001
# Input pattern 618:
0.33 0.53 0.49
# Output pattern 618:
00000001
# Input pattern 619:
0.44 0.89 0.17
# Output pattern 619:
01000000
# Input pattern 620:
0.43 0.81 0.26
# Output pattern 620:
01000000
# Input pattern 621:
0.61 0.54 0.93
# Output pattern 621:
00000010
# Input pattern 622:
0.72 0.82 0.9
# Output pattern 622:
00000001
# Input pattern 623:
0.69 0.1 0.36
# Output pattern 623:
10000000
# Input pattern 624:
0.18 0.36 0.16
# Output pattern 624:
01000000
# Input pattern 625:
0.37 0.61 0.36
# Output pattern 625:
01000000
135
# Output pattern 842:
00000001
# Input pattern 843:
0.57 0.19 0.39
# Output pattern 843:
10000000
# Input pattern 844:
0.04 0.58 0.89
# Output pattern 844:
00000001
# Input pattern 845:
0.73 0.58 0.54
# Output pattern 845:
01000000
# Input pattern 846:
0.1 0.49 0.58
# Output pattern 846:
00000001
# Input pattern 847:
0.64 0.35 0.13
# Output pattern 847:
01000000
# Input pattern 848:
0.06 0.18 0.02
# Output pattern 848:
01000000
# Input pattern 849:
0.56 0.31 0.94
# Output pattern 849:
00000010
# Input pattern 850:
0.74 0.26 0.76
# Output pattern 850:
10000000
# Input pattern 851:
0.58 0.75 0.97
# Output pattern 851:
00000010
# Input pattern 852:
0.47 0.38 0.12
# Output pattern 852:
01000000
# Input pattern 853:
0.69 0.03 0.08
# Output pattern 853:
10000000
# Input pattern 170:
0.93 0.19 0.76
# Output pattern 170:
00100000
# Input pattern 171:
0.23 0.99 0.73
# Output pattern 171:
00000010
# Input pattern 172:
0.37 0.56 0.93
# Output pattern 172:
00000010
# Input pattern 173:
0.7 0.2 0.38
# Output pattern 173:
10000000
# Input pattern 174:
0.05 0.09 0.27
# Output pattern 174:
00000001
# Input pattern 175:
0.1 0.14 0.07
# Output pattern 175:
01000000
# Input pattern 176:
0.81 0.38 0.66
# Output pattern 176:
10000000
# Input pattern 177:
0.25 0.53 0.85
# Output pattern 177:
00000001
# Input pattern 178:
0.9 0.74 0.7
# Output pattern 178:
01000000
# Input pattern 179:
0.44 0.69 0.97
# Output pattern 179:
00000010
# Input pattern 180:
0.6 0.24 0.32
# Output pattern 180:
10000000
# Input pattern 181:
0.76 0.93 0.78
# Input pattern 398:
0.64 0.54 0.7
# Output pattern 398:
10000000
# Input pattern 399:
0.53 0.83 0.9
# Output pattern 399:
00000001
# Input pattern 400:
0.38 0.64 0.9
# Output pattern 400:
00000001
# Input pattern 401:
0.09 0.77 0.06
# Output pattern 401:
01000000
# Input pattern 402:
0.64 0.82 0.11
# Output pattern 402:
01000000
# Input pattern 403:
0.43 0.41 0.52
# Output pattern 403:
10000000
# Input pattern 404:
0.04 0.57 0.26
# Output pattern 404:
00000001
# Input pattern 405:
0.12 0.9 0.51
# Output pattern 405:
00000001
# Input pattern 406:
0.29 0.21 0.89
# Output pattern 406:
10000000
# Input pattern 407:
0.31 0.9 0.28
# Output pattern 407:
01000000
# Input pattern 408:
0.95 0.43 0.38
# Output pattern 408:
00100000
# Input pattern 409:
0.15 0.06 0.02
# Input pattern 626:
0.04 0.68 0.02
# Output pattern 626:
01000000
# Input pattern 627:
0.82 0.48 0.23
# Output pattern 627:
01000000
# Input pattern 628:
0.43 0.38 0.5
# Output pattern 628:
10000000
# Input pattern 629:
0.72 0.5 0.96
# Output pattern 629:
00000010
# Input pattern 630:
0.38 0.68 0.57
# Output pattern 630:
00000001
# Input pattern 631:
0.93 0.75 0.83
# Output pattern 631:
00100000
# Input pattern 632:
0.78 0.39 0.62
# Output pattern 632:
10000000
# Input pattern 633:
0.09 0.74 0.45
# Output pattern 633:
00000001
# Input pattern 634:
0.03 0.14 0.24
# Output pattern 634:
00000001
# Input pattern 635:
0.35 0.28 0.78
# Output pattern 635:
10000000
# Input pattern 636:
0.59 0.23 0.57
# Output pattern 636:
10000000
# Input pattern 637:
0.08 0.71 0.83
136
# Input pattern 854:
0.27 0.4 0.85
# Output pattern 854:
00000001
# Input pattern 855:
0.58 0.3 0.2
# Output pattern 855:
01000000
# Input pattern 856:
0.51 0.6 0.18
# Output pattern 856:
01000000
# Input pattern 857:
0.81 0.94 0.64
# Output pattern 857:
00100000
# Input pattern 858:
0.15 0.99 0.03
# Output pattern 858:
00100000
# Input pattern 859:
0.76 0.34 0.07
# Output pattern 859:
01000000
# Input pattern 860:
0.64 0.41 0.12
# Output pattern 860:
01000000
# Input pattern 861:
0.7 0.18 0.96
# Output pattern 861:
00000010
# Input pattern 862:
0.34 0.16 0.31
# Output pattern 862:
10000000
# Input pattern 863:
0.48 0.22 0.88
# Output pattern 863:
10000000
# Input pattern 864:
0.92 0.59 0.56
# Output pattern 864:
00100000
# Input pattern 865:
0.3 0.81 0.29
# Output pattern 181:
00000010
# Input pattern 182:
0.29 0.74 0.46
# Output pattern 182:
00000001
# Input pattern 183:
0.59 0.25 0.63
# Output pattern 183:
10000000
# Input pattern 184:
0.24 0.29 0.7
# Output pattern 184:
00000001
# Input pattern 185:
0.64 0.27 0.57
# Output pattern 185:
10000000
# Input pattern 186:
0.96 0.93 0.2
# Output pattern 186:
01000000
# Input pattern 187:
0.74 0.87 0.19
# Output pattern 187:
01000000
# Input pattern 188:
0.54 0.66 1
# Output pattern 188:
00000010
# Input pattern 189:
0.82 0.59 0.78
# Output pattern 189:
10000000
# Input pattern 190:
0.69 0.17 0.54
# Output pattern 190:
10000000
# Input pattern 191:
0.19 0.04 0.38
# Output pattern 191:
10000000
# Input pattern 192:
0.19 0.27 0.04
# Output pattern 192:
01000000
# Output pattern 409:
01000000
# Input pattern 410:
0.47 0.34 0.85
# Output pattern 410:
10000000
# Input pattern 411:
0.2 0.33 0.41
# Output pattern 411:
00000001
# Input pattern 412:
0.13 0.58 0.52
# Output pattern 412:
00000001
# Input pattern 413:
0.02 0.35 0.98
# Output pattern 413:
00000010
# Input pattern 414:
0.44 0.82 0.55
# Output pattern 414:
00000001
# Input pattern 415:
0.82 0.87 0.87
# Output pattern 415:
00000001
# Input pattern 416:
0.74 0.95 0.03
# Output pattern 416:
00100000
# Input pattern 417:
0.71 0.38 0.47
# Output pattern 417:
10000000
# Input pattern 418:
0.8 0.67 0.84
# Output pattern 418:
10000000
# Input pattern 419:
0.33 0.91 0.18
# Output pattern 419:
00100000
# Input pattern 420:
0.73 0.33 0.15
# Output pattern 420:
01000000
# Output pattern 637:
00000001
# Input pattern 638:
0.03 0.4 0.97
# Output pattern 638:
00000010
# Input pattern 639:
0.96 0.31 0.49
# Output pattern 639:
00100000
# Input pattern 640:
0.15 0.89 0.63
# Output pattern 640:
00000001
# Input pattern 641:
0.61 0.26 0.61
# Output pattern 641:
10000000
# Input pattern 642:
0.87 0.94 0.37
# Output pattern 642:
00100000
# Input pattern 643:
0.78 0.05 0.91
# Output pattern 643:
00000010
# Input pattern 644:
0.28 0.77 0.69
# Output pattern 644:
00000001
# Input pattern 645:
0.83 0.07 0.71
# Output pattern 645:
10000000
# Input pattern 646:
0.96 0.39 0.88
# Output pattern 646:
00100000
# Input pattern 647:
0.08 0.86 0.65
# Output pattern 647:
00000001
# Input pattern 648:
0.52 0.7 0.85
# Output pattern 648:
00000001
137
# Output pattern 865:
01000000
# Input pattern 866:
0.88 0.77 0.43
# Output pattern 866:
01000000
# Input pattern 867:
0.52 0.36 0.49
# Output pattern 867:
10000000
# Input pattern 868:
0.94 0.65 0.64
# Output pattern 868:
00100000
# Input pattern 869:
0.67 0.07 0.22
# Output pattern 869:
10000000
# Input pattern 870:
0.87 0.09 0.7
# Output pattern 870:
10000000
# Input pattern 871:
0.56 0.54 0.04
# Output pattern 871:
01000000
# Input pattern 872:
0.2 0.09 0.84
# Output pattern 872:
10000000
# Input pattern 873:
0.69 0.96 0.29
# Output pattern 873:
00100000
# Input pattern 874:
0.06 0.6 0.42
# Output pattern 874:
00000001
# Input pattern 875:
0.05 0.22 0.22
# Output pattern 875:
00000001
# Input pattern 876:
0.02 0.73 0.91
# Output pattern 876:
00000010
# Input pattern 193:
0.5 0.72 0.97
# Output pattern 193:
00000010
# Input pattern 194:
0.46 0.57 0.7
# Output pattern 194:
00000001
# Input pattern 195:
0.28 0.06 0.46
# Output pattern 195:
10000000
# Input pattern 196:
0.63 0.73 0.98
# Output pattern 196:
00000010
# Input pattern 197:
0.9 0.63 0.86
# Output pattern 197:
10000000
# Input pattern 198:
0.67 1 0.53
# Output pattern 198:
00100000
# Input pattern 199:
0.88 0.28 0.64
# Output pattern 199:
10000000
# Input pattern 200:
0.62 0.9 0.75
# Output pattern 200:
00000001
# Input pattern 201:
0.68 0.16 0.12
# Output pattern 201:
01000000
# Input pattern 202:
0.88 0.8 0.6
# Output pattern 202:
01000000
# Input pattern 203:
0.48 0.68 0.04
# Output pattern 203:
01000000
# Input pattern 204:
0.09 0.04 0.86
# Input pattern 421:
0.24 0.51 0.05
# Output pattern 421:
01000000
# Input pattern 422:
0.97 0.35 0.18
# Output pattern 422:
00100000
# Input pattern 423:
0.21 0.74 0.09
# Output pattern 423:
01000000
# Input pattern 424:
0.16 0.37 0.7
# Output pattern 424:
00000001
# Input pattern 425:
0.69 0.61 0.15
# Output pattern 425:
01000000
# Input pattern 426:
0.34 0.84 0.86
# Output pattern 426:
00000001
# Input pattern 427:
0.9 0.01 0.78
# Output pattern 427:
10000000
# Input pattern 428:
0.16 0.45 0.36
# Output pattern 428:
00000001
# Input pattern 429:
0.62 0.32 0.98
# Output pattern 429:
00000010
# Input pattern 430:
0.67 0.29 0.61
# Output pattern 430:
10000000
# Input pattern 431:
0.95 0.15 0.87
# Output pattern 431:
00100000
# Input pattern 432:
0.14 0.27 0.84
# Input pattern 649:
0.1 0.97 0.39
# Output pattern 649:
00000010
# Input pattern 650:
0.29 0.87 0.58
# Output pattern 650:
00000001
# Input pattern 651:
0.7 0.32 0.91
# Output pattern 651:
00000010
# Input pattern 652:
0.24 0.31 0.85
# Output pattern 652:
00000001
# Input pattern 653:
0.68 0.4 0.51
# Output pattern 653:
10000000
# Input pattern 654:
0.08 0.09 0.05
# Output pattern 654:
01000000
# Input pattern 655:
0.61 0.28 0.14
# Output pattern 655:
01000000
# Input pattern 656:
0.51 0.29 0.53
# Output pattern 656:
10000000
# Input pattern 657:
0.71 0.08 0.02
# Output pattern 657:
01000000
# Input pattern 658:
0.85 0.42 0.84
# Output pattern 658:
10000000
# Input pattern 659:
0.46 0.67 0.13
# Output pattern 659:
01000000
# Input pattern 660:
0.07 0.18 0.01
138
# Input pattern 877:
0.82 0.06 0.72
# Output pattern 877:
10000000
# Input pattern 878:
0.04 0.75 0.68
# Output pattern 878:
00000001
# Input pattern 879:
0.5 0.55 0.5
# Output pattern 879:
00100000
# Input pattern 880:
0.1 0.91 0.12
# Output pattern 880:
00000010
# Input pattern 881:
0.2 0.44 0.19
# Output pattern 881:
01000000
# Input pattern 882:
0.71 0.72 0.08
# Output pattern 882:
01000000
# Input pattern 883:
0.4 0.55 0.29
# Output pattern 883:
01000000
# Input pattern 884:
0.41 0.29 0.24
# Output pattern 884:
01000000
# Input pattern 885:
0.47 0.31 0.03
# Output pattern 885:
01000000
# Input pattern 886:
0.9 0.8 0.79
# Output pattern 886:
01000000
# Input pattern 887:
0.37 0.06 0.14
# Output pattern 887:
10000000
# Input pattern 888:
0.19 0.75 0.25
# Output pattern 204:
10000000
# Input pattern 205:
0.18 0.99 0.21
# Output pattern 205:
00000010
# Input pattern 206:
0.13 0.58 0.38
# Output pattern 206:
00000001
# Input pattern 207:
0.86 0.27 0.44
# Output pattern 207:
10000000
# Input pattern 208:
0.35 0.95 0.05
# Output pattern 208:
00100000
# Input pattern 209:
0.83 0.2 0.65
# Output pattern 209:
10000000
# Input pattern 210:
0.27 0.09 0.22
# Output pattern 210:
10000000
# Input pattern 211:
0.61 0.87 0.07
# Output pattern 211:
01000000
# Input pattern 212:
0.18 0.14 0.62
# Output pattern 212:
10000000
# Input pattern 213:
0.88 0.17 0.28
# Output pattern 213:
10000000
# Input pattern 214:
0.08 0.44 1
# Output pattern 214:
00000010
# Input pattern 215:
0.18 0.44 0.71
# Output pattern 215:
00000001
# Output pattern 432:
00000001
# Input pattern 433:
0.46 0.6 0.73
# Output pattern 433:
00000001
# Input pattern 434:
0.43 0.3 0.71
# Output pattern 434:
10000000
# Input pattern 435:
0.19 0.82 0.76
# Output pattern 435:
00000001
# Input pattern 436:
0.6 0.01 0.91
# Output pattern 436:
00000010
# Input pattern 437:
0.68 0.82 0.87
# Output pattern 437:
00000001
# Input pattern 438:
0.35 0.55 0.96
# Output pattern 438:
00000010
# Input pattern 439:
0.6 0.71 0.6
# Output pattern 439:
00100000
# Input pattern 440:
0.4 0.65 0.23
# Output pattern 440:
01000000
# Input pattern 441:
0.15 0.14 0.43
# Output pattern 441:
10000000
# Input pattern 442:
0.75 0.67 0.38
# Output pattern 442:
01000000
# Input pattern 443:
0.08 0.09 0.48
# Output pattern 443:
00000001
# Output pattern 660:
01000000
# Input pattern 661:
0.51 0.11 0.62
# Output pattern 661:
10000000
# Input pattern 662:
0.4 0.82 0.66
# Output pattern 662:
00000001
# Input pattern 663:
0.27 0.41 0.64
# Output pattern 663:
00000001
# Input pattern 664:
0.08 0.24 0.87
# Output pattern 664:
00000001
# Input pattern 665:
0.77 0.96 0.42
# Output pattern 665:
00100000
# Input pattern 666:
0.47 0.97 0.11
# Output pattern 666:
00100000
# Input pattern 667:
0.05 0.99 0.21
# Output pattern 667:
00000010
# Input pattern 668:
0.99 0.18 0.75
# Output pattern 668:
00100000
# Input pattern 669:
0.73 0.88 0.24
# Output pattern 669:
01000000
# Input pattern 670:
0.31 0.17 0.66
# Output pattern 670:
10000000
# Input pattern 671:
0.31 0.45 0
# Output pattern 671:
01000000
139
# Output pattern 888:
00000001
# Input pattern 889:
0.32 0.14 0.62
# Output pattern 889:
10000000
# Input pattern 890:
0.31 0.22 0.88
# Output pattern 890:
10000000
# Input pattern 891:
0.1 0.96 0.73
# Output pattern 891:
00000010
# Input pattern 892:
0.93 0.42 0.28
# Output pattern 892:
00100000
# Input pattern 893:
0.18 0.15 0.56
# Output pattern 893:
10000000
# Input pattern 894:
0.64 0.18 0.25
# Output pattern 894:
10000000
# Input pattern 895:
0.34 0.87 0.05
# Output pattern 895:
01000000
# Input pattern 896:
0.73 0.19 0.44
# Output pattern 896:
10000000
# Input pattern 897:
0.41 0.9 0.11
# Output pattern 897:
01000000
# Input pattern 898:
0.97 0.41 0.85
# Output pattern 898:
00100000
# Input pattern 899:
0.3 0.36 0.95
# Output pattern 899:
00000010
# Input pattern 216:
0.8 1 0.02
# Output pattern 216:
00100000
# Input pattern 217:
0.73 0.95 0.75
# Output pattern 217:
00000010
# Input pattern 218:
0.92 0.31 0.99
# Output pattern 218:
00001000
# Input pattern 219:
0.1 0.68 0.8
# Output pattern 219:
00000001
# Input pattern 220:
0.76 0.73 0.31
# Output pattern 220:
01000000
# Input pattern 221:
0.39 0.24 0.24
# Output pattern 221:
10000000
# Input pattern 222:
0.75 0.61 0.48
# Output pattern 222:
01000000
# Input pattern 223:
0.16 0.96 0.51
# Output pattern 223:
00000010
# Input pattern 224:
0.08 0.03 0.71
# Output pattern 224:
10000000
# Input pattern 225:
0.91 0.48 0.21
# Output pattern 225:
00100000
# Input pattern 226:
0.43 0.76 0.12
# Output pattern 226:
01000000
# Input pattern 227:
0.1 0.03 0.07
# Input pattern 444:
0.36 0.05 0.05
# Output pattern 444:
10000000
# Input pattern 445:
0.19 0.88 0.49
# Output pattern 445:
00000001
# Input pattern 446:
0.96 0.98 0.13
# Output pattern 446:
00100000
# Input pattern 447:
0.04 0.86 0.46
# Output pattern 447:
00000001
# Input pattern 448:
0.86 0.34 0.57
# Output pattern 448:
10000000
# Input pattern 449:
0.69 0.12 0.35
# Output pattern 449:
10000000
# Input pattern 450:
0.3 0.35 0.53
# Output pattern 450:
00000001
# Input pattern 451:
0.4 0.95 0.38
# Output pattern 451:
00100000
# Input pattern 452:
0.63 0.3 0.31
# Output pattern 452:
10000000
# Input pattern 453:
0.88 0.9 0.76
# Output pattern 453:
01000000
# Input pattern 454:
0.48 0.55 0.62
# Output pattern 454:
00000001
# Input pattern 455:
0.14 0.22 0.15
# Input pattern 672:
0.26 0.76 0.74
# Output pattern 672:
00000001
# Input pattern 673:
0.44 0.83 0.66
# Output pattern 673:
00000001
# Input pattern 674:
0.77 0.14 0.76
# Output pattern 674:
10000000
# Input pattern 675:
0.83 0.19 0.9
# Output pattern 675:
10000000
# Input pattern 676:
0.46 0.67 0.1
# Output pattern 676:
01000000
# Input pattern 677:
0.92 0.53 0.77
# Output pattern 677:
00100000
# Input pattern 678:
0.57 0.99 0.65
# Output pattern 678:
00000010
# Input pattern 679:
0.38 0.56 0.67
# Output pattern 679:
00000001
# Input pattern 680:
0.31 0.44 0.53
# Output pattern 680:
00000001
# Input pattern 681:
0.22 0.38 0.46
# Output pattern 681:
00000001
# Input pattern 682:
0.09 0.23 0.57
# Output pattern 682:
00000001
# Input pattern 683:
0.61 0.84 0.12
140
# Input pattern 900:
0.3 0.22 0.01
# Output pattern 900:
01000000
# Input pattern 901:
0.57 0.08 0.06
# Output pattern 901:
01000000
# Input pattern 902:
0.33 0.4 0.33
# Output pattern 902:
00100000
# Input pattern 903:
0.28 0.02 0.04
# Output pattern 903:
10000000
# Input pattern 904:
0.32 0.55 0.94
# Output pattern 904:
00000010
# Input pattern 905:
0.49 0.91 0.87
# Output pattern 905:
00000010
# Input pattern 906:
0.59 0.02 0.91
# Output pattern 906:
00000010
# Input pattern 907:
0.46 0.47 0.1
# Output pattern 907:
01000000
# Input pattern 908:
0.19 0.87 0.78
# Output pattern 908:
00000001
# Input pattern 909:
0.36 0.09 0.45
# Output pattern 909:
10000000
# Input pattern 910:
0.87 0.32 0.79
# Output pattern 910:
10000000
# Input pattern 911:
0.87 0.48 0.17
# Output pattern 227:
10000000
# Input pattern 228:
0.76 0.85 0.69
# Output pattern 228:
01000000
# Output pattern 455:
00000001
# Input pattern 456:
0.29 0.42 0.76
# Output pattern 456:
00000001
# Output pattern 683:
01000000
# Input pattern 684:
0.76 0.5 0.3
# Output pattern 684:
01000000
141
# Output pattern 911:
01000000
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
# Input pattern 1:
0.6 0.02 0.63
# Output pattern 1:
10000000
# Input pattern 2:
0.89 0.26 0.33
# Output pattern 2:
10000000
# Input pattern 3:
0.75 0.09 0.48
# Output pattern 3:
10000000
# Input pattern 4:
0.21 0.5 0.86
# Output pattern 4:
00000001
# Input pattern 5:
0.24 0.61 0.77
# Output pattern 5:
00000001
# Input pattern 6:
0.56 0.96 0.51
# Output pattern 6:
00100000
# Input pattern 7:
0.37 0.75 0.26
# Output pattern 7:
01000000
# Input pattern 8:
0.67 0.39 0.74
# Output pattern 8:
10000000
# Input pattern 51:
0.46 0.56 0.01
# Output pattern 51:
01000000
# Input pattern 52:
0.07 0.49 0.49
# Output pattern 52:
00000001
# Input pattern 53:
0.97 0.51 0.44
# Output pattern 53:
00100000
# Input pattern 54:
0.81 0.29 0.21
# Output pattern 54:
01000000
# Input pattern 55:
0.65 0.55 0.35
# Output pattern 55:
01000000
# Input pattern 56:
0.59 0.21 0.66
# Output pattern 56:
10000000
# Input pattern 57:
0.53 0.9 0.58
# Output pattern 57:
00000001
# Input pattern 58:
0.89 0.71 0.76
# Output pattern 58:
10000000
# Input pattern 101:
0.46 0.25 0.51
# Output pattern 101:
10000000
# Input pattern 102:
0.61 0.88 0.61
# Output pattern 102:
00100000
# Input pattern 103:
0.28 0.45 0.49
# Output pattern 103:
00000001
# Input pattern 104:
0.59 0.39 0.24
# Output pattern 104:
01000000
# Input pattern 105:
0.65 0.25 0.58
# Output pattern 105:
10000000
# Input pattern 106:
0.29 0.22 0.3
# Output pattern 106:
10000000
# Input pattern 107:
0.88 0.09 0.84
# Output pattern 107:
10000000
# Input pattern 108:
0.69 0.66 0.33
# Output pattern 108:
01000000
142
# Input pattern 151:
0.31 0.16 0.34
# Output pattern 151:
10000000
# Input pattern 152:
0.88 0.22 0.48
# Output pattern 152:
10000000
# Input pattern 153:
0.56 0.59 0.92
# Output pattern 153:
00000010
# Input pattern 154:
0.29 0.81 0.3
# Output pattern 154:
00000001
# Input pattern 155:
0.43 0.77 0.88
# Output pattern 155:
00000001
# Input pattern 156:
0.49 0.36 0.52
# Output pattern 156:
10000000
# Input pattern 157:
0.64 0.65 0.94
# Output pattern 157:
00000010
# Input pattern 158:
0.22 0.07 0.67
# Output pattern 158:
10000000
# Input pattern 9:
0.04 0.92 0.03
# Output pattern 9:
00100000
# Input pattern 10:
0.31 0.6 0.26
# Output pattern 10:
01000000
# Input pattern 11:
0.73 0.44 0.84
# Output pattern 11:
10000000
# Input pattern 12:
0.24 0.09 0.77
# Output pattern 12:
10000000
# Input pattern 13:
0.34 0.45 0.28
# Output pattern 13:
01000000
# Input pattern 14:
0.49 0.33 0.84
# Output pattern 14:
10000000
# Input pattern 15:
0.56 0.7 0.4
# Output pattern 15:
01000000
# Input pattern 16:
1 0.99 0.84
# Output pattern 16:
00100000
# Input pattern 17:
0.26 0.95 0.59
# Output pattern 17:
00100000
# Input pattern 18:
0.84 0.31 0.56
# Output pattern 18:
10000000
# Input pattern 19:
0.32 0.79 0.55
# Output pattern 19:
00000001
# Input pattern 20:
0.11 0.01 0.98
# Input pattern 59:
0.58 0.81 0.24
# Output pattern 59:
01000000
# Input pattern 60:
0.8 0.29 0.4
# Output pattern 60:
10000000
# Input pattern 61:
0.26 0.23 0.4
# Output pattern 61:
10000000
# Input pattern 62:
0.69 0.02 0.35
# Output pattern 62:
10000000
# Input pattern 63:
0.85 0.04 0.98
# Output pattern 63:
00000010
# Input pattern 64:
0.57 0.07 0.71
# Output pattern 64:
10000000
# Input pattern 65:
0.15 0.91 0.05
# Output pattern 65:
00100000
# Input pattern 66:
0.21 0.93 0.69
# Output pattern 66:
00000010
# Input pattern 67:
0.71 0.51 0.41
# Output pattern 67:
01000000
# Input pattern 68:
0.22 0.46 0.21
# Output pattern 68:
01000000
# Input pattern 69:
0.82 0.55 0.68
# Output pattern 69:
10000000
# Input pattern 70:
0.37 0.65 0.02
# Input pattern 109:
0.89 0.97 0.02
# Output pattern 109:
00100000
# Input pattern 110:
0.43 0.77 0.25
# Output pattern 110:
01000000
# Input pattern 111:
0.53 0.16 0.41
# Output pattern 111:
10000000
# Input pattern 112:
0.98 0.61 0.45
# Output pattern 112:
00100000
# Input pattern 113:
0.85 0.62 0.66
# Output pattern 113:
10000000
# Input pattern 114:
0.35 0.27 0.76
# Output pattern 114:
10000000
# Input pattern 115:
0.43 0.91 0.19
# Output pattern 115:
00100000
# Input pattern 116:
0.78 0.15 0.27
# Output pattern 116:
10000000
# Input pattern 117:
0.1 0.91 0.05
# Output pattern 117:
00100000
# Input pattern 118:
0.76 0.23 0.82
# Output pattern 118:
10000000
# Input pattern 119:
0.25 0.34 0.73
# Output pattern 119:
00000001
# Input pattern 120:
0.58 0.39 0.18
143
# Input pattern 159:
0.7 0.09 0.87
# Output pattern 159:
10000000
# Input pattern 160:
0.04 0.54 0.56
# Output pattern 160:
00000001
# Input pattern 161:
0.84 0.09 0.2
# Output pattern 161:
10000000
# Input pattern 162:
0.29 0.96 0.69
# Output pattern 162:
00000010
# Input pattern 163:
0.42 0.6 0.06
# Output pattern 163:
01000000
# Input pattern 164:
0.22 0.22 0.05
# Output pattern 164:
01000000
# Input pattern 165:
0.91 0.73 0.02
# Output pattern 165:
00100000
# Input pattern 166:
0.72 0.06 0.82
# Output pattern 166:
10000000
# Input pattern 167:
0.68 0.75 0.04
# Output pattern 167:
01000000
# Input pattern 168:
0.5 0.55 0.5
# Output pattern 168:
00100000
# Input pattern 169:
0.12 0.91 0.1
# Output pattern 169:
00100000
# Input pattern 170:
0.19 0.44 0.2
# Output pattern 20:
00000010
# Input pattern 21:
0.07 0.36 0.12
# Output pattern 21:
00000001
# Input pattern 22:
0.92 0.54 0.5
# Output pattern 22:
00100000
# Input pattern 23:
0.66 0.43 0.57
# Output pattern 23:
10000000
# Input pattern 24:
0.34 0.13 0.26
# Output pattern 24:
10000000
# Input pattern 25:
0.9 0.77 0.77
# Output pattern 25:
10000000
# Input pattern 26:
0.17 0.22 0.3
# Output pattern 26:
00000001
# Input pattern 27:
0.68 0.74 0.59
# Output pattern 27:
01000000
# Input pattern 28:
0.93 0.9 0.81
# Output pattern 28:
00100000
# Input pattern 29:
0.67 0.67 0.02
# Output pattern 29:
01000000
# Input pattern 30:
0.17 0.35 0.41
# Output pattern 30:
00000001
# Input pattern 31:
0.49 0.72 0.04
# Output pattern 31:
01000000
# Output pattern 70:
01000000
# Input pattern 71:
0.71 0.47 0.02
# Output pattern 71:
01000000
# Input pattern 72:
0.42 0.29 0.72
# Output pattern 72:
10000000
# Input pattern 73:
0.71 0.61 0.8
# Output pattern 73:
10000000
# Input pattern 74:
0.22 0.65 0.39
# Output pattern 74:
00000001
# Input pattern 75:
0.31 0.06 0.85
# Output pattern 75:
10000000
# Input pattern 76:
0.48 0.36 0.85
# Output pattern 76:
10000000
# Input pattern 77:
0.41 0.05 0.84
# Output pattern 77:
10000000
# Input pattern 78:
0.41 0.79 0.39
# Output pattern 78:
01000000
# Input pattern 79:
0.42 0.1 0.05
# Output pattern 79:
01000000
# Input pattern 80:
0.21 0.39 0.05
# Output pattern 80:
01000000
# Input pattern 81:
0.54 0.18 0.5
# Output pattern 81:
10000000
# Output pattern 120:
01000000
# Input pattern 121:
0.51 0.83 0.2
# Output pattern 121:
01000000
# Input pattern 122:
0.03 0.12 0.81
# Output pattern 122:
00000001
# Input pattern 123:
0.62 0.29 0.93
# Output pattern 123:
00000010
# Input pattern 124:
0.36 0.64 0.21
# Output pattern 124:
01000000
# Input pattern 125:
0.46 0.43 0.37
# Output pattern 125:
01000000
# Input pattern 126:
0.62 0.15 0.6
# Output pattern 126:
10000000
# Input pattern 127:
0.82 0.69 0.57
# Output pattern 127:
01000000
# Input pattern 128:
0.61 0.36 0.72
# Output pattern 128:
10000000
# Input pattern 129:
0.58 0.71 0.07
# Output pattern 129:
01000000
# Input pattern 130:
0.6 0.8 0.7
# Output pattern 130:
00000001
# Input pattern 131:
0.64 0.6 0.53
# Output pattern 131:
01000000
144
# Output pattern 170:
00000001
# Input pattern 171:
0.08 0.72 0.71
# Output pattern 171:
00000001
# Input pattern 172:
0.29 0.55 0.4
# Output pattern 172:
00000001
# Input pattern 173:
0.24 0.29 0.41
# Output pattern 173:
00000001
# Input pattern 174:
0.03 0.31 0.47
# Output pattern 174:
00000001
# Input pattern 175:
0.79 0.8 0.9
# Output pattern 175:
00000001
# Input pattern 176:
0.14 0.06 0.37
# Output pattern 176:
10000000
# Input pattern 177:
0.25 0.75 0.19
# Output pattern 177:
01000000
# Input pattern 178:
0.62 0.14 0.32
# Output pattern 178:
10000000
# Input pattern 179:
0.88 0.22 0.31
# Output pattern 179:
10000000
# Input pattern 180:
0.73 0.96 0.1
# Output pattern 180:
00100000
# Input pattern 181:
0.28 0.42 0.93
# Output pattern 181:
00000010
# Input pattern 32:
0.9 0.06 0.55
# Output pattern 32:
10000000
# Input pattern 33:
0.79 0.8 0.35
# Output pattern 33:
01000000
# Input pattern 34:
0.51 0.88 0.09
# Output pattern 34:
01000000
# Input pattern 35:
0.19 0.41 0.15
# Output pattern 35:
01000000
# Input pattern 36:
0.51 0.56 0.51
# Output pattern 36:
00100000
# Input pattern 37:
0.85 0.55 0.01
# Output pattern 37:
01000000
# Input pattern 38:
0.41 0.94 0.38
# Output pattern 38:
00100000
# Input pattern 39:
0.46 0.11 0.47
# Output pattern 39:
10000000
# Input pattern 40:
0.45 0.04 0.65
# Output pattern 40:
10000000
# Input pattern 41:
0.03 0.44 0.61
# Output pattern 41:
00000001
# Input pattern 42:
0.85 0.91 0.21
# Output pattern 42:
00100000
# Input pattern 43:
0.62 0.21 0.2
# Input pattern 82:
0.7 0.22 0.66
# Output pattern 82:
10000000
# Input pattern 83:
0.1 0.56 0.23
# Output pattern 83:
00000001
# Input pattern 84:
0.04 0.42 0.2
# Output pattern 84:
00000001
# Input pattern 85:
0.14 0.04 0.67
# Output pattern 85:
10000000
# Input pattern 86:
0.05 0.93 0.22
# Output pattern 86:
00000010
# Input pattern 87:
0.42 0 0.21
# Output pattern 87:
10000000
# Input pattern 88:
0.6 0.14 0.26
# Output pattern 88:
10000000
# Input pattern 89:
0.34 0.16 0.93
# Output pattern 89:
00000010
# Input pattern 90:
0.72 0.39 0.38
# Output pattern 90:
01000000
# Input pattern 91:
0.66 0.37 0.01
# Output pattern 91:
01000000
# Input pattern 92:
0.1 0.25 0.14
# Output pattern 92:
00000001
# Input pattern 93:
0.71 1 0.02
# Input pattern 132:
0.39 0.19 0.57
# Output pattern 132:
10000000
# Input pattern 133:
0.89 0.58 0.04
# Output pattern 133:
01000000
# Input pattern 134:
0.54 0.58 0.73
# Output pattern 134:
00000001
# Input pattern 135:
0.58 0.49 0.1
# Output pattern 135:
01000000
# Input pattern 136:
0.13 0.35 0.64
# Output pattern 136:
00000001
# Input pattern 137:
0.02 0.18 0.06
# Output pattern 137:
00000001
# Input pattern 138:
0.94 0.31 0.56
# Output pattern 138:
00100000
# Input pattern 139:
0.76 0.26 0.74
# Output pattern 139:
10000000
# Input pattern 140:
0.97 0.75 0.58
# Output pattern 140:
00100000
# Input pattern 141:
0.12 0.38 0.47
# Output pattern 141:
00000001
# Input pattern 142:
0.08 0.03 0.69
# Output pattern 142:
10000000
# Input pattern 143:
0.85 0.4 0.27
145
# Input pattern 182:
0.56 0.15 0.18
# Output pattern 182:
10000000
# Input pattern 183:
0.25 0.18 0.64
# Output pattern 183:
10000000
# Input pattern 184:
0.05 0.87 0.34
# Output pattern 184:
00000001
# Input pattern 185:
0.44 0.19 0.73
# Output pattern 185:
10000000
# Input pattern 186:
0.11 0.9 0.41
# Output pattern 186:
00000001
# Input pattern 187:
0.85 0.41 0.97
# Output pattern 187:
00000010
# Input pattern 188:
0.95 0.36 0.3
# Output pattern 188:
00100000
# Input pattern 189:
0.01 0.22 0.3
# Output pattern 189:
00000001
# Input pattern 190:
0.06 0.08 0.57
# Output pattern 190:
00000001
# Input pattern 191:
0.33 0.4 0.33
# Output pattern 191:
00100000
# Input pattern 192:
0.04 0.02 0.28
# Output pattern 192:
10000000
# Input pattern 193:
0.94 0.55 0.32
# Output pattern 43:
01000000
# Input pattern 44:
0.22 0.66 0.6
# Output pattern 44:
00000001
# Input pattern 45:
0.69 0.83 0.12
# Output pattern 45:
01000000
# Input pattern 46:
0.72 0.32 0.79
# Output pattern 46:
10000000
# Input pattern 47:
0.52 0.48 0.55
# Output pattern 47:
10000000
# Input pattern 48:
0.83 0.1 0.07
# Output pattern 48:
01000000
# Input pattern 49:
0.09 0.33 0.84
# Output pattern 49:
00000001
# Input pattern 50:
0.25 0.54 0.28
# Output pattern 50:
00000001
# Output pattern 93:
00100000
# Input pattern 94:
0.72 0.55 0.29
# Output pattern 94:
01000000
# Input pattern 95:
0.41 0.93 0.69
# Output pattern 95:
00000010
# Input pattern 96:
0.74 0.2 0.31
# Output pattern 96:
10000000
# Input pattern 97:
0.89 0.36 0.5
# Output pattern 97:
10000000
# Input pattern 98:
0.18 0.71 0.51
# Output pattern 98:
00000001
# Input pattern 99:
0.51 0.83 0.52
# Output pattern 99:
00000001
# Input pattern 100:
0.47 0.14 0.74
# Output pattern 100:
10000000
# Output pattern 143:
01000000
# Input pattern 144:
0.2 0.3 0.58
# Output pattern 144:
00000001
# Input pattern 145:
0.18 0.6 0.51
# Output pattern 145:
00000001
# Input pattern 146:
0.64 0.94 0.81
# Output pattern 146:
00000010
# Input pattern 147:
0.03 0.99 0.15
# Output pattern 147:
00000010
# Input pattern 148:
0.07 0.34 0.76
# Output pattern 148:
00000001
# Input pattern 149:
0.12 0.41 0.64
# Output pattern 149:
00000001
# Input pattern 150:
0.96 0.18 0.7
# Output pattern 150:
00100000
146
# Output pattern 193:
00100000
# Input pattern 194:
0.87 0.91 0.49
# Output pattern 194:
00100000
# Input pattern 195:
0.91 0.02 0.59
# Output pattern 195:
00100000
# Input pattern 196:
0.1 0.47 0.46
# Output pattern 196:
00000001
# Input pattern 197:
0.78 0.87 0.19
# Output pattern 197:
01000000
# Input pattern 198:
0.45 0.09 0.36
# Output pattern 198:
10000000
# Input pattern 199:
0.79 0.32 0.87
# Output pattern 199:
10000000
# Input pattern 200:
0.17 0.48 0.87
# Output pattern 200:
00000001
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
147
#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
148
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
149
#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
150
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
151
#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
152
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
153
#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
154
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
155
#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
156
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
157
#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
158
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
159
#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
160
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
161
#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
162
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
163
#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
164
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
165
#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
166
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
167
#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
168
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
#define
#ifndef
#define
#endif
Act_Logistic(sum, bias)
Act_Identity(sum, bias)
NULL
NULL (void *)0
typedef struct UT {
float act;
float Bias;
int
NoOfSources;
struct UT
**sources; /*
float *weights; /*
} UnitType, *pUnit;
( (sum+bias<10000.0) ? ( 1.0/(1.0 + exp(-sum-bias) ) ) : 0.0 )
( sum )
/* Activation
*/
/* Bias of the Unit */
/* Number of predecessor units */
predecessor units */
weights from predecessor units */
/* 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,
12, Units + 13,
Units + 14, Units + 15, Units + 16, Units +
Units + 4, Units + 5, Units + 6, Units + 7,
12, Units + 13,
Units + 14, Units + 15, Units + 16, Units +
Units + 4, Units + 5, Units + 6, Units + 7,
12, Units + 13,
Units + 14, Units + 15, Units + 16, Units +
Units + 4, Units + 5, Units + 6, Units + 7,
12, Units + 13,
Units + 14, Units + 15, Units + 16, Units +
Units + 4, Units + 5, Units + 6, Units + 7,
12, Units + 13,
Units + 14, Units + 15, Units + 16, Units +
Units + 4, Units + 5, Units + 6, Units + 7,
12, Units + 13,
Units + 14, Units + 15, Units + 16, Units +
Units + 4, Units + 5, Units + 6, Units + 7,
12, Units + 13,
Units + 14, Units + 15, Units + 16, Units +
Units + 4, Units + 5, Units + 6, Units + 7,
12, Units + 13,
Units + 14, Units + 15, Units + 16, Units +
*/
Units + 8, Units + 9, Units + 10, Units + 11, Units +
17, Units + 18, Units + 19, Units + 20,
Units + 8, Units + 9, Units + 10, Units + 11, Units +
17, Units + 18, Units + 19, Units + 20,
Units + 8, Units + 9, Units + 10, Units + 11, Units +
17, Units + 18, Units + 19, Units + 20,
Units + 8, Units + 9, Units + 10, Units + 11, Units +
17, Units + 18, Units + 19, Units + 20,
Units + 8, Units + 9, Units + 10, Units + 11, Units +
17, Units + 18, Units + 19, Units + 20,
Units + 8, Units + 9, Units + 10, Units + 11, Units +
17, Units + 18, Units + 19, Units + 20,
Units + 8, Units + 9, Units + 10, Units + 11, Units +
17, Units + 18, Units + 19, Units + 20,
Units + 8, Units + 9, Units + 10, Units + 11, Units +
17, Units + 18, Units + 19, Units + 20,
};
169
/* 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] ,
170
},
{ /* 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] ,
171
},
{ /* 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" );
172
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);
173
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
Resultado
Esquerdo
Central Direito 000 030 090 120 180 240 270 330
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
174
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
175
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
176
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
177
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
178
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
struct UT
*/
NoOfSources; /* Number of predecessor units */
**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,
179
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,
180
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,
};
/* 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,
181
1.176160, -1.482980, 64.152657,
-7.296000, -30.247690,
5.887150, 11.611230,
-5.254930,
0.359240,
-31.029051,
7.411190,
9.146040,
2.362280,
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,
2.969300, -8.182690,
17.852579,
4.323410,
22.979490,
6.813470,
-7.080890,
-10.572310,
-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,
1.238880, -0.566210,
-2.296600,
-1.148260,
5.360080,
-3.355930,
-1.680750,
-4.251740,
-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,
13.761910, -13.652430,
-28.874969,
-2.956700,
3.562850,
3.802390,
2.693810,
-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 },
182
-11.241080,
{ /* 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] ,
183
&Weights[6] ,
},
{ /* unit 7 (oculto) */
0.0, 7.870630, 3,
&Sources[9] ,
&Weights[9] ,
},
{ /* 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) */
184
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] ,
185
},
{ /* 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,
186
&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] ,
}
187
};
//--------------------------------------------------------------------------// 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];
}
188
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);
}
189
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"));
}
190
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);
191
add(w20);
Wall w21 = new Wall(new
add(w21);
Wall w22 = new Wall(new
add(w22);
Wall w23 = new Wall(new
add(w23);
Wall w24 = new Wall(new
w24.rotate90(1);
add(w24);
Wall w25 = new Wall(new
w25.rotate90(1);
add(w25);
Vector3d(-2, 0, -5), 6, 2, this);
Vector3d(-1, 0, -1), 4, 2, this);
Vector3d(4, 0, -1), 2, 2, this);
Vector3d(1, 0, -4), 2, 2, this);
Vector3d(-1, 0, -2), 2, 2, this);
/** Robô */
add(new Robot(new Vector3d(5, 0, -8.2), "RNAn1"));
}
192
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));
}
}
}
193
/** 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;
}
}
}
194