Ingeniería Técnica en Informática de Gestión

(1)

Departamento de Inform´atica Universidad Carlos III de Madrid

Ingenier´ıa T´

ecnica en

Inform´

atica de Gesti´

on

Inteligencia Artificial

Febrero 2010. 1a _parte

Normas generales del examen

• El tiempo para realizar el examen es de 1,5 horas

• Sólo se responderán preguntas sobre el examen los primeros 30 minutos • Si se sale del aula, no se podrá volver a entrar durante el examen • No se puede presentar el examen escrito a lápiz

Problema 1. (5 puntos)

Se desea implementar un algoritmo de búsqueda para jugar al Conecta-4. El tablero del juego se muestra en la Figura 1. En este juego, inicialmente el tablero está vac´ıo. Cada jugador debe deslizar una ficha por una de las columnas en cada turno. El juego termina cuando ya no hay más hueco en el tablero para más fichas, o cuando un jugador consigue hacer 4 en l´ınea, es decir, tener 4 fichas en posiciones del tablero consecutivas, ya sea en horizontal, vertical o diagonal.

Figura 1: Estado del tablero del Conecta-4 Se pide:

1. (2 puntos) Formalizar el problema como un problema de b´usqueda, es decir, formalizar el espacio de estados, los operadores, y definir el estado inicial y las metas.

2. (0,75 puntos) ¿Cuál es el factor de ramificación m´ınimo y máximo para cada nodo? ¿Cuál es la profundidad máxima del árbol de búsqueda?

3. (0,75 puntos) Asumiendo que se tienen bastantes restricciones de tiempo, justificar qu´e algoritmo de b´usqueda utilizar´ıas para resolver el problema, razonando la respuesta dada.

4. (0,75 puntos) Definir (de manera informal) una funci´on de evaluaci´on adecuada para ejecutar el algoritmo elegido anteriormente.

5. (0,75 puntos) Ejecutar el algoritmo elegido para decidir qué movimiento harán las negras desde el estado dado en la Figura 2. Elegir los parámetros del algoritmo oportunos para generar entre 10-15 nodos aproximadamente.

(2)

Figura 2: Estado del tablero del Conecta-4. Las fichas colocadas se colorean en negro y en gris, y los huecos libres en blanco.

1. Soluci´

on

1.1. Cuesti´

on 1

Este es un problema de búsqueda de 2 agentes. Un estado de este problema se formaliza de manera sencilla con una matriz de valores, T , de tamaño M × N . En este caso, N corresponde con el número de filas (N = 6) y M con el número de columnas (M = 7) del tablero. Cada posición de la matriz T [x, y] (0 < x < M , 0 < y < N ) toma valor 0 si está desocupada, 1 si está ocupada por una ficha del jugador 1, y 2 si está ocupada por una ficha del jugador 2.

En el estado inicial, no hay ninguna ficha colocada, por lo que ∀x, y, T [x, y] = 0. El estado final se identifica por dos condiciones:

1. El tablero ya est´a lleno: ∀x, y, T [x, y] 6= 0

2. Ha ganado la partida un jugador. Es decir, se cumple:

4 en raya horizontal: existe una posici´on x, y tal que T [x, y] = T [x + 1, y] = T [x + 2, y] = T [x + 3, y], para 0 < x < M − 4.

4 en raya vertical: existe una posici´on x, y tal que T [x, y] = T [x, y + 1] = T [x, y + 2] = T [x, y + 3], para 0 < y < N − 4.

4 en raya diagonal ascendente: existe una posici´on x, y tal que T [x, y] = T [x + 1, y + 1] = T [x + 2, y + 2] = T [x + 3, y + 3], para 0 < x < M − 4, 0 < y < N − 4.

4 en raya diagonal descendente: existe una posici´on x, y tal que T [x, y] = T [x+1, y −1] = T [x+2, y −2] = T [x + 3, y − 3], para 0 < x < M − 4, 3 < y < N .

