Docsity
Docsity

Prepare-se para as provas
Prepare-se para as provas

Estude fácil! Tem muito documento disponível na Docsity


Ganhe pontos para baixar
Ganhe pontos para baixar

Ganhe pontos ajudando outros esrudantes ou compre um plano Premium


Guias e Dicas
Guias e Dicas

Implementação do Backpropagation usando Matlab, Notas de estudo de Cultura

Esse tutorial ensina implementar um algoritmo Backpropagation em Matlab

Tipologia: Notas de estudo

2011

Compartilhado em 06/06/2011

nielsen-damasceno-7
nielsen-damasceno-7 🇧🇷

2 documentos

1 / 8

Toggle sidebar

Esta página não é visível na pré-visualização

Não perca as partes importantes!

bg1
1
Prof. M.Sc. Nielsen Castelo Damasceno – www.ncdd.com.br – E-mail: nielsen.tekla@gmail.com
REDE NEURAL BACKPROPAGATION
Tutorial
Nielsen Castelo Damasceno
1 Introdução
Um modelo matemático de uma rede neural biológica 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.
Figura 1 – Arquitetura de uma RNA.
I é a camada de entrada com 3 neurônios, H é a camada oculta com 1
neurônio e O é a camada de saída com 2 neurônios
Todos os neurônios da camada de entrada são conectados à todos os
neurônios da camada escondida (oculta). Similarmente, o neurônio da camada
oculta é conectado a todos os neurônios da camada de saída. Essa conexão é feita
através dos pesos.
O número de neurônios na camada de entrada é igual ao tamanho do vetor
de entrada da RNA. Analogamente, o número de neurônios na camada de saída é
igual ao tamanho do vetor de saída da RNA. O tamanho da camada oculta é
opcional e podendo ser alterado de acordo com sua necessidade.
I1
I2
I3
H1
O2
O1
Camada de entrada
(I)
Camada de saída
(O)
Camada oculta
pf3
pf4
pf5
pf8

Pré-visualização parcial do texto

Baixe Implementação do Backpropagation usando Matlab e outras Notas de estudo em PDF para Cultura, somente na Docsity!

REDE NEURAL BACKPROPAGATION

Tutorial Nielsen Castelo Damasceno 1 Introdução Um modelo matemático de uma rede neural biológica 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.

Figura 1 – Arquitetura de uma RNA. I é a camada de entrada com 3 neurônios, H é a camada oculta com 1 neurônio e O é a camada de saída com 2 neurônios Todos os neurônios da camada de entrada são conectados à todos os neurônios da camada escondida (oculta). Similarmente, o neurônio da camada oculta é conectado a todos os neurônios da camada de saída. Essa conexão é feita através dos pesos. O número de neurônios na camada de entrada é igual ao tamanho do vetor de entrada da RNA. Analogamente, o número de neurônios na camada de saída é igual ao tamanho do vetor de saída da RNA. O tamanho da camada oculta é opcional e podendo ser alterado de acordo com sua necessidade.

I 1

I 2

I 3

H 1

O 2

O 1

Camada de entrada

(I)

Camada de saída

(O)

Camada oculta

Para todos os vetores de entrada, a correspondente saída do vetor é calculada de acordo com a expressão: [ ] ([ ] [ ] [ ]) [ _ ] ([ _ ] *[ _ 2 ] [ 2 ])

_ _ _ 1 1

vetor saída função vetor oculto matriz peso bias

vetor oculto função vetor entrada matriz peso bias = +

Caso a operação [^ vetor _ entrada ]^ ∗ [ matriz^ _ peso 1 ]for zero, consequentemente a saída do vetor também vai ser zero. Isso pode ser evitado utilizando um vetor chamado de Bias. Portanto, o bias, será somado a [ vetor _ entrada ] ∗ [ matriz _ peso 1 ]. A função comumente utilizada na expressão (1) é representada por:

[ 1 exp( )] log ( )^1 sig x = (^) + − x (2)

