1

REDE NEURAL BACKPROPAGATION

Tutorial Nielsen Castelo Damasceno 1 Introduo Um modelo matemtico de uma rede neural biolgica pode ser definido por uma Rede Neural Artificial (RNA). O modelo de rede neural bastante utilizado o backpropagation. Este modelo consiste na arquitetura representada pela figura 1.

Camada de entrada (I)

Camada de sada (O)

I1
Camada oculta

O1 I2 I3
Figura 1 Arquitetura de uma RNA. I a camada de entrada com 3 neurnios, H a camada oculta com 1 neurnio e O a camada de sada com 2 neurnios Todos os neurnios da camada de entrada so conectados todos os neurnios da camada escondida (oculta). Similarmente, o neurnio da camada oculta conectado a todos os neurnios da camada de sada. Essa conexo feita atravs dos pesos. O nmero de neurnios na camada de entrada igual ao tamanho do vetor de entrada da RNA. Analogamente, o nmero de neurnios na camada de sada igual ao tamanho do vetor de sada da RNA. O tamanho da camada oculta opcional e podendo ser alterado de acordo com sua necessidade.

H1 O2

Prof. M.Sc. Nielsen Castelo Damasceno www.ncdd.com.br E-mail: nielsen.tekla@gmail.com

Para todos os vetores de entrada, a correspondente sada do vetor calculada de acordo com a expresso:

[vetor _ oculto] = funo([vetor _ entrada] [matriz _ peso1] + [bias1]) (1) [vetor _ sada] = funo([vetor _ oculto]* [matriz _ peso2] + [bias 2]) Caso a operao [vetor _ entrada] [matriz _ peso1] for zero, consequentemente a
sada do vetor tambm vai ser zero. Isso pode ser evitado utilizando um vetor chamado de Bias. Portanto, o bias, ser somado a

[vetor _ entrada] [matriz _ peso1] .

A funo

comumente utilizada na expresso (1) representada por:

log sig ( x) = tan sig ( x) =

1 [1 + exp( x)] 2 [1 + exp(2 x)]

(2) (3)

O objetivo da RNA encontra os vetores de pesos e bias de acordo com os vetores de entrada e desejado. O processo de obteno dos pesos e os bias chamado de treinamento. Considere a arquitetura dada pela figura 1. O nmero de neurnios na camada de entrada 3, o nmero de neurnios na camada de sada 2 e o nmero de neurnios na camada oculta 1. Os pesos conectados no i-simo neurnio na primeira camada e o j-simo neurnio na camada oculta so representados por wij . O peso conectado no i-simo neurnio na camada oculta e j-simo neurnio na camada de sada so representados por wij . Seja um vetor de entrada representado por [ii
i2 i3 ] . A camada oculta o2 ] . O vetor bias da
'