En este problema, cada jugador dispone de un único operador, P oner(c), que intenta colocar una ficha en la columna c. Este operador tiene una única precondición (asumiendo, obviamente, que el jugador dispone del turno), que es que en la columna c haya sitio para una ficha, es decir, que T [c, 5] = 0. Si esa condición se cumple, se puede ejecutar el operador, en cuyo caso el efecto resultante es que colocará una ficha en la posición que esté libre. Si suponemos que el jugador que tiene el turno es el jugador i (para i ∈ [1, 2]), entonces:

Si existe j tal que 0 ≤ j < N , T [c, j] 6= 0 y T [c, j + 1] = 0 Hacer T [c, j + 1] = i

Si no, hacer T [c, 0] = i

Esta regla, por tanto, busca primero una fila j en la columna c que tenga una ficha, y que en la posición j + 1 no tenga ninguna ficha y, por tanto, ser´ıa donde quedar´ıa la nueva ficha insertada. Si no encuentra esa situación, dado que hay algún hueco (por la precondición del operador), entonces coloca la ficha en la primera fila (la fila 0).

(3)

1.2. Cuesti´

on 2

El factor de ramificación m´ınimo es 1, y se da cuando sólo hay huecos disponibles en una columna. El máximo es 7, coincidiendo con el número máximo de columnas. La profundidad máxima del árbol de búsqueda es el número total de fichas que se pueden colocar en el tablero, es decir, 42 (N × M ).

1.3. Cuesti´

on 3

Dado que es un problema de búsqueda con dos agentes, se puede utilizar el algoritmo MiniMax. Dada las restricciones de memoria, utilizar´ıamos Alfa-beta, limitando también la profundidad máxima a los valores adecuados en función de la memoria disponible.

1.4. Cuesti´

on 4

Una posible función de evaluación podr´ıa ser la distancia de un jugador a un estado meta, donde esa distancia viene dado por el número de fichas que hay que tendr´ıa que colocar para ganar la partida. Por ejemplo, en la Figura 2, el jugador que juega con blancas (en el dibujo, fichas grises), está a una distancia de 2 de la meta, puesto que con colocar dos ficha en la columna 4 ganar´ıa la partida. El jugador que lleva las negras está a una distancia 3 de la victoria, que conseguir´ıa poniendo 2 fichas en la columna 4 y otra en la 5. El objetivo ser´ıa, por tanto minimizar ese valor. En caso de que un jugador no tenga forma de ganar la partida, su distancia a meta se define como 10 (que es la distancia máxima a la meta).

Esta función de evaluación no tiene en cuenta, sin embargo, lo cerca que está el contrario de su meta. Por tanto, una función de evaluación más adecuada penalizar´ıa en función de lo cerca que esté el contrario de la meta. Por tanto, a la función anterior, le podr´ıamos sumar 10 (máxima distancia a meta) menos la distancia a meta del contrario. As´ı, en el estado de la figura, el jugador que mueve con negras evaluar´ıa ese estado con un valor de 9 (3+10-2).

1.5. Cuesti´

on 5

Si se utilizara el algoritmo Mini-Max para resolver este problema, se generar´ıa el ´arbol de b´usqueda mostrado en la Figura 3. El nodo inicial (nodo 1) tendr´ıa 3 sucesores, resultantes de que Max (fichas negras) colocara una ficha en la columna 4, en la 5 y en la 6 respectivamente. Del nodo 2 se genar´ıan otros 3 sucesores, el 5 el 6 y el 7. El nodo 5 es un estado final, puesto que las fichas blancas ganan. Por tanto, ese nodo se etiqueta como −∞.

inf 10+101=19 2+101=11 1+101=10 2+102=10 2+102=10 2+101=11 3+101=12 inf 10 10 1 2 3 4 5 6 7 8 9 10 11 12 10

Figura 3: ´Arbol de b´usqueda Mini-Max

En caso de que se ejecutara una b´usqueda alfa-beta, el ´arbol ser´ıa equivalente, excepto para los nodos 6 y 7, que habr´ıan sido podados, puesto que β(2) = alf a(1) = −∞.

(4)

Departamento de Inform´atica Universidad Carlos III de Madrid

Ingenier´ıa T´

