Na documentação anterior (”Perceptron em PERL“), foi comentado que a rede de uma única camada têm a limitação de resolver apenas problemas com características lineares. Procurando solucionar problemas não-lineares, de acordo com o que foi testado anteriormente, neste documento será implementado uma rede neural artificial MLP (Multilayer Perceptron) em um script PERL.

Em redes de uma única camada um erro e é obtido através da diferença da saída desejada e da saída atual. Já em redes de múltiplas camadas esse procedimento só se aplica na camada de saída, já que não existem saídas desejadas nas camadas intermediárias. Em 1986, Rumelhart, Hinton e Williams, encontraram a solução deste problema com a descrição do algoritmo de retropropagação de erros, ou também conhecido como back-propagation. Portanto, o erro das camadas intermediárias é calculado utilizando o gradiente descendente. Sendo assim, o erro de saída da rede é calculado e retroalimentado para as camadas intermediárias. Na figura abaixo, uma ilustração de uma rede de múltiplas camadas:

A primeira camada não contêm neurônios, mas sim os valores de entrada (input). A camada intermediária ou oculta (hidden) é composta por  vários neurônios e, dependendo da topologia, poderão existir camadas adicionais. A camada de saída (output) também é composta por neurônios e é nesta camada em que se obtém os resultados da rede. Para que uma rede funcione corretamente é preciso estar atento aos seguintes passos:

• Definir a topologia da rede
• Selecionar exemplos para treinamento
• Treinar a rede com os exemplos aleatoriamente
• Testar a rede com diferentes exemplos
• Colocar a rede em produção

Seguindo estes passos, a rede aqui implementada já tem uma topologia pré-definida:

Próximo passo é selecionar os exemplos, veja a tabela:

Ou seja, nesta tabela temos o problema não-linear com a operação lógica not xor. Estes valores já foram preenchidos no script, já é possível progredir para a parte prática!

MLP em PERL:

Baixe o arquivo multilayerperceptron.txt, e renomeie:

$ mv multilayerperceptron.txt multilayerperceptron.pl

Execute o script:

$ perl multilayerperceptron.pl

Quando abrir o código-fonte, note que a função &treinar vai iniciar o treinamento da rede na seguinte ordem: sortear e selecionar elementos, propagar e retropropagar. O treinamento só vai parar quando ocorrer 20.000 iterações ou até que o erro médio fique menor que 0,1. Depois do treinamento, o script executará os testes de acordo com a tabela acima e os pesos encontrados.

Neste exemplo de treinamento, observe o número de iterações necessárias para obter este erro médio:

+-----------------------------------------------------------------------+
Iteracoes : 5586
Erro medio: 0.0999879056521445
+-----------------------------------------------------------------------+
 Camada de Entrada:
 Entrada 1      = 0
 Entrada 2      = 1
 Bias           = 1
 Saida desejada = 0
 Camada Oculta:
 Perceptron (1)
 - peso w0 = 5.92965150134864
 - peso w1 = -6.02940205491744
 - peso wb = -3.33311356293781
 y = 8.5876365052834e-05
 Perceptron (2)
 - peso w0 = -5.61155018078928
 - peso w1 = 5.37113621208487
 - peso wb = -2.995916930648
 y = 0.914888368913857
 Camada de Saida:
 Perceptron (3)
 - peso w0 = -8.59545979005542
 - peso w1 = -8.7253347106524
 - peso wb = 4.27613939276666
 y = 0.0239676434822143
 resultado = 0
+-----------------------------------------------------------------------+

Após o treinamento, os testes poderão ser realizados:

+-----------------------------------------------------------------------+
 Qual a funcao de Paulo?
 Camada de Entrada: 0,0
 Camada Oculta    :
 Perceptron 1 = 0.0344525056970724
 Perceptron 2 = 0.0476106738471936
 Camada de Saida  : 1
 Perceptron 3 = 0.972470596816921
 Resposta: Paulo = Tecnico.
+-----------------------------------------------------------------------+

+-----------------------------------------------------------------------+
 Qual a funcao de Joao?
 Camada de Entrada: 0,1
 Camada Oculta    :
 Perceptron 1 = 8.58764005878735e-05
 Perceptron 2 = 0.914918026077931
 Camada de Saida  : 0
 Perceptron 3 = 0.0239495494481809
 Resposta: Joao = Analista.
+-----------------------------------------------------------------------+

+-----------------------------------------------------------------------+
 Qual a funcao de Tiago?
 Camada de Entrada: 1,0
 Camada Oculta    :
 Perceptron 1 = 0.930638434625416
 Perceptron 2 = 0.000182702788692357
 Camada de Saida  : 0
 Perceptron 3 = 0.0235517875248058
 Resposta: Tiago = Analista.
+-----------------------------------------------------------------------+

+-----------------------------------------------------------------------+
 Qual a funcao de Pedro?
 Camada de Entrada: 1,1
 Camada Oculta    :
 Perceptron 1 = 0.03128401763865
 Perceptron 2 = 0.0378211856204887
 Camada de Saida  : 1
 Perceptron 3 = 0.975331165234103
 Resposta: Pedro = Tecnico.
+-----------------------------------------------------------------------+

O problema que antes não foi resolvido pela rede de uma camada, foi resolvido agora por esta rede de três camadas. Mostrou-se aqui como funciona uma rede MLP e sua vantagem sobre uma rede de uma única camada. Procurou-se também fazer o código-fonte dos scripts de uma maneira simples para facilitar o entendimento a quem interessar.

Obrigado pela sua atenção! E agradecimentos ao Prof. Julio Cesar Nievola!

<< Perceptron em PERL

Livro de referência:

Redes Neurais Artificiais: teoria e aplicações / Antônio de Pádua Braga, André Carlos Ponce de Leon Ferreira de Carvalho,Teresa Bernarda Ludemir. – 2.ed. -  LTC, 2007.

MLP em Python: http://www.adgsolucoes.com.br/200…