representada por [h1 ] e o vetor de sada representado por [oi

camada oculta representado por [bh ] e o bias da camada de sada representado por [b1 b2 ] . E finalmente, o vetor de sada desejada dado por [t1 t 2 ] . A seguir, descreve-se um resumo de todos os processos envolvendo todos os vetores.
h1 = funo( w11 * i1 + w21 * i2 + w31 * i3 + bh )

(4) (5) (6) (7)

o1 = funo( w11 '*h1 + b1 ) o2 = funo( w12 '*h1 + b2 ) t1 ~ = o1

Prof. M.Sc. Nielsen Castelo Damasceno www.ncdd.com.br E-mail: nielsen.tekla@gmail.com

t 2 ~ = o2

(8)

2 Uma arquitetura simples

Considere uma arquitetura com uma nica camada de entrada e uma nica camada de sada, que pode ser expresso por:

sada = funo(entrada * W + B)

(9)

O vetor de sada desejada representado por desejado . O objetivo encontrar um melhor W tal que a funo custo igual a (desejado sada) 2 seja minimizada. Para obter os melhores pesos. Inicializamos os vetores de pesos e fazemos umas modificaes nesses pesos iterativamente. Os melhores pesos so obtidos depois de um finito nmero de iterao no algoritmo. A mudana dos vetores de pesos em toda iterao representado por W , ou seja,

W (n + 1) = W (n) + W (n + 1)

(10)

Assim, o vetor de peso ajustado da seguinte forma:

novopeso = velhopeso * valor _ corrente _ da _ funo _ custo

Funo _ Custo(C ) = (desejado sada )
2

C = (desejado funo(entrada * W + B ))

A curva da funo custo calculada usando a derivada de C em funo de W e pode ser aproximada por [1]:

2((desejado funo(entrada * W + B)) * (entrada))

= 2 * erro * entrada

Portanto, W (n + 1) = W (n) 2 * * erro * (entrada) .

W (n + 1) = W (n) + erro * entrada

Este o backpropagation, pois o erro repropagado nas camadas para ajustar os pesos.

Prof. M.Sc. Nielsen Castelo Damasceno www.ncdd.com.br E-mail: nielsen.tekla@gmail.com

3 Algoritmo O algoritmo backpropagation para a arquitetura da figura 1 descrito a seguir. 1. Inicialize aleatoriamente as matrizes de pesos. 2. Inicialize aleatoriamente os bias. 3. Calcule a sada para cada correspondente vetor de entrada [ii 4. Ajuste os pesos de acordo com os seguintes procedimentos: a. Entre a camada escondida e sada W11 ' (n + 1) = W11 ' (n) + o(t1 o1 ) * h1

i2

i3 ]

W12 ' (n + 1) = W12 ' (n) + o(t 2 o2 ) * h1 b. Entre a camada entrada e escondida W11 (n + 1) = W11 (n) + H * e * i1 W21 (n + 1) = W21 (n) + H * e * i2
W31 (n + 1) = W31 (n) + H * e * i3

e o erro estimado na camada oculta usando o erro calculado na camada de sada, ou seja, e = h1 * (1 h1 ) * [(t1 o1 ) + (t2 o2 )]

5. Faa o ajuste do Bias

bh (n + 1) = bh (n) + e * H b1 (n + 1) = b1 (n) + (t1 o1 ) * O b2 (n + 1) = b2 (n) + (t 2 o2 ) * O

6. Volte para o passo 3 at 5 para todos os pares de vetores entrada e o correspondente vetor desejado. 7. Seja d1 , d 2 , L , d n os vetores desejado e y1 , y2 , L , yn o correspondente vetor de sada calculado usando a atualizao dos pesos e bias. A soma do quadrado do erro calculada como:
SQE = (d1 y1 ) 2 + (d 2 y2 ) 2 + L + (d n yn ) 2

8. Volte para o passo 3 at 5 enquanto no encontrar um SQE que satisfaa um critrio desejado.

Para incluir o termo de momento durante o treinamento, devemos fazer a seguinte modificao da expresso descrita no passo 4:

Prof. M.Sc. Nielsen Castelo Damasceno www.ncdd.com.br E-mail: nielsen.tekla@gmail.com

W11 ' (n + 1) = W11 ' (n) + o(t1 o1 ) * h1 + o * W11 ' (n) 14 244 4 3
W11 '( n+1)

W12 ' (n + 1) = W12 ' (n) + W12 ' (n + 1) + o * W12 ' (n) W11 (n + 1) = W12 (n) + W11 (n + 1) + H * W11 (n) W21 (n + 1) = W21 (n) + W21 (n + 1) + H * W21 (n)

W31 (n + 1) = W31 (n) + W31 (n + 1) + H * W31 (n)

bh (n + 1) = bh (n) + e * H + H * bh (n) 13 2
bh ( n +1)

b1 (n + 1) = b1 (n) + b1 (n + 1) + o * b1 (n) b2 (n + 1) = b2 (n) + b2 (n + 1) + o * b2 (n) onde, H e o o termo do momento usado na camada oculta e camada de sada, respectivamente. 4 Exemplo Considere o exemplo dos padres de entrada e sada desejada a seguir:

Figura 2 Padro de treinamentos. Parmetros da RNA: 3 camadas 3 neurnios na camada de entrada 1 neurnio na camada escondida 2 neurnios na camada de sada Taxa de treinamento: 0,001

Prof. M.Sc. Nielsen Castelo Damasceno www.ncdd.com.br E-mail: nielsen.tekla@gmail.com

Funo de transferncia usado na camada oculta (equao 2). Funo de transferncia usado na camada de sada linear. Nmero mximo de iteraes 200.
6.5 6 Soma do erro ao quadrado (SSE) 5.5 5 4.5 4 3.5 3 2.5

20

40

60

80

100 120 Iterao

140

160

180

200

Figura 3 Grfico da soma do erro ao quadrado a cada nmero de iterao. Depois de 200 iteraes o algoritmo apresentou os seguintes resultados: >> W1 W1 = 0.57521 0.05978 0.23478

>> W2 W2 = 0.32897 >> saida saida = 0.25326 0.27252 0.25817 1.0541 1.097 1.065 0.73321

Prof. M.Sc. Nielsen Castelo Damasceno www.ncdd.com.br E-mail: nielsen.tekla@gmail.com

0.27737 0.29955 0.31693 0.30409 0.32114

1.1078 1.1573 1.196 1.1674 1.2054

E finalmente, utilizando uma funo de arredondamento no matlab temos o seguinte resultado. >> disp(round(saida)); 0 0 0 0 0 0 0 0 >> 5 Cdigo-fonte
clear; clc;close all; % padro de entrada entrada = [0 0 0;0 0 1;0 1 0;0 1 1;1 0 0;1 0 1;1 1 0;1 1 1]; N = length(entrada); % sada desejada desejado = [0 0;0 1;0 1 ;0 1;0 1;0 1;0 1 ;1 1]; % Parametros da RNA nin = size(entrada,2); % Nmero de neuronios na camada entrada nout = size(desejado,2); % Nmero de neurnios na camada de sada SSE =[ ]; INDEX=[ ]; W1 = rand(nin,1); W2 = rand(1,nout); B1 = rand; B2 = rand(1,2); % Taxa de aprendizagem eta = 1e-3; epoca = 200; for i = 1:epoca for j = 1:N H = funcao(entrada * W1 + repmat(B1,[8 1]));
Prof. M.Sc. Nielsen Castelo Damasceno www.ncdd.com.br E-mail: nielsen.tekla@gmail.com

1 1 1 1 1 1 1 1

8
saida = W2' * H + repmat(B2,[8 1])'; %saida = H * W2 + repmat(B2,[8 1]); ERR_HO = desejado - saida'; ERR_IH = (H.*(1-H))'.*(sum(ERR_HO')'); W2(1,1) W2(1,2) W1(1,1) W1(2,1) W1(3,1) B1 = B1 B2(1,1) B2(1,2) = = = = = + = = W2(1,1) + ERR_HO(j,1) W2(1,2) + ERR_HO(j,2) W1(1,1) + ERR_IH(j,1) W1(2,1) + ERR_IH(j,1) W1(3,1) + ERR_IH(j,1) ERR_IH(j,1) * eta; B2(1,1) + ERR_HO(j,1) B2(1,2) + ERR_HO(j,2) * * * * * H(1,j)* eta; H(1,j) * eta; entrada(j,1) * eta; entrada(j,2) * eta; entrada(j,3) * eta;

* eta; * eta;

end INDEX = [INDEX i]; SSE = [SSE sum(sum(ERR_HO.^2))]; plot(INDEX,SSE,'r'); xlabel('Iterao') ylabel('Soma do erro ao quadrado (SSE)') pause(0.05); disp(i); end H = logsig(entrada * W1 + repmat(B1,[8 1])); saida = H * W2 + repmat(B2,[8 1]); disp(round(saida));

function [res]=funcao(x) res = 1/(1+exp(-x)); end

OBS.: O cdigo-fonte pode ser baixado no meu site em http://www.ncdd.com.br.

Referncias [1] E. S. Gopi. Algorithm Collections for digital signal processing application using Matlab, Springer. 2007.

Prof. M.Sc. Nielsen Castelo Damasceno www.ncdd.com.br E-mail: nielsen.tekla@gmail.com