Redes Neurais Artificiais [#3]

RNA - Treinamento

A fase treino é, pra mim, a fase mais interessante. É só imaginar um treinamento de cão. Depois de treinado, ao ouvir a palavra "senta" o bixinho vai invariavelmente sentar. Qual a graça? A graça é, aos poucos, fazê-lo entender que ao ouvir "senta" ele deva colocar a bundinha no chão e ficar ali paradinho. De maneira semelhante acontece com a rede neural: depois de ensiná-la, executar é basicamente colher os resultados.

Antes de começar, vou mostrar como seria um modelo da porta-lógica E (AND):

                      [-1]
                        |
                        |1,5
                1       |
         [x1]-------> |¯¯¯|
                      |   |------> Y
         [x2]-------> |___|
                1

    Y=1, se u >= 0
    Y=0, se u < 0

            [x1] [x2] [u = w1x1 + w2x2 - limiar] [Y]
             0    0    1*0 + 1*0 - 1,5 = -1,5     0
             0    1    1*0 + 1*1 - 1,5 = -0,5     0
             1    0    1*1 + 1*0 - 1,5 = -0,5     0
             1    1    1*1 + 1*1 - 1,5 = 0,5      1


Alguma dúvida? A única diferença entre a porta lógica OU (OR) é o peso da entrada do limiar, que antes era 0,5 e agora é 1,5.

Voltando para a fase de treinamento. É aqui onde é ensinado o que é o certo para que a rede neural aprenda por si só. Esta fase consiste na modificação dos pesos e do limiar do neurônio M-P até que ele resolva o problema de interesse ou que o período de aprendizagem tenha finalizado. Esse processo de modificação dos parâmetros é guiado pelo erro entre a saída desejada e a saída gerada pela rede e pelo valores de entrada de x.

Uma regra de aprendizagem tem a seguinte forma:

onde:
- w(t) é a memória (conhecimento atual) do sistema;
- e(t) é a diferença (erro) entre a saída desejada [d(t)] e a saída obtida [y(t)];
- x(t) é o vetor de entradas.
- h é chamado de fator de aprendizagem a fim de tornar o processo de ajuste do vetor w mais estável.

O diagrama de blocos de um neurônio em fase de treinamento é o seguinte:
Vamos executar a fórmula da aprendizagem para a porta-lógica OU (OR) adotando h = 1 e seguindo os seguintes passos:

Primeiro temos que ter o gabarito para ensinarmos o que é o certo para o neurônio. Para o caso da porta lógica nós temos as entradas possíveis e as saídas desejadas possíveis:

[x1][x2][d]
|0 ||0 ||0|
|0 ||1 ||1|
|1 ||0 ||1|
|1 ||1 ||1|
Agora iniciaremos os pesos e o limiar do neurônio com valor zero para que, sozinho, eles se ajustem até resolver nosso problema.
                      [-1]
                        |
                        |q
                w1      |
         [x1]-------> |¯¯¯|
                      |   |------> Y
         [x2]-------> |___|
                w2

Para t = 0: Iniciar com zeros os pesos e o limiar: w1(0)=w2(0)=q(0)=0
Logo,
      | q(0)| |0|                     |  -1 |
w(0)= |w1(0)|=|0|                x(t)=|x1(t)|
      |w2(0)| |0|                     |x2(t)|

Para t = 1: Calcular a saída para w(1)=[0 0 0] e x(1)=[-1 0 0]:
u(1) = (0)(-1) + (0)(0) + (0)(0) = 0;
y(1) = 0, (pois u <= 0)
e(1) = d - y = 0 - 0 = 0;
                          |0|           |-1| |0|
w(2) = w(1) + he(1)x(1) = |0| + (0,5)(0)|0 | = |0| = w(1)
                          |0|           |0 |   |0|

Para t = 2: Calcular a saída para w(2)=[0 0 0] e x(2)=[-1 0 1]:
u(2) = (0)(-1) + (0)(0) + (0)(1) = 0;
y(2) = 0, (pois u <= 0)
e(2) = d - y = 1 - 0 = 1;

                          |0|           |-1|   |-0,5|
w(3) = w(2) + he(2)x(2) = |0| + (0,5)(1)|0 | = | 0 |
                          |0|           |1 |   | 0,5|

Para t = 3: Calcular a saída para w(3)=[-0,5 0 0,5] e x(3)=[-1 1 0]:
u(3) = (-0,5)(-1) + (0)(1) + (0,5)(0) = 0,5;
y(3) = 1, (pois u > 0)
e(3) = d - y = 1 - 1 = 0;

w(4) = w(3)

Para t = 4: Calcular a saída para w(4)=[-0,5 0 0,5] e x(4)=[-1 1 1]:
u(4) = (-0,5)(-1) + (0)(1) + (0,5)(1) = 1;
y(4) = 1, (pois u > 0)
e(4) = d - y = 1 - 1 = 0;

w(5) = w(4) = w(3)

Para t = 5: Calcular a saída para w(5)=[-0,5 0 0,5] e x(5)=[-1 0 0]:
u(5) = (-0,5)(-1) + (0)(0) + (0,5)(0) = 0,5;
y(5) = 1, (pois u > 0)
e(5) = d - y = 0 - 1 = -1;

                          |-0,5|            |-1|   | 0 |
w(6) = w(5) + he(5)x(5) = | 0  | + (0,5)(-1)|0 | = | 0 |
                          | 0,5|            |1 |   |0,5|

Para t = 6: Calcular a saída para w(6)=[0 0 0,5] e x(6)=[-1 0 1]:
u(6) = (0)(-1) + (0)(0) + (0,5)(1) = 0,5;
y(6) = 1, (pois u > 0)
e(6) = d - y = 1 - 1 = 0;

w(7) = w(6)

Para t = 7: Calcular a saída para w(7)=[0 0 0,5] e x(7)=[-1 1 0]:
u(7) = (0)(-1) + (0)(1) + (0,5)(0) = 0;
y(7) = 0, (pois u <= 0)
e(7) = d - y = 1 - 0 = 1;

                          | 0 |           |-1|   |-0,5|
w(8) = w(7) + he(7)x(7) = | 0 | + (0,5)(1)|1 | = | 0,5|
                          |0,5|           |0 |   | 0,5|

Para t = 8: Calcular a saída para w(8)=[-0,5 0,5 0,5] e x(8)=[-1 1 1]:
u(8) = (-0,5)(-1) + (0,5)(1) + (0,5)(1) = 0,5;
y(8) = 1, (pois u > 0)
e(8) = d - y = 1 - 1 = 0;

w(9) = w(8)

Para t = 9: Calcular a saída para w(9)=[-0,5 0,5 0,5] e x(9)=[-1 0 0]:
u(9) = (-0,5)(-1) + (0,5)(1) + (0,5)(0) = 0,5;
y(9) = 1, (pois u > 0)
e(9) = d - y = 0 - 1 = -1;

                           |-0,5|            |-1|   | 0 |
w(10) = w(9) + he(9)x(9) = | 0,5| + (0,5)(-1)|0 | = |0,5|
                           | 0,5|            |0 |   |0,5|

Para t = 10: Calcular a saída para w(10)=[0 0,5 0,5] e x(10)=[-1 0 1]:
u(10) = (0)(-1) + (0,5)(0) + (0,5)(1) = 0,5;
y(10) = 1, (pois u > 0)
e(10) = d - y = 1 - 1 = 0;

w(11) = w(10)

Para t = 11: Calcular a saída para w(11)=[0 0,5 0,5] e x(11)=[-1 0 1]:
u(11) = (0)(-1) + (0,5)(1) + (0,5)(0) = 0,5;
y(11) = 1, (pois u < 0)
e(11) = d - y = 1 - 1 = 0;

w(12) = w(11) = w(10)

Para t = 12: Calcular a saída para w(12)=[0 0,5 0,5] e x(12)=[-1 1 1]:
u(12) = (0)(-1) + (0,5)(1) + (0,5)(1) = 1;
y(12) = 1, (pois u > 0)
e(12) = d - y = 1 - 1 = 0;

w(13) = w(12) = w(11) = w(10)

Para t = 13: Calcular a saída para w(13)=[0 0,5 0,5] e x(13)=[-1 0 0]:
u(13) = (0)(-1) + (0,5)(0) + (0,5)(0) = 0;
y(13) = 0, (pois u <= 0)
e(13) = d - y = 0 - 0 = 0;

w(14) = w(13) = w(12) = w(11) = w(10)

FIM!

Percebemos que os pesos estabilizaram, memória não mudou e o erro estabilizou em zero. Ou seja, esse conjunto de pesos satisfaz a solução do nosso problema. Após o treinamento os pesos obtidos são guardados para serem usados. Logo, o neurônio-modelo encontrado é:

        |q | | 0 |
    w = |w1|=|0,5|
        |w2| |0,5|

                      [-1]
                        |
                        |0
              0,5       |
         [x1]-------> |¯¯¯|
                      |   |------> Y
         [x2]-------> |___|
              0,5

Apesar desse modelo ser diferente do apresentado na semana passada, funciona tão bem quanto. Isso mostra que os pesos não são únicos para cada problema. Diferentes pesos podem sim levar às mesmas soluções.

Se para uma simples porta-lógica com entradas e saídas binárias houveram 13 etapas de treinamento, imaginem para uma situação mais complexa. Ainda que um computador faça as contas por nós, essa etapa pode durar horas e horas dependendo de cada problema.

Para quem não viu, aqui estão as outras partes dessa introdução às Redes Neurais Artificiais:
- Redes Neurais Artificiais [#1]
- Redes Neurais Artificiais [#2]

Todo conteúdo baseado nas aulas do prof. Guilherme do Departamento de Teleinfomática da Universiade Federal do Ceará.