|
BARRA
DE EXPLORACIÓN
|
Principal Arriba
|
| |
|
Práctica
Actual
Comienzo
9 de Noviembre de 2009
Entrega
1Febrero de 2009
|
| |
|
Novedades
|
|

11/1/10
Por alguna razón que
desconozco, el programa "mapea" que hay compilado para Ubuntu no procesa
bien los ficheros de caminos (aunque sí lo hace en otras distros). Por
ello he incluido una versión "modificada" para que funcione en esta
distro. La podéis descargar de la sección de
Software.
Histórico de Avisos::
|
| |
Las técnicas de
planificación que vamos a utilizar en esta práctica se conocen como HTN (Hierarchical Task Network planning) y en particular vamos a utilizar un
planificador llamado SIADEX (ver software disponible). Estas técnicas se
basan en la descripción de un problema a partir de una serie de tareas y
subtareas que el planificador debe combinar y componer para resolver un
problema. Existen dos tipos de tareas, las tareas abstractas, que pueden
descomponerse en una o más subtareas, y las tareas primitivas o acciones, que no se pueden
descomponer.
Cada tarea abstracta se
puede descomponer de varias formas distintas, cada una de estas formas de
descomponer una tarea se llama método, y en su descomposición pueden
aparecer tanto tareas abstractas como tareas primitivas.

