Agentes Reflexivos - 2 UBICAR Y ENCONTRAR UNA FUENTE DE SONIDO

OBJETIVO
Programar el robot para que utilizando el sensor de sonido (micrófono) pueda ubicar y llegar hasta una fuente de sonido que si bien está fija, funciona de manera episódica. La fuente de sonido puede encontrarse en cualquier dirección con respecto de la dirección inicial del robot y dentro de un área de 15 m2

import lejos.nxt.Button;

import lejos.nxt.LCD;

import lejos.nxt.Motor;

import lejos.nxt.SensorPort;

import lejos.nxt.SoundSensor;

import lejos.robotics.navigation.Pilot;

import lejos.robotics.navigation.TachoPilot;

public class SoundFinder {

public static SoundSensor sound;

public static Pilot pilot;

public static double averange;

public static void main(String[] args)

{

pilot = new TachoPilot(5.6f, 11.5f, Motor.B, Motor.C);

sound = new SoundSensor(SensorPort.S2,true);

pilot.setTurnSpeed(180);

Button.waitForPress();

while(true)

{

int selectedPos=0;

selectedPos=rotateAndFind();

rotate(selectedPos);

pilot.travel(20);

}

}

public static int rotateAndFind()

{

double value=5;

int pos=0;

double temp=0;

for(int i=0; i<8; i++)

{

temp=readSensorValue();

print("esc "+temp);

if(temp>value)

{

value=temp;

pos=i;

}

pilot.rotate(45);

while(pilot.isMoving());

pilot.stop();

}

pilot.rotate(10); //fix de 180

print("Val max:"+value);

return pos;

}

public static void print(String text)

{

LCD.clear();

LCD.drawString(text, 2, 2);

}

public static void rotate(int val)

{

print("Acomodando");

pilot.rotate(45*val);

pilot.rotate(55); //fix de rotación

}

public static double readSensorValue()

{

double value=0.0;

sleep(500);

value=sound.readValue();

sleep(500);

return value;

}

public static void sleep(int time)

{

try {

Thread.sleep(time);

} catch (InterruptedException e) {

}

}

}

Agentes Reflexivos - 1 SEGUIR UNA LÍNEA NEGRA

OBJETIVO
Programar el robot para que utilizando el sensor de luz pueda encontrar y seguir una trayectoria marcada con una línea negra pintada sobre una superficie plana. La trayectoria puede ser recta, con giros en varios ángulos, zig-zag, etc.

import lejos.nxt.*;

import lejos.robotics.navigation.*;

import lejos.robotics.subsumption.*;

public class FollowBlackLine {

public static void main(String[] args){

Pilot pilot = new TachoPilot(5.6f, 11.25f, Motor.B, Motor.C);

LightSensor light = new LightSensor(SensorPort.S3);

pilot.setTurnSpeed(180);

Behavior getBackToLine = new GetBackToLine(pilot, light);

Behavior goForward = new GoForward(pilot, light);

Behavior [] behaviorArray = {getBackToLine, goForward};

Arbitrator arbitrator = new Arbitrator(behaviorArray);

LCD.drawString("Follow Black Line", 2, 2);

Button.waitForPress();

arbitrator.start();

}

}

import lejos.nxt.*;

import lejos.robotics.subsumption.*;

import lejos.robotics.navigation.*;

public class GetBackToLine implements Behavior, SensorPortListener{

private Pilot pilot;

private LightSensor light;

private int sweep;

private boolean suppress;

private boolean outOfBlackLine;

public GetBackToLine(Pilot pilot, LightSensor light){

this.pilot = pilot;

this.light = light;

suppress = false;

outOfBlackLine = false;

SensorPort.S3.addSensorPortListener(this);

}

public void stateChanged(SensorPort port, int oldValue, int newValue){

if(light.readValue() > 35){

outOfBlackLine = true;

}

}

public boolean takeControl(){

if(outOfBlackLine){

LCD.clear();

LCD.drawString("GetBackToLine", 2, 2);

outOfBlackLine = false;

return true;

}

else {

return false;

}

}

public void suppress(){

suppress = true;

}

public void action(){

sweep = 10;

while(!suppress){

pilot.rotate(sweep, true);

while(!suppress && pilot.isMoving()){

Thread.yield();

}

sweep*=-2;

}

pilot.stop();

suppress = false;

}

}

import lejos.nxt.*;

import lejos.robotics.subsumption.*;

import lejos.robotics.navigation.*;