ecnica en

Inform´

atica de Gesti´

on

Inteligencia Artificial

Febrero 2010. 2a _parte

Normas generales del examen

• El tiempo para realizar el examen es de 2 horas

• Sólo se responderán preguntas sobre el examen los primeros 30 minutos • Si se sale del aula, no se podrá volver a entrar durante el examen • No se puede presentar el examen escrito a lápiz

Problema 2. (5 puntos)

Los robot aspiradores que hay en el mercado se basan en movimientos aleatorios, está comprobado que en un tiempo suficientemente alto aspirando de forma aleatoria termina limpiando todo el recinto. Para comprobarlo se ha pedido diseñar un sistema de producción que simule el funcionamiento de uno de estos robots y cuente el tiempo que tardar´ıa en aspirar una habitación rectangular suponiendo lo siguiente:

La habitaci´on se puede dividir en casillas y tiene una dimensi´on de NxM.

Se toma como origen de coordenadas la casilla (1,1) en la esquina superior izquierda.

El robot puede girar 90o _{grados en los dos sentidos lev´}_{ogiro y dextr´}_{ogiro y avanzar una casilla en la direcci´}_on

en la que est´a orientado.

Tarda el doble de tiempo en avanzar que en girar.

Las casillas las limpia simplemente pasando por encima de ellas.

Inicialmente el robot est´a en la base y tras limpiar toda la habitaci´on debe volver a ella.

En la habitación puede haber obstáculos que el robot será capaz de evitar. En la simulación se conoce las posición de dichos obstáculos y basta con evitar que el robot pase por encima de ellos.

Se pide:

1. (2 puntos) Utilizando sintaxis de Clips, definir una jerarqu´ıa de marcos para modelar el conocimiento del sistema de producción pedido. Definir las instancias iniciales necesarias para simular la limpieza de una habitación de 10x10 casillas, suponiendo que la base se encuentra en la casilla (1,1) y que hay 4 obstáculos situados en las casillas (5,1), (5,2), (5,3) y (3,3).

2. (3 puntos) Utilizando sintaxis de Clips y la jerarqu´ıa del apartado anterior, definir las reglas del sistema de producción que permitan demostrar que el robot moviéndose de forma aleatoria por la habitación consigue finalizar la limpieza, es decir, pasa por todas las casillas en las que no hay un obstáculo. La limpieza finaliza cuando el robot vuelve a la base. La/s regla/s de finalización debe/n mostrar por pantalla el tiempo total que ha tardado el robot en completar la limpieza. Hay que intentar minimizar el número de reglas. Los obstáculos de la habitación se deben introducir como instancias iniciales en la base de hechos pero las casillas que componen la habitación se tiene que generar automáticamente mediante reglas del sistema de producción.

(5)

Para simplificar las reglas que simulan el movimiento del robot hay que utilizar las plantillas de la figura 4. La plantilla giro representa la orientación final del robot después de girar, habrá 8 hechos de esta plantilla indicando las 4 posibles orientaciones iniciales en las que se puede encontrar el robot (Norte, Sur, Este y Oeste), slot inicial, y los 2 posibles sentidos de giro (Izquierda y Derecha), slot sentido, el slot final indicará la orientación en la que quedará el robot tras el giro (ver figura 5). La plantilla desplazamiento indica el incremento en el eje X, slot dx, y en el eje Y, slot dy, que experimenta el robot en cada acción de avanzar dependiendo de la orientación inicial, slot orientacion, en la que se encuentre. Habrá 4 hechos de esta plantilla, uno para cada posible orientación del robot (Norte, Sur, Este y Oeste)(ver figura 6).

(deftemplate giro (slot inicial

(type SYMBOL)

(allowed-values Norte Sur Este Oeste)) (slot sentido

(type SYMBOL )

(allowed-values Izquierda Derecha)) (slot final

(type SYMBOL)

(allowed-values Norte Sur Este Oeste)))

(deftemplate desplazamiento (slot orientacion

(type SYMBOL)

(allowed-values Norte Sur Este Oeste)) (slot dx (type INTEGER) (allowed-values -1 0 1) (default 0)) (slot dy (type INTEGER) (allowed-values -1 0 1) (default 0)))

