Práctica de Agentes Reflexivos

Cucaracha:





Rodear Objeto:





Salir Laberinto:





Seguir Línea:





Seguir Sonido:

Descripción PEAS

Descripción del task environment de varios agentes con metodología PEAS (Performance measure, environment, actuators y sensors):

Agente		Performance Measure	Environment	Actuators	Sensors
Ajedrez		Dificultad ideal de acuerdo a la experiencia del jugador.	Fichas en el tablero, fichas del agente, fichas del usuario, espacio disponible/ocupado en el tablero.	Mover ficha.	Cámara para detectar el estado del tablero.
Póker		Dificultad ideal de acuerdo a la experiencia del jugador.	Cartas en la mano, juego del usuario.	Tomar cartas, elegir cartas, cambiar cartas, mostrar mano.	Evaluar mano del oponente, estudiar cartas.
Chofer		Seguro, rápido, legal, viaje confortable, maximización de ganancias.	Camino, tráfico, peatones, clientes.	Dar vuelta, acelerar, frenar, obedecer señales, claxon.	Cámaras, sonar, velocímetro, GPS, odómetro, sensores de motor.
Sistema de análisis imágenes		Veracidad del diagnóstico, costo reducido, satisfacción del usuario.	Imagen a analizar, datos adicionales, paciente.	Pedir imagen, obtener imagen, escanear imagen, analizar imagen, emitir un diagnóstico.	Cámara para obtención de imagen.

Ejercicios de Planificación

- Ejercicios de Planificación -

Ir de Compras

Estados:

· Estado_inicial -> At(casa) ᴧ ~Have(penca) ᴧ ~Have(taladro) ᴧ ~Have(leche) ᴧ Sell(SM, leche) ᴧ Sell(SM, penca) ᴧ Sell(Ferretería, taladro).

· Estado_final -> At(casa) ᴧ Have(penca) ᴧ Have(taladro) ᴧ Have(leche).

Predicados:

· At(x): estar en el lugar ‘x’.

· Have(x): tener la cosa ‘x’.

· Sell(x, y): la tienda ‘x’ vende la cosa ‘y’.

Operadores:

OP { ACTION: Go(there),

PRECOND: At(here),

EFFECT: At(there) ᴧ ~At(here) }

OP { ACTION: Buy(thing),

PRECOND: At(store) ᴧ Sell(store, thing),

EFFECT: Have(thing) }

OP { ACTION: Start,

PRECOND:( ),

EFFECT: (estado_inicial) }

OP { ACTION: Finish,

PRECOND:(estado_final),

EFFECT: ( ) }

El Mundo de los Cubos

Estados:

· Estado_inicial -> OnTable(cubo1) ᴧ On(cubo2, cubo1) ᴧ

On(cubo3, cubo2) ᴧ Clear(cubo3) ᴧ Empty().

· Estado_final -> Empty() ᴧ OnTable(cubo1) ᴧ OnTable(cubo2) ᴧ

OnTable(cubo3) ᴧ Clear(cubo1) ᴧ Clear(cubo2) ᴧ

Clear(cubo3).

Predicados:

· Holding(x): la garra está sosteniendo el cubo ‘x’.

· On(x, y): el cubo ‘x’ está encima del cubo ‘y’.

· Empty(): la garra no está sosteniendo un cubo alguno.

· OnTable(x): el cubo ‘x’ se encuentra sobre la mesa.

· Clear(x): el cubo ‘x’ no tiene cubo alguno sobre de él.

Operadores:

OP { ACTION: Pickup(cubo1, cubo2),

PRECOND: Empty() ᴧ clear(cubo1) ᴧ On(cubo1, cubo2),

EFFECT: Holding(cubo1) ᴧ Clear(cubo2),

~Empty() ᴧ ~On(cubo1, cubo2) ᴧ ~Clear(cubo1) }

OP { ACTION: PickupFromTable(cubo),

PRECOND: Empty() ᴧ Clear(cubo) ᴧ OnTable(cubo),

EFFECT: Holding(cubo),

~Empty() ᴧ ~OnTable(cubo) ᴧ ~Clear(cubo) }

OP { ACTION: PutDown(cubo1, cubo2),

PRECOND: Holding(cubo1) ᴧ clear(cubo2),

EFFECT: Empty() ᴧ On(cubo1, cubo2) ᴧ Clear(cubo1),

~Clear(cubo2) ᴧ ~Holding(cubo1) }

