El asiento del alma

Aprendizaje secuencial y olvido catastrófico

Hoy me ha dado por hacer unas simulaciones chiquititas para presentar un par de problemas que tienen las redes neuronales de dos y tres capas que usan el algoritmo de backpropagation (retropropagación del error). Este tipo de redes son muy sencillas y deben de ser de las más usadas, siendo una especie de constituyente de muchas otras redes más complejas. Las de tres capas contienen una capa de salida y otra de entrada, más una capa de unidades ocultas. Las capas se conectan una con la siguiente, de manera que la activación de las unidades de entrada (correspondiente al patrón que se le presenta a la red) pasa por las unidades ocultas y llega a las unidades de salida. Allí se compara con un patrón tutor (que viene a ser lo que la red quieres que haga) y la diferencia entre lo que la red hace y debería hacer viaja hacia atrás por las capas modificando los pesos de las conexiones que las unen. Vamos, y esto es lo más sencillo.

Para estas simulaciones vamos a usar el simulador t-learn que posee una licencia GNU de esas. Es bastante sencillo de manejar. Cada red es un "proyecto" que se compone de a) arquitectura, b) patrones input, c) patrones tutores. Con un menú se elige la manera en que se entrena la red (learning rate = 0.1, y momentum = 0, para todas estas simulaciones), y a otro toque de ratón ya se entrena la red.

Aprendizaje secuencial

Un problema de estas redes es que están incapacitadas para aprender un problema de una manera secuencial. Supongamos que tengo que memorizar cuatro definiciones de un diccionario. Primero nos presentan una, luego otra, luego otra, y la última. Lo normal al entrenar una red neuronal es presentar las cuatro definiciones y luego ver cómo ha aprendido. En caso de que lo hagamos secuencialmente (una a una) su rendimiento cae en picado. Esto se debe a que las representaciones de la red se pisan: para solucionar dos problemas distintos, la red usa los mismos recursos; como si cada uno de sus cachos contuviera procedimientos para realizar tareas completamente distintas. Así, si la red se dedica por completo a un problema, no crea soluciones que tengan en cuenta que hay otros problemas a solucionar. Bueno, mejor lo vemos... enseñándole a la red el problema X-OR ("o exclusivo") de manera secuencial...

Arquitectura
2 unidades de entrada, 2 unidades ocultas y 1 unidad de salida:
NODES:
nodes = 3
inputs = 2
outputs = 1
output nodes are 3
CONNECTIONS:
groups = 0
1-3 from 0
1-2 from i1-i2
3 from 1-2
SPECIAL:

Patrones input
Cuatro patrones (00, 10, 01 y 11):
distributed
4
0 0
1 0
0 1
1 1

Patrones tutores
Cuatro patrones (0, 1, 1 y 0). De modo que al patrón input 00 le corresponde una salida de 0, al 10 le corresponde una salida de 1, al 01 le corresponde una salida de 1, y al 11 le corresponde una salida de 0. Así, hay dos grupos de estímulos: los de salida 0, que son el 00 y el 11; y los de salida 1, que son el 10 y el 01. Aquí están preparados para t-learn:
distributed
4
0
1
1
0

Resultados

Cuando entrenamos a la red con 40.000 ensayos de esta tarea, los resultados que nos ofrece son los siguientes:

Ante el patrón 00: 0.104
Ante el patrón 10: 0.889
Ante el patrón 01: 0.882
Ante el patrón 11: 0.092

De alguna manera, ya resuelve la tarea agrupando los estímulos tal como le hemos pedido.

Ahora lo que hacemos es entrenar a la red en la misma tarea pero secuencialmente. El patrón 00 es entrenado 10.000 veces junto al patrón tutor 0, y el mismo procedimiento se sigue con el 10 junto al 1, con el 01 junto al 1, y el 11 junto al 0. ¿Qué resultado sale?

Para el patrón 00: 0.023
Para el patrón 10: 0.033
Para el patrón 01: 0.014
Para el patrón 11: 0.017