public class GoForward implements Behavior, SensorPortListener{

private Pilot pilot;

private LightSensor light;

private boolean foundBlackLine;

public GoForward(Pilot pilot, LightSensor light){

this.pilot = pilot;

this.light = light;

foundBlackLine = false;

SensorPort.S3.addSensorPortListener(this);

}

public void stateChanged(SensorPort port, int oldValue, int newValue){

if(light.readValue() <= 35){

foundBlackLine = true;

}

}

public boolean takeControl(){

if(foundBlackLine){

LCD.clear();

LCD.drawString("GoForward", 2, 2);

foundBlackLine = false;

return true;

}

else{

return false;

}

}

public void suppress(){

pilot.stop();

}

public void action(){

pilot.forward();

while(light.readValue() <= 35){

Thread.yield();

}

}

}

Tarea: ¿Qué Agente para qué Problema?

AGENTES Y AMBIENTES
EJERCICIOS

¿QUÉ AGENTE PARA QUÉ PROBLEMA?
Para los siguientes problemas señala qué tipo de agente podría resolverlo mejor (reflexivo o deliberativo). Es importante justificar la respuesta y dar ejemplos de situaciones en los que uno u otro tipo de agente podría desempeñarse mejor.

- Salir de un laberinto
Reflexivo. Esto ya que con un simple algoritmo en el que el agente pueda seguir una trayectoria de seguir la pared derecha basta para poder resolver este problema.

- Explorar habitaciones y reconocer los objetos encontrados dentro de éstas.
Deliberativo (Reflexivo con memoria). Esto debido a que el agente debe de recordar cómo se encuentra el mundo. Un agente solo reflexivo no podría guardar el estado del mendo actual.

- Jugar ajedrez
Deliberativo (guiado por utilidad). Esto que el agente debe de estudiar su situación actual y tratar de tomar decisiones en base a eso, debe buscar una estrategia y poder continuarla por más de un turno.

- Jugar dominó (en parejas).
Deliberativo (guiado por objetivo). Esto ya que el agente debe analizar qué posibilidades tiene de lanzar una pieza dependiendo de las que ya se jugaron.

- Cuidar una persona mayor en su casa.
Deliberativo (guiado por utilidad). Esto ya que se debe de analizar no solo que el agente cumpla con su tarea, si no, también importa cómo fue que la realizó.

- Asistir a un ejecutivo en el manejo de su agenda.
Deliberativo (guiado por utilidad). Esto ya que el agente debe de estudiar por lo general un histórico para poder analizar la mayor cantidad de información y así poder dar un mejor resultado.

- Asistir a un ejecutivo en la preparación de sus viajes de negocios
Deliberativo (guiado por utilidad). Esto ya que debe de analizar una gran cantidad de información, procesarla para poder realizar una combinación que pueda dar un mejor resultado entre las opciones de viaje posibles.

La mayoría de estos problemas deben ser resueltos por un agente deliberativo, esto ya que requieren un razonamiento y tener conocimiento del mundo en el que se encuentra para poder desempeñar su tarea.


METODOLOGÍA PAGE
Una forma para responder la pregunta anterior es construir una definición PAGE de cada uno de los agentes. Esta definición consiste de 4 partes:
-Perceceptions: Qué cosas será capaz de percibir el agente.
-Actions: Qué acciones será capaz de llevar a cabo el agente.
-Goals (Objetivo): Cuál es el objetivo del agente.
-Environment (Ambiente): Qué características tiene el ambiente en el que el agente va a llevar a cabo su tarea y que pueden afectarlo.








3 MAS PROBLEMAS…
Para los siguientes problemas señala qué tipo de agente podría resolverlo mejor (reflexivo o
deliberativo). Es importante justificar la respuesta y dar ejemplos de situaciones en los que uno u
otro tipo de agente podría desempeñarse mejor.
- Controlar el tráfico de aviones en el aeropuerto.
- Monitorear el tráfico de automóviles en la ciudad de Guadalajara.
- Monitorear las condiciones del bosque de la primavera para evitar y/o responder
ante incendios forestales.
Haz una descripción PAGE de los agentes.






¿En qué son diferentes estos problemas con respecto de los del punto 2?
Estos problemas se pueden resolver con agentes reflexivos los cuales responder a alguna lectura de uno o varios sensores y actúa de acuerdo a ello.

¿Qué necesita un agente para poder resolverlos?
Necesita sensores y actuadores.

Tipos de Agentes

Agente	Tipo de Agente	Percepciones	Acciones	Objetivos	Ambiente
					accesi ble	determi nista	episó dico	está tico	discre to
ajedrez	guiado por utilidad	posiciones de las piezas en el tablero	mover pieza, quitar pieza	eliminar al rey	si	si	no	si	si jugador contrario, piezas en el tablero
poker	guiado por objetivo	cartas, cámara	tomar carta, jugar carta, apostar, retirarse	aumentar ganancias, ganar partida	no	no	no	si	si jugadores, cartas, apuestas
manejar un taxi	reflexivo	cámara, velocímetro, gps, microfono	dirigir el volante, acelerar, frenar, escuchar al pasajero	ruta más corta, aumentar ganancias, viaje rápido y seguro	no	no	no	no	no calle, tráfico, peatones, clientes
sistema de análisis de imágenes	reflexivo con memoria	imagenes	comparar imagen, girar	asociar imagen	si	si	si	semi	no usuario, imagen

