MLP em PERL
09 de Novembro de 2009.

Na documentação anterior (Perceptron em PERL), foi comentado que a rede de uma 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á implementada uma rede neural artificial MLP (Multilayer Perceptron) em um script PERL.

Em redes de uma 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 para esse problema com a descrição do algoritmo de retropropagação de erros, que  também é conhecido como back-propagation. Nesse algoritmo 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 é apresentada 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 é nessa camada 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 esses passos, a rede aqui implementada já tem uma topologia pré-definida:



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

-------------------------------------
| Pessoa | Valor | Função   | Valor |
|-----------------------------------|
| Paulo  |   0,0 | Tecnico  |     1 |
| Joao   |   0,1 | Analista |     0 |
| Tiago  |   1,0 | Analista |     0 |
| Pedro  |   1,1 | Tecnico  |     1 |
-------------------------------------

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 e já é possível partir para a 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 esse 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. Apresentou-se aqui um exemplo de como funciona uma rede MLP e sua vantagem sobre a rede de uma camada. Buscou-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!

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/...