Solamente clasifica bien el primer y el último patrón. Realmente la red está empleando una estrategia que le sirve para resolver sólo el último patrón que se le ha presentado, y pasa de lo que aprendió en los anteriores grupos de ensayos (lo ha olvidado). Una muestra de que adapta una estrategia dirigida a resolver cada patrón en particular, y no el conjunto de ellos, se vé en el nivel al que comienza el error global de la red cuando se le presenta un patrón nuevo. Primero, cuando se le presenta el patrón 00, y está comenzando el entrenamiento, su error es un valor aleatorio, determinado por sus pesos iniciales. Cuando termina de entrenarse con este patrón, su salida es un 0 constante, y al comenzar a entrenarse con el segundo patrón el error resultante es igual a 1. Cuando se pasa del segundo al tercer patrón (que compartirían esta burda estrategia de respuesta) el error es evidentemente 0, y con el cuarto patrón vuelve a subir a 1. Podemos ver cuáles son los pesos de las conexiones de la red, a ver si nos informan de cómo ésta resuelve la tarea.

Así, cuando la red ha sido entrenada con todos los patrones, no-secuencialmente, sus conexiones se dibujan como sigue:

Ésta es una de tantas combinaciones de pesos que permiten resolver la tarea X-OR. Se lee haciendo entrar la activación de abajo (i1 e i2 son las unidades de entrada) hacia arriba, multiplicando de lado y haciendo un buen lío. Las cajas blancas son conexiones que activan, y las negras son inhibitorias. La "b" corresponde a la unidad "bias" que activa a las unidades ocultas y de salida. Ahora veremos que el aprendizaje secuencial produce una serie de cambios en el peso de la unidad bias con la unidad de salida que son los que explican la incapacidad de la red para responder correctamente ante todo el conjunto de estímulos:

Patrón 00 - 0

Patrón 10 - 1

Patrón 01 - 1

Patrón 11 - 0

Que la red esté resolviendo las tareas cambiando los pesos que se dirigen del bias a las unidades ocultas y a la unidad de salida sólo reduce la influencia de las unidades de entrada. Esto también hace que presentes el patrón que presentes, la red responderá según el último patrón presentado: se ha vuelto insensible al input.

Olvido catastrófico

El olvido catastrófico se resume en que las redes cada vez que aprenden se comportan "casi" como si fueran tábulas rasas. Aunque la red puede tener más problemas para aprender una nueva tarea tras haber sido entrenado con determinadas tareas, tenderá a ignorar que ha sido entrenada con anterioridad (hablando muy metafóricamente).

Supongamos que enseñamos a la red a distinguir naranjas y limones, y luego la enseñamos a distinguir mandarinas y pomelos. Esto es, las categorías son ortogonales pero sus miembros se parecen bastante en cuanto a forma, color, acidez. La ortogonalidad es muy sencilla de representar en una red: basta con crear un patrón tutor con tantos valores como categorías, y hacer que estos vectores sean ortogonales (100, 010, 001, por ejemplo). Si las naranjas son 1000, los limones son 0100, las mandarinas son 0010, y los pomelos son 0001, y primero entrenamos con naranjas y limones, y después con mandarinas y pomelos... ¿cómo recordará la red las naranjas y los limones? Pues muy mal:

Naranja 0.004 0.004 1.000 0.000
Naranja 0.005 0.007 0.972 0.046
Naranja 0.009 0.004 1.000 0.000
Naranja 0.021 0.016 0.203 0.737
Naranja 0.006 0.011 0.085 0.899
Naranja 0.009 0.014 0.011 0.986
Limón 0.002 0.003 0.996 0.005
Limón 0.004 0.007 0.487 0.457
Limón 0.002 0.003 0.996 0.005
Limón 0.004 0.007 0.487 0.457

En próximos capítulos veremos cómo se soluciona este problema, y cómo la solución puede pasar por hacer que las representaciones internas de la red "se pisen" en menor medida.

URL de trackback de esta historia http://jkaranka.blogalia.com//trackbacks/17338

Aprendizaje secuencial y olvido catastrófico

Referencias (TrackBacks)

Comentarios

Todas las Historias

Translate me!

Archivos

Documentos