[ 1 exp( 2 )] tan ( )^2 sig x = (^) + − x (3) O objetivo da RNA é encontra os vetores de pesos e bias de acordo com os vetores de entrada e desejado. O processo de obtenção dos pesos e os bias é chamado de treinamento. Considere a arquitetura dada pela figura 1. O número de neurônios na camada de entrada é 3, o número de neurônios na camada de saída é 2 e o número de neurônios na camada oculta é 1. Os pesos conectados no i-ésimo neurônio na primeira camada e o j-ésimo neurônio na camada oculta são representados por wij. O peso conectado no i-ésimo neurônio na camada oculta e j-ésimo neurônio na camada de saída são representados por w ij '. Seja um vetor de entrada representado por [ i (^) i i 2 i 3 ]. A camada oculta é representada por [ h 1 ]e o vetor de saída é representado por [ o (^) i o 2 ]. O vetor bias da camada oculta é representado por [ b (^) h ]e o bias da camada de saída é representado por [ b 1 (^) b 2 ]. E finalmente, o vetor de saída desejada é dado por [ t 1 (^) t 2 ]. A seguir, descreve-se um resumo de todos os processos envolvendo todos os vetores. h 1 (^) = função ( w 11 * i 1 + w 21 * i 2 + w 31 * i 3 + bh ) (4) o 1 (^) = função ( w 11 '* h 1 + b 1 ) (5) o 2 (^) = função ( w 12 '* h 1 + b 2 ) (6) t 1 (^) ~ = o 1 (7)

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 saída para cada correspondente vetor de entrada [ i (^) i i 2 i 3 ]
  4. Ajuste os pesos de acordo com os seguintes procedimentos: a. Entre a camada escondida e saída W 11 (^) ' ( n + 1 )= W 11 '( n )+ γ o ( t 1 − o 1 )* h 1 W 12 (^) ' ( n + 1 )= W 12 '( n )+ γ o ( t 2 − o 2 )* h 1 b. Entre a camada entrada e escondida W 11 (^) ( n + 1 )= W 11 ( n )+ γ H * e * i 1 W 21 (^) ( n + 1 )= W 21 ( n )+ γ H * e * i 2

W 31 ( n + 1 )= W 31 ( n )+ γ H * e * i 3

e ’ é o erro estimado na camada oculta usando o erro calculado na camada de saída, ou seja, e = h 1 * ( 1 − h 1 )*[(^ t 1 − o 1 )+( t 2 − o 2 )]

  1. Faça o ajuste do Bias

bh ( n + 1 )= bh ( n )+ e * λ H

b 1 ( n + 1 )= b 1 ( n )+( t 1 − o 1 )* λ O

b 2 ( n + 1 )= b 2 ( n )+( t 2 − o 2 )* λ O

  1. Volte para o passo 3 até 5 para todos os pares de vetores entrada e o correspondente vetor desejado.
  2. Seja d 1 , d (^) 2 ,L , dn os vetores desejado e y 1 , y (^) 2 ,L , yn o correspondente vetor de saída calculado usando a atualização dos pesos e bias. A soma do quadrado do erro é calculada como: SQE = ( d 1 − y 1 )^2 +( d 2 − y 2 )^2 +L+( dnyn )^2
  3. Volte para o passo 3 até 5 enquanto não encontrar um SQE que satisfaça um critério desejado.

Para incluir o termo de momento durante o treinamento, devemos fazer a seguinte modificação da expressão descrita no passo 4:

'( 1 ) 11 11 1 1 1 11

W n W n ot o h o W n W n

∆ +

γ 1 4 2 4 4 3 4 ρ

W 12 (^) ' ( n + 1 )= W 12 '( n )+∆ W 12 '( n + 1 )+ ρ o *∆ W 12 '( n ) W 11 ( n + 1 )= W 12 ( n )+∆ W 11 ( n + 1 )+ ρ H *∆ W 11 ( n ) W 21 (^) ( n + 1 )= W 21 ( n )+∆ W 21 ( n + 1 )+ ρ H *∆ W 21 ( n )

W 31 ( n + 1 )= W 31 ( n )+∆ W 31 ( n + 1 )+ ρ H *∆ W 31 ( n )

( 1 )

b n b n e H bh n h h b hnH

∆ +

b 1 ( n + 1 )= b 1 ( n )+∆ b 1 ( n + 1 )+ ρ o *∆ b 1 ( n )

b 2 ( n + 1 )= b 2 ( n )+∆ b 2 ( n + 1 )+ ρ o *∆ b 2 ( n )

onde, ρ H e ρ o é o termo do momento usado na camada oculta e camada de saída,

respectivamente. 4 Exemplo Considere o exemplo dos padrões de entrada e saída desejada a seguir:

Figura 2 – Padrão de treinamentos. Parâmetros da RNA:

  • 3 camadas
  • 3 neurônios na camada de entrada
  • 1 neurônio na camada escondida
  • 2 neurônios na camada de saída
  • Taxa de treinamento: 0,

E finalmente, utilizando uma função de arredondamento no matlab temos o seguinte resultado.

disp(round(saida)); 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

5 Código-fonte clear; % padrão clc;close de entrada all; entrada N = length(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]; % desejado saída desejada = [0 0;0 1;0 1 ;0 1;0 1;0 1;0 1 ;1 1]; % nin Parametros = size(entrada,2); da RNA % Número de neuronios na camada entrada nout SSE =[= size(desejado,2);]; INDEX=[ ]; % Número de neurônios na camada de saída

W1 W2 == rand(nin,1);rand(1,nout); B1 B2 == rand;rand(1,2); % eta Taxa = 1e-3;de aprendizagem epoca for i == 200;1:epoca for (^) Hj == funcao(entrada1:N * W1 + repmat(B1,[8 1]));

saida %saida = =W2' H ** W2H (^) ++ repmat(B2,[8repmat(B2,[8 1]);1])'; ERR_HO ERR_IH == desejado(H.(1-H))'.(sum(ERR_HO')'); - saida'; W2(1,1) W2(1,2) == W2(1,1)W2(1,2) ++ ERR_HO(j,1)ERR_HO(j,2) ** H(1,j)*H(1,j) *eta; eta; W1(1,1) W1(2,1) == W1(1,1)W1(2,1) ++ ERR_IH(j,1)ERR_IH(j,1) ** entrada(j,1)entrada(j,2) ** eta;eta; W1(3,1) B1 = B1 =+ W1(3,1)ERR_IH(j,1) + ERR_IH(j,1) * eta; * entrada(j,3) * eta; B2(1,1) B2(1,2) == B2(1,1)B2(1,2) ++ ERR_HO(j,1)ERR_HO(j,2) ** eta;eta; end INDEX = [INDEX i]; SSE plot(INDEX,SSE, = [SSE sum(sum(ERR_HO.^2))];'r'); xlabel( ylabel('Iteração''Soma do erro) ao quadrado (SSE)') pause(0.05); disp(i); end H = logsig(entrada * W1 + repmat(B1,[8 1])); saida disp(round(saida)); = H * W2 + repmat(B2,[8 1]);

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

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

Referências [1] E. S. Gopi. “Algorithm Collections for digital signal processing application using Matlab”, Springer. 2007.