Planificación

3.1 IR DE COMPRAS

Predicados:
At(place) – Señala que estamos en el lugar place
Have(thing) – Dice que tenemos thing
Sell(store, thing) – La tienda store vende la cosa thing

Operaciones:
OP {
Action: Go(there)
Precondition: At(here)
Effect: At(there) ^ ¬At(here)
}

OP {
Action: Buy(thing)
Precondition: At(store) ^ Sell(store, thing)
Effect: Have(thing)
}

Estado Inicial:
At(Home) ^ ¬Have(Milk) ^ ¬Have(Bananas) ^ ¬Have(Drill) ^ Sell(SM, Milk) ^ Sell(SM, Bananas) ^ Sell(HWS, Drill)

Estado Objetivo:
At(Home) ^ Have(Milk) ^ Have(Bananas) ^ Have(Drill)

 
3.2 EL MUNDO DE LOS CUBOS

Predicados:
cubo(x) - x es un cubo
brazoRobot(r) - r es un brazo robótico que puede sostener y mover cubos
sobreMesa(x) - cubo x está sobre la mesa
sobreCubo(x,y) - cubo x está sobre cubo y
nadaEncima(x) - cubo x no tiene nada sobre él mismo
sostener(x) - el brazo robot sostiene al cubo x
robotLibre(x) - el brazo robot no sostiene ningún cubo

Operaciones:
OP {
Action: TomarCubodeMesa(x)
Precondition:
nadaEncima(x) ^ cubo(x) ^ brazoRobot(r) ^ sobreMesa(x) ^ robotLibre(r)
Effects: sostener(x) ^ ¬ sobreMesa(x) ^ ¬ robotLibre(r)
}

OP {
Action: TomarCubodeOtroCubo(x,y)
Precondition:
nadaEncima(x) ^ cubo(x) ^ cubo(y) ^ brazoRobot(r) ^ sobreCubo(x,y) ^ robotLibre(r)
Effects: sostener(x) ^ nadaEncima(y) ^ ¬sobreCubo(x,y) ^ ¬ robotLibre(r)
}

OP {
Action: DejarSobreMesa(x)
Precondition: brazoRobot(r) ^ sostener(x) ^ cubo(x)
Effects: ¬sostener(x) ^ sobreMesa(x) ^ robotLibre(r)
}

OP {
Action: DejarSobreCubo(x,y)
Precondition: brazoRobot(r) ^ sostener(x) ^ cubo(x)
Effects: ¬sostener(x) ^ sobreCubo(x,y) ^ robotLibre(r)
}

Estado Inicial: Cualquier configuración de cubos sobre la mesa
cubo(A) cubo(B) cubo(C) sobreMesa(A) sobreMesa(B) sobreCubo(C,A) brazoRobot(r) robotLibre(r)

Estado Objetivo: Cualquier configuración diferente de cubos sobre la mesa
cubo(A) cubo(B) cubo(C) sobreMesa(C) sobreCubo(B,C) sobreCubo(A,B) brazoRobot(r) robotLibre(r)

 
3.3 EL MUNDO DE SHAKEY

El estado inicial de este problema es una configuración cualquiera de salones, cajas y Shakey. El estado objetivo es que todas las cajas y Shakey estén en el salón 1, todos los salones tengan las luces apagadas.
At(Room)
Señala que Shakey está en el cuarto Room.

LightOff(Room)
Señala que la luz está apagada en ese cuarto.

AreBoxes(NumberOfBoxes,Room)
Señala el número de cajas que hay en el cuarto, debe de haber al menos una para que Shakey apague la luz.

Initial State:
AtRoom(r3) ^ AreBoxes(4b,r 1)^¬LightOff(r1) ^LightOff(r2) ^LightOff(r3) ^¬LightOff(r4)

Gold State:
AtRoom(r1) ^ AreBoxes(4b,r 1)^LightOff(r1) ^LightOff(r2) ^LightOff(r3) ^LightOff(r4)

OP {
Action: Start
Precondition: {}
Effect: {Initial State}
}

OP {
Action: Finish
Precondition: {Gold State}
Effect: { }
}

OP {
Action: Go(rx)
Precondition: {At(ry)}
Effect: { At(rx)^¬At(ry)}
}

OP {
Action: TurnOffLight (Room)
Precondition: {¬LightOff(Room)^AreBoxes(b>=1,Room)}
Effect: { LightOff(Room)^ ¬LightOff(Room)}
}