OP { ACTION: PutDownOnTable(cubo),

PRECOND: Holding(cubo),

EFFECT: Empty() ᴧ OnTable(cubo) ᴧ Clear(cubo),

~Holding(cubo) }

OP { ACTION: Start,

PRECOND:( ),

EFFECT: (estado_inicial) }

OP { ACTION: Finish,

PRECOND:(estado_final),

EFFECT: ( ) }

El Mundo de Shakey

Estados:

· Estado_inicial -> Box(c1) ᴧ Box(c2) ᴧ Box(c3) ᴧ Box(c4) ᴧ Room(r1) ᴧ Room(r2) ᴧ Room(r3) ᴧ Room(r4) ᴧ Room(pasillo) ᴧ On(r3) ᴧ On(r2) ᴧ Off(r1) ᴧ Off(r4) ᴧ At(c1, r1) ᴧ At(c2, r1) ᴧ At(c3, r1) ᴧ At(c4, r1) ᴧ At(shakey, pasillo).

· Estado_final -> At(c1, r1) ᴧ At(c2, r1) ᴧ At(c3, r1) ᴧ

At(c4, r1) ᴧ At(shakey, r1) ᴧ Off(r1) ᴧ Off(r2) ᴧ Off(r3) ᴧ

Off(r4).

Predicados:

· Box(x): ‘x’ es una caja.

· Room(x): ‘x’ es un cuarto.

· Shakey(x): ‘x’ es un robot.

· On(r): la luz de la habitación ‘r’ está encendida.

· Off(r): la luz de la habitación ‘r’ está apagada.

· At(x, r): ‘x’ está en la habitación ‘r’.

· Holding(x): shakey sostiene el objeto (caja) ‘x’.

· OnTop(x): shakey está encima de la caja ‘x’.

· Free(shakey): shakey no está sosteniendo ninguna caja.

· OnFloor(shakey): shakey está en el suelo.

Operadores:

OP { ACTION: TomarCaja(x),

PRECOND: Free(shakey) ᴧ Caja(x) ᴧ At(shakey, r) ᴧ

At(x, r) ᴧ OnFloor(shakey),

EFFECT: Holding(x) ᴧ ~Free(shakey) }

OP { ACTION: ApagarCuarto(r),

PRECOND: Cuarto(r) ᴧ On(r) ᴧ At(shakey, r) ᴧ OnTop(x),

EFFECT: ~On(r) }

OP { ACTION: SubirCaja(x),

PRECOND: Caja(x) ᴧ Free(shakey) ᴧ At(shakey, r) ᴧ

At(x, r) ᴧ OnFloor(shakey),

EFFECT: OnTop(x) ᴧ ~OnFloor }

OP { ACTION: BajarCaja(x),

PRECOND: OnTop(x),

EFFECT: OnFloor(shakey) ᴧ ~OnTop(x) }

OP { ACTION: DejarCaja(x),

PRECOND: Holding(x),

EFFECT: ~Holding(x) ᴧ Free(shakey) }

OP { ACTION: EntrarCuarto(r),

PRECOND: At(shakey, pasillo) ᴧ OnFloor(shakey),

EFFECT: At(shakey, r) ᴧ ~At(shakey, pasillo) }

OP { ACTION: SalirCuarto(r),

PRECOND: At(shakey, r) ᴧ OnFloor(shakey),

EFFECT: ~At(shakey, r) ᴧ At(shakey, pasillo) }

OP { ACTION: SacarCaja(x),

PRECOND: Holding(x) ᴧ At(shakey, r),

EFFECT: ~At(x, r) ᴧ ~At(shakey, r) ᴧ

At(shakey, pasillo) ᴧ At(x, pasillo) }

OP { ACTION: MeterCaja(x),

PRECOND: Holding(x) ᴧ At(shakey, pasillo),

EFFECT: At(x, r) ᴧ At(shakey, r) ᴧ ~At(shakey, pasillo)

ᴧ ~At(x, pasillo) }

OP { ACTION: Start,

PRECOND:( ),

EFFECT: (estado_inicial) }

OP { ACTION: Finish,

PRECOND:(estado_final),

EFFECT: ( ) }