En esta figura se puede
observar una tarea abstracta
(Mover ?objeto ?posicion) que sirve para mover un objeto a una localización
determinada por la variable ?posicion. En la figura se pueden observar tres métodos distintos para
descomponer esta tarea abstracta: mover por helicóptero, mover con un
todo-terreno o mover a pie. Si seguimos el método de mover por helicóptero,
entonces la tarea se descompone en las siguientes subtareas (recuadradas en
gris): mover el objeto al punto de aterrizaje, mover el helicóptero al punto de
aterrizaje, cargar el objeto y volar hasta el punto de destino. La subtarea de cargar
el objeto (aparece punteada) es una tarea primitiva o acción, es decir, no se puede
descomponer. El resto son tareas abstractas, es decir, se pueden
descomponer en más subtares. Si seguimos el método de mover en todo-terreno
entonces hay que cargar el objeto en el vehículo y conducir hasta el destino.
Por último, si elegimos el método de moverlo a pie, entonces hay que coger el
objeto y desplazarse andando.
Para un planificador HTN,
los componentes de un problema de planificación son los mismos que los vistos
antes, pero contienen distinta información
- Dominio. Es la descripción de las tareas abstractas y acciones
que se pueden realizar.
- Tareas abstractas. Cada tarea abstracta puede
tener más de un método de descomposición y cada método tiene
- una precondición, es decir,
una fórmula que dice cuándo se puede aplicar ese método
- un conjunto de subtareas, es
decir, la descomposición propiamente dicha
|
(:task mover
:parameters (?objeto ?posicion)
(:method Mover-en-helicoptero
:precondition (and (posicion ?objeto
?actual)(>= (distancia ?actual ?posicion) 100))) ;; precondicion
:tasks((mover ?objeto
?aterrizaje)(mover helicoptero ?aterrizaje)(cargar ?objeto)(volar-a
?posicion))) ;; descomposicion
(:method Mover-en-todo-terreno
:precondition (terreno-abrupto
?posicion) ;; precodicion
:tasks((cargar ?objeto)(conducir-a
?posicion))) ;; descomposicion
(:method Mover-andando
:precondition () ;; precondicion
:tasks ((coger ?objeto)(ir-andando-a
?posicion))) ;; descomposicion
|
o
el
significado de esta tarea abstracta es: si se cumplen las precondiciones de ir
en helicóptero, utiliza ese método para descomponerla, en otro caso, si se
cumplen las precondiciones de ir en todo-terreno, utiliza ese método, y en
cualquier otro caso (sin precondiciones) ve andando.
- Acciones. Cada acción o tarea
primitiva se describe exactamente igual que se ha visto anteriormente a
partir de las listas de precondición, supresión y adición, solo que, en
este caso, la lista de supresión aparece como literales negados en una
única lista de efectos
|
(:action coger
:parameters
(?objeto)
:precondition (posicion ?objeto ?actual) ;; precondicion
:effects (and
(not (posicion ?objeto ?actual)) ;; supresion
(cogido ?objeto))) ;; adicion
|
o
el
significado de esta acción es bastante intuitivo.
- Adicionalmente, un dominio puede contener axiomas,
es decir, reglas que permiten inferir nuevos hechos a partir de hechos que ya
son conocidos. Estos axiomas son de la forma SI <condición> ENTONCES
<consecuencia> y se escribe como (:derived <consecuencia>
<condición>)
|
(:derived (igual ?x ?x) (
))
(:derived (diferente ?x
?y) ((not (igual ?x ?y))))
|
·
Estos
dos axiomas significan lo siguiente. El primero significa que un objeto es
siempre igual a si mismo (la condición esta vacía). El segundo significa si dos
objetos no son iguales, entonces son diferentes.
- Estado inicial. Es igual que antes,
es decir, un conjunto de hechos que son ciertos al comienzo del problema.
- Objetivo. En este caso, es la descripción de una o mas tareas
abstractas que se desean cumplir, por ejemplo (mover estatua-colón
granada).
Ante esta formulación, un
planificador empieza a descomponer la tarea abstracta en subtareas mas pequeñas
hasta que todas las tareas que queden sean primitivas, en este caso la solución
que devuelve es la concatenación de todas las tareas primitivas o acciones en
que se ha descompuesto el problema.
Ejemplo
Siguiendo el conocido mundo
de bloques mencionado anteriormente el
dominio se codificaría de la siguiente forma en la sintaxis de SIADE . En un fichero
llamado dominio aparecen descritas las tareas abstractas y las primitivas, así como otra
información como constantes que puedan aparecer, tipos de los objetos del
problema y axiomas. En otro fichero, llamado de problema, aparecen los objetos
que componen el problema actual y sus tipos, el estado inicial y el objetivo
del problema. Notad que el uso de caracteres
acentuados está prohibido en cualquiera de los ficheros, tanto de dominio como
de problema.
|
Fichero
bloques.pddl (descargar )
|
|
(define
(domain bloques)
(:requirements
:typing
:fluents
:derived-predicates
:negative-preconditions
:htn-expansion)
(:types
bloque superficie -
object)
(:constants mesa -
superficie)
(:predicates
(manovacia)
(libre ?x - bloque)
(cogido ?x - bloque)
(sobremesa ?x - bloque)
(sobre ?x ?y - bloque)
(igual ?x ?y)
(distinto ?x ?y))
(:derived
(igual ?x ?x) ())
(:derived
(distinto ?x ?y) (not (igual ?x ?y)))
(:task sobre
:parameters (?x ?y)
(:method
poner_encima
:precondition () ; vacío
:tasks ((limpiar ?x)(limpiar ?y)(colocar ?x
?y))))
(:task limpiar
:parameters (?x)
(:method
limpiar_mesa
:precondition (igual ?x mesa)
:tasks())
(:method
limpiar_libre
:precondition (libre ?x)
:tasks ())
(:method
limpiar_ocupado
:precondition (sobre ?y ?x)
:tasks ((limpiar ?y)(colocar ?y mesa))))
(:task colocar
:parameters (?x ?y)
(:method colocar
:precondition ()
:tasks ((primero-coge ?x)(despues-deja ?x
?y))))
(:task primero-coge
:parameters (?x - bloque)
(:method
cogelo_de_la_mesa
:precondition (sobremesa ?x)
:tasks (coger ?x))
(:method
cogelo_de_la_pila
:precondition (sobre ?x ?y)
:tasks (desapilar ?x ?y)))
(:task despues-deja
:parameters (?x - bloque ?y - object)
(:method
dejalo_en_la_mesa
:precondition (igual ?y mesa)
:tasks (dejar ?x))
(:method
dejalo_en_la_pila
:precondition (distinto ?y mesa)
:tasks (apilar ?x ?y)))
(:action coger
:parameters (?x - bloque)
:precondition (and (sobremesa ?x)(libre ?x)(manovacia))
:effect (and (not (sobremesa ?x)) (not
(libre ?x))(not (manovacia))
(cogido ?x)))
(:action dejar
:parameters (?x - bloque)
:precondition (cogido ?x)
:effect (and (sobremesa ?x) (libre ?x) (manovacia)
(not (cogido ?x))))
(:action apilar
:parameters (?x ?y - bloque)
:precondition (and (cogido ?x)(libre ?y))
:effect (and (not (cogido ?x)) (not (libre
?y)) (libre ?x) (sobre ?x ?y) (manovacia)))
(:action desapilar
:parameters (?x ?y - bloque)
:precondition (and (manovacia) (libre ?x)
(sobre ?x ?y))
:effect
(and (cogido ?x) (libre ?y) (not (libre ?x)) (not (sobre ?x ?y)) (not (manovacia))))
)
|
Y el problema
descrito en la sección anterior se codificaría como
|
Fichero
sussman.pddl (descargar )
|
|
(define
(problem sussman)
(:domain bloques)
(:objects
A B C - bloque)
(:init
(sobremesa a)
(sobre c a)
(libre c)
(sobremesa b)
(libre b)
(manovacia))
(:tasks-goal
:tasks ((sobre c mesa)(sobre b c)(sobre a
b)))
)
|
|
Fichero
torre1.pddl (descargar )
|
|
Fichero
torre2.pddl (descargar )
|
|
Fichero
pirula.pddl (descargar )
|
Para poder ejecutar SIADEX (ver
Software Disponible) es necesario
seguir los siguientes pasos:
- Primero se
descarga y se ejecuta la script source instalar.
Esto permite utilizar SIADEX en las aulas de prácticas (si quieres obtener el
código fuente de SIADEX para instalarlo en tu casa, visita la página de
software disponible y lee las
condiciones de uso).
- Ahora
se llama al planificador con el dominio de los bloques anterior y alguno de
los problemas.
- siadex bloques.pddl sussman.pddl
Obtendremos una imagen mas
o menos como esta

mostrando que el plan
obtenido (entre otra información) es el mismo que
el visto anteriormente.
|
:action
(desapilar C A)
:action (dejar C)
:action (coger B)
:action (apilar B C)
:action (coger A)
:action (apilar A B)
|
La principal ventaja de la planificación
HTN es que podemos decirle al planificador cómo puede resolver mejor el
problema a través de sus métodos en vez de confiar en un proceso de fuerza
bruta.
[ Siguiente ] |