Algoritmos genéticos y redes neuronales

Algoritmos genéticos
El Perceptrón
Descenso por gradiente y «regla delta»
Redes multicapa
Retropropagación

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 1
UPM

Modelos basados en la naturaleza («biónicos»)

Ontogénesis
⇒ Modelos neurocibernéticos
Filogénesis
⇒ Modelos evolucionistas
«Al fin y al cabo, no hay tantas técnicas informáticas que hayan
demostrado su valor a lo largo de 3.000 millones de años de
pruebas de campo» (Forsyth, 1986)

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 2
UPM
 La evolución como modelo

Primeras ideas: Generación de

mutaciones al azar sobre el
población de individuos código binario de programas
(Frieldberg, 1958)
competición por recursos
Actualmente, énfasis en otros
selección
mecanismos genéticos, p. ej.,
entrecruzamiento de genes
combinación de adaptados
(crossover)
«Computación evolucionista:»
reproducción
• Algoritmos genéticos:
individuos = cadenas de bits
mutaciones
• Programación genética:
individuos = árboles sintácticos
de los programas

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 3
UPM

Optimización con algoritmos genéticos

Problema: encontrar el máximo/mínimo de f (x1, . . . xn)

Población: valores de (x1, . . . xn) en binario (cromosomas)
Operadores genéticos:
• Mutación (cambio de un bit con probabilidad pequeña)
• Selección de las parejas reproductoras (probabilidad
proporcional al valor de la función)
• Entrecruzamiento de los genomas de cada pareja
Nueva generacion: los hijos sustituyen a los individuos menos
adaptados
Convergencia: cuando hay muchos valores iguales
La mutación sirve para resolver el problema de los
máximos/mínimos locales

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 4
UPM
 Inducción de reglas con algoritmos genéticos
Problema: encontrar las mejores reglas para una BC
Población: la BC, con una medida de la bondad de cada regla
Operadores genéticos: sobre la codificación binaria de las reglas, o bien en
el nivel simbólico:
• Mutación:
si A y B enton es C ⇒ si A y D enton es C
• Entrecruzamiento (crossover):
si A y B y C enton es D ⇒ si A y G enton es H
si F y G enton es H ⇒ si F y B y C enton es D
• Inversión:
si F y G enton es H ⇒ si G y F enton es H
La medida de «bondad» o «fuerza» depende de la aplicación:
Clasificación: fallo o acierto
Predicción: cercanía al valor
Control: resultado de la acción de control

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 5
UPM

Ejemplo de entrecruzamiento en binario

Reglas padres:
[A1=valor11][A2=valor12] → [R=R1]
[A1=valor21][A2=valor22] → [R=R2]

Codificación: Aplicación:

A1 A2 R 11100100 máscara: 11110110

111 001 00 00011110
010 101 11 01010111 01000101

Reglas hijas:
[A1=valor11][A2=valor22] → [R=R3]
[A1=valor21][A2=valor12] → [R=R4]

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 6
UPM
 Sistema GABIL (DeJong et al., 1993)

Población: {reglas de orden 0+}

Evaluación de reglas:
f (r) = porcentaje de ejemplos
correctamente clasificados por r
En cada generación, p reglas (constante)
• a una fracción t se le aplica entrecruzamiento y se susti-
tuyen pos los hijos
• a una fracción m (muy pequeña) se le aplica mutación
Resultados: sobre 12 problemas sintéticos,
GABIL: 92,1 %
ID3, AQ, C4.5. . . : 91,2 % – 96,6 %

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 7
UPM

Operadores genéticos en GABIL

Selección aleatoria de (1 − t) · p reglas de la población actual

para añadir a la siguiente, con probabilidad:
f (ri)
P(ri) = p
∑ j=1 f (r j )
Entrecruzamiento entre t · p/2 pares de reglas de la población
actual (seleccionadas con la misma función), añadiendo el
resultado a la siguiente
Mutación de m · p reglas (con probabilidad uniforme) de la
población resultante

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 8
UPM
 GABIL: algoritmo

Inicio: P = {p reglas al azar}

Calcular f (ri), i = 1 . . . p
Mientras (máx f (ri) < umbral)
PS = 0/
PS = selecc(P,t)
PS = PS ∪ entrecruzamiento(P,t)
PS = mutac(PS , m)
P = PS
calcular f (ri)
Devolver r tal que f (r) es máxima

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 9
UPM

Neurona formal (McCulloch y Pitts, 1943)