OP {
Action: BringBox(rx,ry) //trae caja de rx a ry
Precondition: { AreBoxes(b>=1,rx)}
Effect: {AreBoxes(b-1,rx)^ AreBoxes(b+1,ry)^At(ry) }
}

Reglas de Relaciones Familiares

1. ∀m,c Mother(c)=m ↔Female(m)^Parent(m,c)
2. ∀w,h Husband(h,w)↔Male(h)^Spouse(h,w)
3. ∀x Male(x)↔¬Female(x)
4. ∀p,c Parent(p,c)↔Child(c,p)
5. ∀g,c Grandparent(g,c)↔∃p Parent(g,p)^Parent(p,c)
6. ∀x,y Sibling(x,y)↔x≠y^ ∃p Parent(p,x)^Parent(p,y)
7. ∀f,c Father(c)=f↔Male(f)^Parent(f,c)
8. ∀w,h Wife(w,h)↔Female(w)^Spouse(w,h)
9. ∀gf,c Grandfather(gf,c)↔∃g Grandparent(g,c)^Male(gf)
10. ∀gm,c Grandmother(gm,c)↔∃p Grandparent(gm,c)^Female(gm)
11. ∀u,n Uncle(u,n)↔∃pParent(p,n)^Sibling(p,u)^Male(u)
12. ∀a,n Aunt(a,n)↔∃pParent(p,n)^Sibling(p,a)^Female(a)
13. ∀c,x Cousin(c,x)↔∃p,t Parent(p,x)^Parent(t,c)^Sibling(p,t)
14. ∀b,x Brother(b,x)↔Sibling(b,x)^Male(b) 
15. ∀s,x Sister(s,x)↔Sibling(s,x)^Female(s)
16. ∀bi,x BrotherInLaw(bi,x)↔∃sp,s,b[Husband(bi,s)^Sister(s,x)]∨
    [Brother(b,sp)^([Wife(sp,x)^Male(x)]∨[Husband(sp,x)^Female(x)])]
17. ∀si,x SisterInLaw(si,x)↔∃sp,s,b[Wife(si,b)^Brother(b,x)]∨
    [Sister(s,sp)^([Wife(sp,x)^Male(x)]∨[Husband(sp,x)^Female(x)])]

Lógica de Primer Orden

1. No todos los estudiantes toman Inteligencia Artificial y Sistemas Distribuidos
   ∃x Estudiante(x)→¬[Toma(x,IA) ]⋀Toma(x,SD)]

2. Solo un estudiante reprobó Inteligencia Artificial
   ∀x,y Estudiante(x)  ⋀ Estudiante(y) ⋀ Reprobar(x,IA) 
   ⋀ Reprobar(y,IA) ↔x=y

3. Solo un estudiante reprobó tanto Inteligencia Artificial como Sistemas Distribuidos
   ∀x,y Estudiante(x)  ⋀ Estudiante(y)  ⋀ Reprobar(x,IA) 
   ⋀ Reprobar(y,IA) ⋀ Reprobar(x,SD) ⋀ Reprobar(y,SD)↔x=y

4. La mejor calificación en Inteligencia Artificial fue más alta que la primera calificación en Sistemas Distribuidos
   ∀x,y Calificacion(x,IA)  ⋀ Calificacion(y,SD)→CalificacionMasAlta(x,y)

5. Cualquier persona a quien le caigan mal los vegetarianos es lista
   ∀x,y CaerMal(x) ⋀ Vegetariano(y)→PersonaLista(x)

6. Nadie quiere a un vegetariano listo
   ∀x,y Quiere(x,y)→¬Vegetariano(y)  ⋁ ¬PersonaLista(y)

7. Existe una mujer que quiere a todos los hombres que no son vegetarianos
   ∃x,y Mujer(x)  ⋀ Hombre(y)  ⋀ Quiere(x,y)→¬Vegetariano(y)

8. Existe un barbero en la ciudad que rasura a todos los hombres que no se rasuran solos
   ∃x,y Barbero(x)  ⋀ Hombre(y)  ⋀ Rasura(x,y)→¬SeRasuraSolo(y)

9. Nadie quiere al profesor a menos que el profesor sea inteligente
   ∀x,y Quiere(x,y) ⋀ Profesor(y)→Inteligente(y)

10. Los politicos pueden engañar a algunas personas todo el tiempo y pueden engañar a todas las personas algún tiempo pero no pueden engañar a todas las personas todo el tiempo
    ∃x,y EngañaTodoElTiempo(x,y) ⋀ ∀x,y EngañaAlgunTiempo(x,y)
    ⋀ ¬∀x,y EngañaTodoElTiempo(x,y)→Politico(x)