Figura 4: Plantillas para simular los giros y desplazamientos del robot.

(deffacts plantillas_giro

(giro (inicial Norte) (sentido Derecha) (final Este)) (giro (inicial Este ) (sentido Derecha) (final Sur)) (giro (inicial Sur ) (sentido Derecha) (final Oeste)) (giro (inicial Oeste) (sentido Derecha) (final Norte)) (giro (inicial Norte) (sentido Izquierda) (final Oeste)) (giro (inicial Oeste) (sentido Izquierda) (final Sur)) (giro (inicial Sur) (sentido Izquierda) (final Este)) (giro (inicial Este ) (sentido Izquierda) (final Norte)) )

Figura 5: Hechos iniciales de giro del robot.

(deffacts plantillas_desplazamiento

(desplazamiento (orientacion Norte) (dx 0) (dy -1)) (desplazamiento (orientacion Este) (dx 1) (dy 0)) (desplazamiento (orientacion Sur ) (dx 0) (dy 1)) (desplazamiento (orientacion Oeste) (dx -1) (dy 0)) )

Figura 6: Hechos iniciales de desplazamientos del robot.

2. Soluci´

on Problema 2

2.1. Cuesti´

on 1

En este problema se identifican dos conceptos: casilla y robot. Ambos comparte la posici´on en la que est´an que se puede representar por las coordenadas x e y. Por tanto, haremos una clase abstracta GENERAL para modelar ´

(6)

representar como otras subclases o simplemente a˜nadiendo un atributo tipo a la clase CASILLA. Las casillas pueden estar sucias o limpias y lo representamos mediante un atributo.

Teniendo en cuenta todo esto, se pude definir la siguiente jerarqu´ıa de marcos:

;;Clase abstracta gen´erica de la que heredan las otras (defclass GENERAL (is-a INITIAL-OBJECT)

(slot x

(type INTEGER)) (slot y

(type INTEGER)))

;;Clase para representar al robot-aspiradora (defclass ROBOT (is-a GENERAL)

(slot orientacion (type SYMBOL)

(allowed-values Norte Sur Este Oeste) (default Norte)))

;;Clase para representar al robo (defclass CASILLA (is-a GENERAL)

(slot tipo (type SYMBOL)

(allowed-values normal obstaculo base) (default normal))

(slot estado (type SYMBOL)

(allowed-values limpia sucia) (default sucia)))

Las instancias para representar la habitaci´on pedida ser´ıan:

(definstances iniciales

([robot] of ROBOT (x 1) (y 1))

([base] of CASILLA (x 1) (y 1) (tipo base)) ([o1] of CASILLA (x 5) (y 1) (tipo obstaculo)) ([o2] of CASILLA (x 5) (y 2) (tipo obstaculo)) ([o3] of CASILLA (x 5) (y 3) (tipo obstaculo)) ([o4] of CASILLA (x 3) (y 3) (tipo obstaculo)))

2.2. Cuesti´

on 2

Para la correcta definición de las reglas del sistema de producción es necesario definir la plantilla control y añadir un único hecho de ese tipo en la base de hechos.