e
1

e s=1 si ( ∑ ej ≥ U) y ( ∑ i k = 0)
n
i
1 U
e, i, s binarias
i U (umbral) entero
m

El modelo simula:
Sinapsis excitadoras e inhibidoras
Umbral de excitación
Sumación espacial

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 10
UPM
 Neuronas formales y lógica de proposiciones

x x x
1 1 1
x 3 x ·x ·x x 2 x ·x ·x x 1 x +x +x
2 1 2 3 2 1 2 3 2 1 2 3
x3 x3 x3

x1
1 x1 1
x
x x ·x ·x 2
1 1 x ·x ·x x 1 1 x ·x +x ·x
1 2 3 2 1 2 3 1 2 1 2
x x1
2 x3 1
x
x 2
3

McCulloch, W. and Pitts, W. (1943): A logical calculus of the ideas immanent in nervous activity.
Bulletin of Mathematical Biophysics, 7:115 - 133.

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 11
UPM

El Perceptron (Rosenblatt, 1958: 1943 + 15)

x0 =−1
x w0
1 w1 s = 1 si y > 0
y= w ·x
i i s = −1 si y <= 0

wn

xn

Conjunto de entrenamiento: E = {hx1, x2, . . . xn, ri}

xi ∈ [−1, 1]; wi ∈ [0, 1]; r ∈ {−1, 1}
Regla de entrenamiento basada en «castigo» de los wi
«culpables»:
Si s = −1 y r = 1 aumentar los wi correspondientes a xi > 0 y
reducir los correspondientes a xi < 0
Si s = 1 y r = −1 reducir los wi correspondientes a xi > 0 y
aumentar los correspondientes a xi < 0

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 12
UPM
 Algoritmo del Perceptron
x0 =−1
x w0
1 w1 s = 1 si y > 0
y= w ·x
i i s = −1 si y <= 0

wn

xn

