LECCIÓN 11 (β β). APRENDIZAJE EN MÁQUINAS. En esta lección se exploran estrategias de aprendizaje con refuerzo. Con ellas se desarrolla un agente capaz de aprender estrategias para jugar al «conecta-4». "De humanos es errar y de necios permanecer en el error." (Cicerón) Inteligencia Artificial e I.C.. 2003/2004 10.1 Dpto. Leng. C. Comp.(Universidad de Málaga) Inteligencia Artificial e I.C.. 2003/2004 10.2 Dpto. Leng. C. Comp.(Universidad de Málaga) R.11.1. Diferencias temporales: tabla de valores. a) Definir un tipo de datos tabla-valor que guarde un valor para cada estado de un problema Los valores de la tabla estarán comprendidos entre los de dos variables globales *ganar* y *perder*, y podrán modificarse empleando las siguientes funciones: a. (tabla-valor-estado-ganador estado tabla) que inicie el valor de estado en la tabla a *ganar*. b. (tabla-valor-estado-perdedor estado tabla) que inicie el valor de estado en la tabla a *perder*. c. (tabla-valor-estado-empate estado tabla) que inicie el valor de estado en la tabla al de otra variable global llamada *empatar*. d. (tabla-valor-actualiza-dt estado sucesor tabla &key alfa) que actualice el valor de estado en función de su sucesor empleando el método de las diferencias temporales: tabla(estado) tabla(estado) + alfa * (tabla(sucesor) – tabla(estado)) ************************** SOLUCION: Se trata de un conjunto de definiciones bastante sencillas. Comenzaremos definiendo las variables globales necesarias: (defvar *ganar*) (setq *ganar* 100) (defvar *perder*) (setq *perder* -100) (defvar *empatar*) (setq *empatar* -1) (defvar *alfa*) ;tasa de aprendizaje de la regla de diferencias temporales (setq *alfa* 0.1) Cada tabla de valores se implementará como una tabla hash indexada por estados. Los constructores y funciones de lectura y escritura son sencillas: (defun make-tabla-valor (&optional (eq-estado #'equalp)) (make-hash-table :test eq-estado)) (defun tabla-valor-asignar (estado valor tabla) (setf (gethash estado tabla) valor)) "Guarda valor para estado" (defun tabla-valor (e tabla) "El valor del estado en la tabla, o *empatar* si no existe" (or (gethash e tabla) *empatar*)) Definiremos también por conveniencia una función tabla-valor-tam, que nos dirá el número de entradas que hay guardadas en una tabla. El lector interesado puede consultar la sintáxis de la función maphash en la HiperEspecificación del lenguaje. (defun tabla-valor-tam (tabla) "Número de entradas de la tabla" (let ((n 0)) (maphash #'(lambda (e v) (setf n (1+ n))) tabla) n)) Una vez definido el tipo de datos, es sencillo escribir las funciones de actualización de la tabla que necesitaremos para el método de aprendizaje con diferencias temporales: (defun tabla-valor-estado-perdedor (e tabla) (tabla-valor-asignar e *perder* tabla)) Inteligencia Artificial e I.C.. 2003/2004 10.3 Dpto. Leng. C. Comp.(Universidad de Málaga) (defun tabla-valor-estado-ganador (e tabla) (tabla-valor-asignar e *ganar* tabla)) (defun tabla-valor-estado-empate (e tabla) (tabla-valor-asignar e *empatar* tabla)) (defun tabla-valor-actualiza-dt (estado sucesor tabla &key (alfa *alfa*)) "Actualiza el valor de estado según el método de las diferencias temporales." (let ((valor (tabla-valor estado tabla))) (tabla-valor-asignar estado (+ valor (* alfa (- (tabla-valor sucesor tabla) valor))) tabla))) Nótese que estas operaciones son independientes de la implementación de los objetos tabla-valor. Inteligencia Artificial e I.C.. 2003/2004 10.4 Dpto. Leng. C. Comp.(Universidad de Málaga) R.11.2. Diferencias temporales en problemas de juegos. a) Definir una función crea-funcion-evaluacion-tabla que reciba un objeto tabla-valor como los definidos en R11.1 y devuelva una función de evaluación de juegos considerando los valores de la tabla. b) Definir una función (aprende-tabla-valor-2 jug1 jug2 estr-rand &optional (pex 0.1)...), que reciba dos jugadores jug1, jug2, y aprenda una tabla-valor de evaluaciones heurísticas para el jugador jug2. El jugador jug2 realizará movimientos de exploración aleatorios con probabilidad pex empleando una estrategia estr-rand. c) Apender una tabla de valores empleando la función anteriror en 10000 partidas del juego del conecta-3 en un tablero 3x3. Crear un jugador-evaluar adecuado y comprobar su eficacia frente a jugadores heurísticos como los definidos en la lección 10. ************************** SOLUCION: a) La definición es bastante sencilla, y similar a la estudiada en R10.2.b. La función de evaluación actuará del siguiente modo: si la posición es final y ganadora para MAX, devolvemos el valor *ganar*, si es final y perdedora para MAX devolvemos *perder*, y en caso contrario se consulta el valor guardado en la tabla: (defun crea-funcion-evaluacion-tabla (tabla &key fmax fmin) #'(lambda (e) (let ((ganador (finalp e))) (cond ((eql ganador fmax) *ganar*) ((eql ganador fmin) *perder*) (t (tabla-valor e tabla)))))) Nótese que cada función devuelta es un cierre léxico que contiene su propia tabla. b) Para definir la función aprende debemos considerar el uso que un jugador hará posteriormente de la tabla de valores. En principio, la tabla se creará para jugadores del tipo jugador-evaluar, tal como se definieron en R10.2.b. En la tabla, se guardará la evaluación de los estados del jugador contrario al que está aprendiendo (MIN), ya que son esas precisamente las que nuestro jugador (MAX) estará interesado en aprender a evaluar. También se guardarán los valores correspondientes a estados finales y perdedores para MAX, de modo que los valores perdedores también se propaguen adecuadamente por la tabla. Al igual que ocurría con la función de evaluación de R10.2.b, la tabla aprendida será diferente según el turno (o la ficha) de nuestro jugador. En nuestro caso, estamos interesados en aprender una tabla para *jugador-2*, aunque la tabla para *jugador-1* se puede aprender de forma análoga. Definiremos aprende-tabla-valor-2 como una función recursiva. Incialmente tabla tendrá una tabla vacía, y e el estado inicial del juego. El esquema inicial podría ser el siguiente: (defun aprende-tabla-valor-2-incompleta (jug1 jug2 estr-rand &optional (pex 0.1) (tabla (make-tabla-valor)) (e (hacer-estado-inicial))) (cond ((or (agotado e) (finalp e)) tabla) (t ;MOVIMIENTO DE jug1 (let ((e2 (elegir-suc-nth (jugador-elige-movimiento jug1 e) e))) ;MOVIMIENTO DE jug2 (let ((e3 (elegir-suc-nth (jugador-elige-movimiento jug2 e2) e2))) (cond ((finalp e3) (tabla-valor-estado-ganador e3 tabla)) ((agotado e3) (tabla-valor-estado-empate e3 tabla))) (tabla-valor-actualiza-dt e e3 tabla)) (aprende-tabla-valor-2-incompleta jug1 jug2 estr-rand pex tabla e3)))))) Inteligencia Artificial e I.C.. 2003/2004 10.5 Dpto. Leng. C. Comp.(Universidad de Málaga) En cada llamada se realizan dos movimientos a partir del estado e, el primero de MIN (dando lugar al estado e2), y el segundo de MAX (dando lugar al estado e3). Si e3 corresponde a un estado final, será ganador para MAX, y si corresponde a un estado agotado, será un empate. A continuación se actualiza el valor de e en la tabla utilizando el de e3 y el método de diferencias temporales. El entrenamiento termina cuando e corresponde al final del juego. Sin embargo, es necesario tener en cuenta consideraciones adicionales: 1. En primer lugar, existe la posibilidad de que e2 pueda corresponder también a un estado final (perdedor para MAX) o agotado. En tal caso, incluiremos la evaluación correspondiente a e2 en la tabla, y actualizaremos el valor de e utilizando el de e2 y el método de diferencias temporales. 2. En segundo lugar, para garantizar que MAX encuentre una buena estrategia, es necesario realizar movimientos exploratorios. Introduciremos una pequeña componente aleatoria en los movimientos de MAX (jug2). En caso de que el movimiento sea exploratorio no actualizaremos el valor de e. (defun aprende-tabla-valor-2 (jug1 jug2 estr-rand &optional (pex 0.1) (tabla (make-tabla-valor)) (e (hacer-estado-inicial))) (cond ((or (agotado e) (finalp e)) tabla) (t ;MOVIMIENTO DE jug1 (let ((e2 (elegir-suc-nth (jugador-elige-movimiento jug1 e) e))) (when (finalp e2) (tabla-valor-estado-perdedor e2 tabla) (tabla-valor-actualiza-dt e e2 tabla) (return-from aprende-tabla-valor-2 tabla)) ;termina perdiendo (when (agotado e2) (tabla-valor-estado-empate e2 tabla) (tabla-valor-actualiza-dt e e2 tabla) (return-from aprende-tabla-valor-2 tabla)) ;termina empatando ;MOVIMIENTO DE jug2 (let* ((explora? (< (random 1.0) pex)) ;cierto con prob. pex (e3 (elegir-suc-nth (if explora? (funcall estr-rand e2) (jugador-elige-movimiento jug2 e2)) e2))) (cond ((finalp e3) (tabla-valor-estado-ganador e3 tabla)) ((agotado e3) (tabla-valor-estado-empate e3 tabla))) (unless explora? (tabla-valor-actualiza-dt e e3 tabla)) (aprende-tabla-valor-2 jug1 jug2 estr-rand pex tabla e3)))))) c) La función aprende-tabla-valor puede recibir una tabla. En tal caso la modifica destructivamente mientras aprende del transcurso de una partida, y luego la devuelve como resultado. Podemos crear un jugador-evaluar que emplee una tabla-valor, y entrenarlo en 10000 partidas frente a un jugador aleatorio. La siguiente función se encarga de entrenar la tabla: (defun entrena-tabla-2 (npartidas &optional (tabla (make-tabla-valor))) (let* ((feval (crea-funcion-evaluacion-tabla tabla :fmax *jugador-2* :fmin *jugador-1*)) (j1 (make-jugador-aleatorio)) (j2 (make-jugador-evaluar :fmax *jugador-2* :fmin *jugador-1* :feval feval))) (dotimes (i npartidas tabla) (aprende-tabla-valor-2 j1 j2 #'estrategia-random tabla)))) Inteligencia Artificial e I.C.. 2003/2004 10.6 Dpto. Leng. C. Comp.(Universidad de Málaga) A continuación configuramos el juego para un tablero 3x3 y conecta-3, y entrenamos una tabla: (setf *nfilas* 3) (setf *ncolumnas* 3) (setf *long-ganadora* 3) (setf *mi-tabla* (entrena-tabla-2 10000)) Lanzamos una partida para ver qué tal actúa nuestro aprendiz (nótese que en el conecta-3 en un tablero 3x3 no existe estrategia ganadora para el primer jugador, a lo más que puede aspirar es a empatar): (conecta4 (make-jugador-humano) (make-jugador-evaluar :feval (crea-funcion-evaluacion-tabla *mi-tabla* :fmax *jugador-2* :fmin *jugador-1*)) t) ¡Buena suerte! Inteligencia Artificial e I.C.. 2003/2004 10.7 Dpto. Leng. C. Comp.(Universidad de Málaga) EJERCICIOS PROPUESTOS. P.11.1. Escribir una definición más elegante del tipo de datos tabla-valor definido en R.11.1, donde las variables globales *ganar*, *perder*, *empatar*, y *alfa* no sean necesarias, y cada objeto del tipo guarde los valores correspondientes P.11.2. El tipo de datos tabla-valor definido en R.11.1 emplea tablas hash para guardar los datos. Las tablas hash son estructuras dinámicas y eficientes, pero no son objetos que puedan escribirse con prin1 ni leerse posteriormente con read. Ampliar la funcionalidad del nuevo tipo de datos escribiendo dos funciones (guardar-tabla-valor tabla nomf) y (leer-tabla-valor tabla nomf) que permitan guardar el contenido de una tabla-valor en un fichero llamado nomf, y devolver una tabla con los contenidos guardados en el mismo respectivamente. P.11.3. Definir una función (ver-aprendizaje npartidas cadam kpruebas) que realice un total de npartidas de entrenamiento para las variantes del juego del conecta4, y devuelva la tabla aprendida. Cada cadam partidas se hará una pausa en el entrenamiento, se jugarán kpruebas partidas contra una estrategia aleatoria, y se mostrará por pantalla una estadística de los resultados. Esto nos permitirá observar la velocidad con que el programa aprende su estrategia de juego, y la eficacia de la misma. Por ejemplo, para el juego del conecta-3 en un tablero 3x3 se debería obtener un resultado parecido al siguiente si se entrena al segundo jugador (J2): (setf *nfilas* 3) (setf *ncolumnas* 3) (setf *long-ganadora* 3) (ver-aprendizaje 10000 500 1000)) Num. Tam. % % % partidas tabla gana J2 empate pierde J2 ---------------------------------------------------0 0 29.70 12.20 58.10 500 236 58.10 30.10 11.80 1000 295 61.40 20.50 18.10 1500 337 63.30 28.90 7.80 2000 371 65.00 29.90 5.10 2500 384 64.30 27.40 8.30 3000 403 63.00 28.10 8.90 3500 429 74.60 16.70 8.70 4000 443 73.90 19.40 6.70 4500 467 84.30 12.30 3.40 5000 483 80.10 19.90 0.00 5500 492 85.00 12.10 2.90 6000 502 81.50 18.50 0.00 6500 513 82.20 17.80 0.00 7000 521 81.10 18.90 0.00 7500 525 81.50 18.50 0.00 8000 531 83.30 16.70 0.00 8500 536 81.10 18.90 0.00 9000 541 82.20 17.80 0.00 9500 542 81.10 18.90 0.00 10000 545 84.30 15.70 0.00 #<EQUALP Hash Table{545} 20F5C30C> P.11.4. Empleando la función del ejercicio anterior, entrenar un jugador para el juego del conecta-3 en un tablero 4x4 y analizar los resultados. Repetir el proceso para el juego del conecta-4 en un tablero 5x5. P.11.5. Definir funciones análogas a las presentadas en R11.2 para aprender una estrategia de juego para el primer jugador del conecta4. P11.6 Emplear las tablas aprendidas en el ejercicio P11.4 para crear un jugador-minimax. ¿Mejora el rendimiento del jugador a medida que ampliamos la profundidad de la búsqueda? ¿Por qué? ¿Cómo podría mejorarse? __________________________________________________________________________________ Las erratas y comentarios sobre estos apuntes son bienvenidos en: lawrence@lcc.uma.es Inteligencia Artificial e I.C.. 2003/2004 10.8 Dpto. Leng. C. Comp.(Universidad de Málaga)