(deftemplate control

(slot ancho ;anchura habitacion (type INTEGER)

(default 10))

(slot alto ;altura habitacion (type INTEGER)

(default 10))

(slot cx ;controlar la generaci´on de casillas (type INTEGER)

(default 0))

(slot cy ;controlar la generaci´on de casillas (type INTEGER)

(default 0))

(slot tiempo ;para contar el tiempo en limpiar (type INTEGER)

(default 0))) (deffacts control

(7)

Existirán tres tipos de reglas: las reglas para generar las instancias de casillas normales, las reglas para simular el movimiento del robot y las reglas para detectar la finalización de la limpieza. Las de generar instacias tendrán mayor prioridad, luego la de finalizar y las que menos prioridad serán las del movimiento. Para que el movimiento sea aleatorio es preciso establecer como estrategia de control random y tanto la regla de girar como de desplazarse tienen que tener la misma prioridad. La estrategia de control random se define mediante la regla inicial. En el enunciado se pide expresamente minimizar el número de reglas y utilizar las plantillas de giro y desplazamiento dadas. Con una sola regla para girar y otra para desplazar es suficiente para resolver el problema. Todas las soluciones en que se han usado más reglas se han considerado incorrectas.

Las reglas del sistema de producci´on pedido son:

;;; ****************************************** ;;; REGLA INICIAL ;;; ****************************************** (defrule estado-inicial (declare (salience 3000)) => (set-strategy random)) ;;; ****************************************** ;;; REGLAS PARA GENERAR LAS CASILLAS

;;; ******************************************

;; Tienen la mayor prioridad para asegurar que se crean todas las casillas antes de empezar a aspirar. ;; Para generar las casillas nos ayudamos de unos hechos auxiliares coor-x y coor-y.

;; Primero insertamos tantos hechos de estos como dimensiones tenga la habitacion y ;; luego generamos las casillas con su ayuda.

(defrule genera-coor-x (declare (salience 100))

?con <- (control (cx ?cx) (ancho ?an)) (test (< ?cx ?an)) => (assert (coor-x (+ ?cx 1))) (modify ?con (cx (+ 1 ?cx)))) (defrule genera-coor-y (declare (salience 100))

?con <- (control (cy ?cy) (alto ?al)) (test (< ?cy ?al))

=>

(assert (coor-y (+ ?cy 1))) (modify ?con (cy (+ 1 ?cy))))

;; Hay que comprobar que no exista ya la casilla creada (podr´ıa ser un obst´aculo o la base) (defrule genera-casilla

(declare (salience 99)) (coor-x ?x)

(coor-y ?y)

(not (object (is-a CASILLA) (x ?x) (y ?y))) =>

(make-instance of CASILLA (x ?x) (y ?y)) (printout t "Genera casilla " ?x " " ?y crlf)) ;;; ****************************************** ;;; REGLA PARA DETECTAR QUE HA LLEGADO A LA META ;;; ******************************************

;;tiene mas prioridad que las de mover pero menos que las de generar (defrule meta

(declare (salience 90)) (control (tiempo ?t))

(object (is-a ROBOT) (x ?x) (y ?y))

(object (is-a CASILLA) (x ?x) (y ?y) (tipo base))

(not (object (is-a CASILLA) (tipo normal) (estado sucia))) =>

(8)

(printout t " HA TARDADO " ?t " UNIDADES DE TIEMPO EN LIMPIAR Y VOLVER A LA BASE" crlf) (halt))

;;; ****************************************** ;;; REGLAS PARA EL MOVIMIENTO DEL ROBOT ;;; ******************************************

;;Con estas dos reglas el robot se mover´a por el recinto de forma aleatoria ya que la estrategia es la random ;; regla para cambiar la orientacion

(defrule robot_gira

?control <- (control (tiempo ?t))

?robot <- (object (is-a ROBOT) (orientacion ?drob)) (giro (inicial ?drob) (sentido ?sen) (final ?df)) =>

(modify-instance ?robot (orientacion ?df) ) (modify ?control (tiempo (+ 1 ?t)))

(printout t " Gira hacia la " ?sen ", orientacion actual: " ?df crlf)) ;;;regla para cambiar la posicion. Hay que evitar que pase sobre un obst´aculo (defrule robot_avanza

?control <- (control (tiempo ?t))

?robot <- (object (is-a ROBOT) (orientacion ?drob) (x ?xrob) (y ?yrob)) (desplazamiento (orientacion ?drob) (dx ?dx) (dy ?dy))

?cas <- (object (is-a CASILLA) (x =(+ ?xrob ?dx)) (y =(+ ?yrob ?dy)) (tipo ?tipo&~obstaculo)) =>

(modify-instance ?robot ( x (+ ?xrob ?dx)) (y (+ ?yrob ?dy)) ) (modify ?control (tiempo (+ 2 ?t)))

(modify-instance ?cas (estado limpia))