while (! ond_term) {
for (e=0; e<nEj; e++)
for (i=0; i<=n; i++) {
dw[i℄ = k*(r[e℄-s[e℄)*x[i℄[e℄;
w[i℄ = w[i℄ + dw[i℄;
}
}

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 13
UPM

Convergencia del Perceptron

x
1

x
2

x
n

algoritmo de
aprendizaje
extraccion de caracteristicas (features)

Condición de convergencia:
separabilidad lineal en el espacio (x1, x2, . . . xn)
Minsky y Papert (1969)

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 14
UPM
 Descenso (o ascenso) por gradiente: principio

Método clásico para optimización: hill climbing

«Neurona» lineal: s(~x) = y(~x) = ~

w ·~x E

Error de una «hipótesis», ~

w:
1
E(~w) = ∑
2 e
(re − se)2; re, se ∈ [0, 1]
w
w
1
2
(e: índice de ejemplos) E=
1
Idea: acercarse al mínimo mediante ∑
2 e
(re − w1 · x1e − w2 · x2e)2
incrementos de ~
w proporcionales al
gradiente de −E
h i
∂E ∂E
∇E = ∂w0
. . . ∂wn
: dirección de máximo crecimiento de E

∆~w = −K · ∇E

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 15
UPM

Descenso por gradiente: adaptación de pesos

1
E(~w) = ∑(re − se)2;
h i
∂E ∂E
∇E = ∂w0 . . . ∂wn ; ∆~w = −K · ∇E
2 e

Como se = ~
w ·~xe,

∂E 1 ∂
= ∑ (re − se)2 = − ∑(re − se) · xie
∂wi 2 e ∂wi e

∆wi = K · ∑(re − se) · xie

e

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 16
UPM
 Descenso por gradiente: algoritmo

while (! ond_term) {
for (i=0; i<=n; i++) dw[i℄ = 0;
for (e=0; e<nEj; e++)
for (i=0; i<=n; i++)
dw[i℄ = dw[i℄ + k*(r[e℄-s[e℄)*x[i℄[e℄;
for (i=0; i<=n; i++)
w[i℄ = w[i℄ + dw[i℄;
}
x[i℄[e℄ es xie: valor de la entrada i para el ejemplo e
Comparar con el algoritmo del Perceptron

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 17
UPM

Descenso incremental o «regla delta»

Variante del algoritmo del gradiente

(Widrow y Hoff, 1960: «adalines»):
w) = 21 (re − se)2
No función error global, sino por ejemplo: Ee(~
Iteración sobre los ejemplos, modificando wi para cada uno
Algoritmo (igual al del Perceptron, pero re, se ∈ [0, 1]):
while (! ond_term) {
for (e=0; e<nEj; e++)
for (i=0; i<=n; i++)
w[i℄ = w[i℄ + k*(r[e℄-s[e℄)*x[i℄[e℄;
}

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 18
UPM
 Diferencias entre Perceptron, Gradiente y Regla Delta

Delta aproxima Gradiente para K suficientemente pequeño, y requiere

menos computación
Si hay varios mínimos (funciones no lineales), Delta mejor que Gradiente
para evitar mínimos locales

Perceptron usa el error (discreto) a la salida del umbral; Gradiente/Delta, el

error (continuo) de la combinación lineal de entradas
Perceptron converge tras un número finito de iteraciones a una hipótesis
(~w) que clasifica perfectamente los ejemplos siempre que éstos sean
linealmente separables
Gradiente/Delta convergen asintóticamente a una hipótesis de mínimo error
(local) aunque los ejemplos no sean linealmente separables
(Demostraciones en Hertz et al., 1991)

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 19
UPM

Redes multicapa: MLP

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 20
UPM
 La separabilidad en las redes multicapa según Minsky

Perceptron y otras funciones de activación con una sola capa:

limitación por la condición de separabilidad lineal
¿Se pueden conseguir superficies no lineales con una red de
varias capas? Para funciones lógicas, sí (ejemplo típico: ORX)
Pero no con el algoritmo del gradiente ni la regla delta: la red
seguiría siendo lineal
¿Con funciones de activación no lineales?
(como el Perceptron)
«Nuestra opinión personal es que la extensión es estéril»
(Minsky y Papert, 1969: 1958 + 11)

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 21
UPM

Separabilidad en las redes multicapa

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 22
UPM
 El entrenamiento de redes multicapa

Problema para el diseño de una estrategia de aprendizaje:

asignación de mérito (credit assignment)
Mérito (o culpa, o responsabilidad) de un peso (wi j ):
∂E
medida de su contribución al error global ( ∂w )
ij

Dificultad con el Perceptron:

la función de activación no es diferenciable
Se necesita una neurona con función de activación
• no lineal, para conseguir superficies no lineales
∂E
• diferenciable, para poder calcular ∆wi j = −K · ∂w ij

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 23
UPM

Neurona no lineal y diferenciable

x0j=-1
x w w
1j 1j 0j
y= w ·x 1
j ij ij
s(y j) = -y
w ("net ") 1+e j
nj j

x
nj
ds
Con esta función sigmoidal (o logística), dy
= s(y) · (1 − s(y))
∂E ∂E j∂y ∂E
∂wi j
= ∂y j
· ∂w ij
= ∂y j
· xi j
Si se conoce r j para un ejemplo e,
∂Ee ∂s
∂y j
= ∂y∂ j ( 21 (r j − s j)2) = −(r j − s j) ∂y jj = −(r j − s j ) · s j · (1 − s j )

∆wi j = K · δ j · xi j , con δ j = (r j − s j ) · s j · (1 − s j )
Pero r j sólo se conoce en la capa de salida

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 24
UPM
 Notación para redes multicapa

xi j : entrada a la neurona j procedente de la i

(para la capa de entrada, entradas a la red)
wi j : peso de la conexión de la neurona i a la j
δ j : factor de error de la neurona j
e: índice sobre los ejemplos
l : índice sobre las neuronas de salida
h, r: índices sobre neuronas ocultas
Con varias neuronas de salida, error de una hipótesis ~
w:
1
w) =
Gradiente: E(~ ∑ ∑
2 e l
(rle − sle)2

1
Regla delta: Ee(~
w) = ∑
2 l
(rle − sle)2

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 25
UPM

Ajuste de pesos en redes multicapa

∂Ee
Considerando Regla Delta, ∆wi j = −K · ∂w = K · δ j · xi j , con ij

δ j = − ∂E e
∂y j

Para la función de activación sigmoidal resulta:

En neuronas de salida: δl = sl · (1 − sl ) · (rl − sl )
En neuronas de la capa anterior a la de salida,
como no se conoce rh se estima el mérito en función de la
contribución de las siguientes: δh = sh · (1 − sh) · ∑l (whl · δl )
En neuronas de la capa c, igual:
δh = sh · (1 − sh) · ∑ r: capa c+1
(whr · δr )
algoritmo de retropropagación, 1985 (1969 + 16)

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 26
UPM
 Algoritmo de retropropagación: adelante

/* Se ini ia w[ ℄[i℄[j℄ on números aleatorios pequeños */

ini iar(w);
while (! ond_term) {
for (ie=0; ie<nEj; ie++) { /* nEj: número de ejemplos */
for (j=0; j<nn[0℄; j++) { /* nn[ ℄: num. neuronas en apa */
for (i=0; i<nEnt; i++) /* nEnt: num. entradas a la red */
x[0℄[i℄[j℄ = e[ie℄[i℄;
s[0℄[j℄ = f(x[0℄[i℄[j℄, w[0℄[i℄[j℄); /*sigm(∑(w*x)):
bu le en i*/
}
/* Se propaga ha ia adelante la entrada */
for ( =1; <n ; ++) { /* n : número de apas */
for (j=0; j<nn[ ℄; j++) {
for (i=0; i<nn[ -1℄; i++) /* nn[ -1℄ = num.ent. apa */
x[ ℄[i℄[j℄ = s[ -1℄[i℄;
s[ ℄[j℄ = f(x[ ℄[i℄[j℄, w[ ℄[i℄[j℄); /* bu le en i */
}
} /* ya tenemos las salidas para el ejemplo ie */

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 27
UPM

Algoritmo de retropropagación: errores de salida

/* Errores en la apa de salida (n -1) */

for (l=0; l<nn[n -1℄; l++) {
d[n -1℄[l℄ = s[n -1℄[l℄*(1 - s[n -1℄[l℄)*(r[ie℄ - s[n -1℄[l℄);
/* Ajuste de pesos de la apa de salida */
for (i=0; i<nn[n -2℄; i++) /* Si n = 1, nn[n -2℄ = nEnt */
w[n -1℄[i℄[l℄ = w[n -1℄[i℄[l℄ + K*d[n -1℄[l℄*x[n -1℄[i℄[l℄;
}

En el caso de una sola capa, hemos terminado

(falta cerrar el bucle de ejemplos y la condición de terminación)
En el caso de varias capas falta lo más interesante: propagar hacia atrás
los errores, modificando los pesos convenientemente

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 28
UPM
 Algoritmo de retropropagación: atrás

/* Se propagan ha ia atrás los errores (si n > 1)*/

for ( =n -2; >=0; --) {
for (h=0; h<nn[ ℄; h++) {
suma = 0;
for (r=0; r<nn[ +1℄; r++)
suma = suma + w[ ℄[h℄[r℄*d[ +1℄[r℄;
d[ ℄[h℄ = s[ ℄[h℄*(1 - s[ ℄[h℄)*suma;
/* y se van ajustando los pesos */
for (i=0; i<nn[ -1℄; i++) /* Si =0, nn[ -1℄ = nEntr */
w[ ℄[i℄[h℄ = w[ ℄[i℄[h℄ + K*d[ ℄[h℄*x[ ℄[i℄[h℄;
}
}
} /* ierra el bu le de ejemplos */
} /* ierra la ondi ión de termina ión */
Atribuido generalmente a Rumelhart, Hinton y Williams (1985)
Idea original de Werbos (1974) redescubierta por Parker (1982)
(Widrow, Proc. IEEE, Sep. 1990)

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 29
UPM

Aplicaciones de retropropagación: ejemplo

Una capa oculta: superficies convexas

Dos capas ocultas: superficies arbitrarias
Ejemplo: reconocimiento de 10 sonidos vocales en el contexto
«h_d» (Huang y Lippmann, 1988)
4000

head

heed had
hid 2000
head
F2 (Hz)

hid
F
1
hud
heard
1000

F who’d hod
2
hood
hawed
500
who’d
0 500 1000 1400
F1 (Hz)
hood

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 30
UPM
 Software para redes neuronales

SNNS (Stuttgart Neural Network Simulator)

Simulador y GUI para Unix (portado tambén a Windows)
Incluye muchos algoritmos, además de retropropagación:
conterprop, quickprop, Rprop...

http://www-ra.informatik.uni-tuebingen.de/SNNS/
JavaNNS
Sucesor de SNNS, multiplataforma

http://www-ra.informatik.uni-tuebingen.de/
software/JavaNNS/wel ome_e.html

c 2008 DIT-ETSIT-UPM Aprendizaje: Algoritmos genéticos y redes neuronales transp. 31
UPM