PDF de programación - Back-Propagation learning

3. Para p=1, 2, … (los patrones, cíclicamente)
Para l = L, L-1, … (las capas)
Para todos los k,j en la capa l (los pesos)
εk
p w p
l
,
(
Calcule el error
kj
τ
y
p
L
(
(
)

]
k
k

N

+
l
ε
+
l
1

v

p w p
,
(

−
(

ε
l
k

[

]

)
1

[

−

=

l
kj

l
kj



=
1

l
v

v

l

1

)

1
)

)− 1 así:
p w
l
,
[
kj
−
p w p
,
(
(
E p W, 
en w pkj
l (
[
′
f u p w p
(

]
)
p w p
w
1
(
,
)
)− 1 así:
]

′
f u

1
))

1
))

−

−

)

y

−

(

l
kj

,

1

l
kj

−
l
1
j

(

p

)



si
)

l=L
otro
l
1
)

(

−

p

(

+

+
l
1
vk

BACK-PROPAGATION LEARNING


1. Asigne pesos iniciales w
2. Seleccione la constante de aprendizaje η( )0 -puede decrementarse
con el tiempo-.

( )0 para todos los k,j,l.

l=
w
kj

l
kj

Calcule el gradiente de

)

(

∂
E p W
,
∂
w
l
kj

= −

ε
l
k

(

p w p
,
(

l
kj


Actualice el valor de este peso mediante
)

l
k

(

∂
E p W
∂
w

,
l
kj

w p
(

l
kj

)

−

−1 η
)
(

p

)

=

w p
(

l
kj



Siguiente peso
Siguiente capa
Siguiente patrón (cíclicamente, hasta que el cambio en
los pesos sea insignificante)



El anterior es el algoritmo de aprendizaje BPL, como aparece en la mayoría de libros sobre
redes neuronales. Resulta muy difícil de leer y, con mayor razón, de entender. Sin embargo,
entre toda esa maraña de subíndices y superíndices, podemos descubrir en la última
ecuación que unas variables w se están actualizando con un incremento negativamente
proporcional a la derivada de una función E(w). Parece ser que el algoritmo BPL quiere
minimizar E(w), de acuerdo con el “método del gradiente”….


Método del Gradiente



f(x)

df x
(
dx
df x
(
dx
df x
(
dx

)2

)3

)1

0<



x
aumentar



1

0=



x
dejar

0>



x
disminuir



2

3

df x
− η (
ant
dx



)



=

x 1

x2

x 3

x

sig

=

x

ant

x

Efectivamente, si queremos encontrar el mínimo de f(x) y estamos en un punto donde f’(x)
es negativa, será necesario incrementar x en busca del mínimo. Pero si f’(x) es positiva,
debemos decrementar x. Esto es, debemos movernos en el sentido contrario al de la
derivada, como parecía sugerir el algoritmo BPL. Una constante de proporcionalidad η
determinará la magnitud de ese movimiento.

f(x)

1.0

0.8

0.6

0.4

0.2

0

-2

0

2

4

6

x

1

(

)
5

2

+

+

−



2

3

x

2

x

3

x

05
.

1000

f x
( )

double derivada(double x)
{
return (x3+6x2-4x+10)(1.5x2+6x-2)/1000;
}
void main(void)
{
double x, xant, Eta;
cout << " Eta ? "; cin >> Eta;
cout << "x inicial ? "; cin >> x;
do
{
xant = x;
x = xant - Eta * derivada(xant);
} while(fabs(x - xant) > 0.000001);
}


El anterior programa en C muestra el procedimiento para buscar el mínimo de una f(x)
particular, dados un punto inicial y una constante de proporcionalidad η. El algoritmo
termina cuando el incremento sea insignificante.



f(x)

1.0

0.8

0.6

0.4

0.2

0

-2

0

2

4

6

x



f '() = -1
f '() = -0.1995

1

n

n

n

x

−

+ =

η (
f x

x
Eta ? 1
x inicial ? -2
0: f(-2) = 0.625

1: f(-1) = 0.11025

2: f(-0.8005) = 0.0770863
f '() = -0.136338
3: f(-0.664162) = 0.0608111 f '() = -0.103663
4: f(-0.5605) = 0.0511443
f '() = -0.0834473
5: f(-0.477052) = 0.0447711 f '() = -0.069637
…
222: f(0.366984) = 0.0215793
223: f(0.366985) = 0.0215793


NO LLEGO AL VERDADERO MINIMO!



d
dx

)

f '() = -1.04596e-006
f '() = -9.98351e-007



f '() = -0.1425

f '() = 0.124007
f '() = -0.124007
f '() = 0.124007
f '() = -0.124007

Eta ? 5
x inicial ? 5

0: f(5) = 0.05625
1: f(5.7125) = 0.00300695
f '() = 0.0578272
2: f(5.42336) = 0.00693551 f '() = -0.0715223
3: f(5.78098) = 0.00842207 f '() = 0.101246 INESTABLE!
….
2147: f(5.81376) = 0.0121104
2148: f(5.19372) = 0.0301088
2149: f(5.81376) = 0.0121104
2150: f(5.19372) = 0.0301088

Eta ? 2
x inicial ? 5
0: f(5) = 0.05625
1: f(5.285) = 0.0194959
2: f(5.50024) = 0.00243065 f '() = -0.0448307 A VECES
3: f(5.5899) = 5.17009e-005 f '() = -0.00697191 FUNCIONA!
4: f(5.60384) = 1.57654e-007
5: f(5.60462) = 2.65361e-010
6: f(5.60465) = 4.29573e-013
7: f(5.60466) = 6.94282e-016


Las anteriores ejecuciones muestran que, con distintos valores de xinicial y η, el algoritmo
anterior puede tener resultados insatisfactorios : Convergir a un mínimo local o,
sencillamente, no convergir. Sin embargo, !A veces funciona!


f '() = -0.000388774
f '() = -1.59587e-005
f '() = -6.42109e-007
f '() = -2.58142e-008

f '() = -0.1425
f '() = -0.10762



w

1
w2
w
3
wN

x1

x2

x

3

xN



z

z

= 
f



w0
x = -1
0



N



=

n

0

w xn

n







Modelo de un elemento computacinal



Para un X = { x1, x2, …, xN }, debería producirse zi
pero, dados unos pesos W = {w0, w1, …, wN}, la

neurona produce zr.


Pues bien, en un elemento computacional de una red neuronal que recibe como entrada un
patrón {x1, x2, …, xN } se produce un error si la salida real zr difiere de la salida ideal zi. ¿Si
zr es función de los pesos wk, porqué no seleccionar los pesos para minimizar el error zi - zr?
zi - zr |zi - zr| (zi - zr)2



0

2

4

0

2

4

0

2

4



Bueno, en principio minimizar el error podría conducirnos a un gran error negativo y lo que
queremos es que el error sea cero. La función valor absoluto incluye mínimos en los puntos
en que el error sea cero, pero como el método del gradiente exige derivar, preferimos
trabajar con el error cuadrado:


APRENDER : Minimizar el error cuadrado


W
n

+ =

1


W
n

− ∇
η

−

z
i

(



(

z W
r

)
)

2






Como cada peso se va a actualizar de acuerdo con la respectiva derivada parcial del error
cuadrado, el vector de pesos completo se actualiza de acuerdo con el vector gradiente.

Por ejemplo, queremos enseñar a la siguiente red neuronal a que responda con zi cuando a
la entrada tenga un punto particular (x,y), y para eso buscaremos los pesos (a,b,c) que
minimicen el error. La función de activación utilizada es la sigmoide.


b

c

z = f(s)

s = ax + by - c

f s
( )

=

+

1

1
exp(

−

s

)



1.0

0.5

0.0

-10

-5

0

5

10

a

x

y

-1



E


a

i=
z
(

−

z

) 2

=

2

e

(Error cuadrado)

+ =

1

n

a

n

−

∂
E
η
∂ b
a

n

+ =

1

b
n

−

n

∂
E
η
∂ c
b
n

+ =

1

n

c

n

−

η

∂
E
∂ (método del gradiente)
c

n

−

=

z

)

z

)

2

(

z

∂
(


Las derivadas parciales del error cuadrado están en términos de la derivada de la función de
activación:

∂
E
∂α
+ =
a

En este caso particular, la derivada de z=f(s) se expresa fácilmente en términos de z:
z

−
z
i
∂α
η '( )
ef
s x

df s
( )
ds
+ =

∂
s
∂α
−
c
n

(
2

= −

∂
z
∂α
η '( )
s y
ef

η '( )
ef
s

c
n

b
n

f s
( )

+ =

1

(
2

= −

= −

2

ef

(
1

b
n

z

i

′

s
( )

z

i

+

a

n

+

n

1

−

−

s

e

−

)

z

)

z

)

−

1

+

=

1

i



∂
s
∂α

=

−

1
+
e
+
e

1
(
)
1 1

=
)

−

s

−

s

f

s
'( )

= −
(

2

−

(

)
1

e

−

s

=

(
1
f s
( )

)

−

e
+
e
(
1

s

−

s

−

s

−

1
+
e
)
=

=

2

1
f s
( )

1

z

−

+
1
(
1

e
s
+
e
−

1

−
−
s

=

1
+
e

1

−

s

−

1




1
+
e

1

−

s




z

)



f

s
'( )

=

+ =

1

n

a

n

+

1η (
ez

−

z x
)

b
n

+ =

1

b
n

+

1η (
ez

−

z y
)

c
n

+ =

1

c
n

−

1η (
ez

−

z

)


a


Las anteriores tres ecuaciones determinan el algoritmo de entrenamiento para la red
mostrada arriba


1
exp(

−

s

)



f s
( )

=

+

1

1.0

0.5

a

x

y

-1

b

c

z = f(s)

s = ax + by - c

0

5

10

0.0

-10

-5


double f(double s)
{
return 1.0/(1.0 + exp(-s));
}
void main(void)
{
double x = -1, y = 2, zi = 1;
double Eta=2, a = 1, b = 1, c = 1;
double z, e, Delta;
do
{
z = f(a*x + b*y - c);
e = zi - z;
Delta = Eta*e*z*(1-z);
cout << a << b << c << z << e << Delta << endl;
a += Delta*x;
b += Delta*y;
c -= Delta;
} while(fabs(e) > 0.1);
}

Por ejemplo, el anterior programa busca los pesos a,b,c que minimicen el error cuadrado si
se quiere que la red produzca 1.0 cuando las entradas sean (-1,2). Como se dijo, la función
sigmoide utilizada tiene la particularidad de que f’(s) = f(s)*(1-f(s)), y el programa usa esta
propiedad al calcular Delta en el tercer renglón de la iteración. La siguiente tabla muestra la
salida del programa anterior, que después de 5 iteraciones le enseñó a la red a clasificar
el punto (-1,2). Por supuesto, una red neuronal que sepa clasificar un punto y tenga una
salida incierta para los demás puntos es absolutamente inútil!

--------------------------------------------------------------------------------------------------------------------------------------------
a
---------------------------------------------------------------------------------------------------------------------------------------------

1
0.75

0.695584
0.662464
0.638451

0.5

0.182426
0.138656
0.116581
0.102542

0.5

0.817574
0.861344
0.883419
0.897458


1
0.75

0.695584
0.662464
0.638451

b



1
1.5

1.60883
1.67507
1.7231

z



c



e



d



0.25
0.0544162
0.0331195
0.0240133
0.0188733

0.619578


1.76084

0.619578

0.90742