Agentes Reflexivos - 3 RODEAR UN OBJETO

OBJETIVO
Programar el robot para que utilizando el sensor de toque pueda encontrar y rodear un
objeto siguiendo su contorno. El objeto puede tener cualquier forma (rectangular como una caja o cilíndrica como un bote, el objeto será suficientemente pesado como para que el robot no lo mueva, dentro de límites razonables. El objeto podrá estar en cualquier posición con respecto del robot dentro de un área de 15 m².

import lejos.nxt.*;

import lejos.nxt.comm.RConsole;

import lejos.robotics.navigation.*;

import lejos.robotics.subsumption.*;

public class GoAround{

public static void main(String[] args){

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

TouchSensor touch = new TouchSensor(SensorPort.S3);

UltrasonicSensor ultrasonic = new UltrasonicSensor(SensorPort.S1);

Behavior goForward = new GoForward(pilot);

Behavior hitObject = new HitObject(pilot, touch, ultrasonic);

Behavior [] behaviorArray = {goForward, hitObject};

Arbitrator arbitrator = new Arbitrator(behaviorArray);

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

Button.waitForPress();

arbitrator.start();

}

}

import lejos.nxt.LCD;

import lejos.robotics.subsumption.*;

import lejos.robotics.navigation.*;

public class GoForward implements Behavior{

private Pilot pilot;

public GoForward(Pilot pilot){

this.pilot = pilot;

}

public boolean takeControl(){

LCD.clear();

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

return true;

}

public void suppress(){

pilot.stop();

}

public void action(){

pilot.forward();

}

}

import lejos.nxt.*;

import lejos.robotics.subsumption.*;

import lejos.robotics.navigation.*;

public class HitObject implements Behavior, SensorPortListener{

private TachoPilot pilot;

private TouchSensor touch;

private UltrasonicSensor ultrasonic;

private boolean hit;

private int backoff;

private int rotationAngle;

private int distance;

private int lastDistance;

private int distanceDifference;

private int veryCloseLeft;

private int slightlyCloseLeft;

private int notCloseLeft;

private int slightlyFarRight;

private int veryFarRight;

private int basePowerLeft;

private int basePowerRight;

private Motor rightMotor;

private Motor leftMotor;

public HitObject(TachoPilot pilot, TouchSensor touch, UltrasonicSensor ultrasonic){

this.pilot = pilot;

this.touch = touch;

this.ultrasonic = ultrasonic;

hit = false;

SensorPort.S3.addSensorPortListener(this);

backoff = 5;

rotationAngle = -90;

distance = 0;

lastDistance = 0;

veryCloseLeft = 20;

slightlyCloseLeft = 25;

notCloseLeft = 30;

slightlyFarRight = 35;

veryFarRight = 40;

basePowerLeft = 100;

basePowerRight = 99;

rightMotor = (Motor)pilot.getRight();

leftMotor = (Motor)pilot.getLeft();

}

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

if(touch.isPressed()){

hit = true;

}

}

public boolean takeControl(){

if(hit){

LCD.clear();

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

hit = false;

return true;

}

else{

return false;

}

}

public void suppress(){

pilot.stop();

}

public void action(){

pilot.stop();

pilot.travel(-backoff);

pilot.rotate(rotationAngle);

while(true){

lastDistance = distance;

distance = ultrasonic.getDistance();

distanceDifference = lastDistance - distance;

if(distance <= notCloseLeft){

if(distance <= veryCloseLeft){

rightMotor.setPower(basePowerRight);

rightMotor.backward();

leftMotor.setPower(basePowerRight);

leftMotor.forward();

}

else if(distance <= slightlyCloseLeft){

rightMotor.setPower(0);

rightMotor.stop();

leftMotor.setPower(basePowerLeft);

leftMotor.forward();

}

else if(distance <= notCloseLeft){

leftMotor.setPower(basePowerLeft);

leftMotor.forward();

rightMotor.setPower(0);

rightMotor.flt();

}

}

else{

if(distance >= slightlyFarRight){

if(distanceDifference < 2){

leftMotor.setPower(0);

leftMotor.stop();

rightMotor.setPower(basePowerRight);

rightMotor.forward();

}

}

else if(distance >= veryFarRight){

leftMotor.setPower(basePowerLeft/2);

leftMotor.forward();

rightMotor.setPower(basePowerLeft);

rightMotor.forward();

}

}

try {

Thread.sleep(30);

}

catch(InterruptedException e){

}

}

}

}

Agentes Reflexivos - 5 HUIR DE LA LUZ (ROBOT ESPÍA O CUCARACHA ARTIFICIAL)

OBJETIVO
Programar el robot para que emule el comportamiento de un robot espía. Este robot utiliza sus sensores ultrasónicos para moverse en una habitación oscura. Si la luz se enciende quiere decir que alguien entra a la habitación y debe esconderse en un lugar oscuro (debajo de algún mueble en un rincón). OJO. Para fines de esta práctica, el robot debe correr a un rincón oscuro, no solamente protegerse de la luz.

import lejos.nxt.*;

import lejos.robotics.subsumption.*;

import lejos.robotics.navigation.*;

public class Hide {

public static void main (String[] aArg) throws Exception {

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

LightSensor light = new LightSensor(SensorPort.S3);

UltrasonicSensor distance =new UltrasonicSensor(SensorPort.S1);

pilot.setTurnSpeed(300);

Behavior getBackToShadow = new GetBackToShadow(pilot, light);

//Behavior goForward = new GoForward(pilot, light);

Behavior findAWall = new FindAWall(pilot,distance);

//Behavior [] behaviorArray = {getBackToLine, goForward, findAWall};

Behavior [] behaviorArray = {getBackToShadow, findAWall};

Arbitrator arbitrator = new Arbitrator(behaviorArray);

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

Button.waitForPress();

arbitrator.start();

}

}

import lejos.nxt.*;

import lejos.robotics.subsumption.*;

import lejos.robotics.navigation.*;

public class GetBackToShadow implements Behavior, SensorPortListener{

private Pilot pilot;

private LightSensor light;

private int sweep;

private boolean suppress;

private boolean inLight;

public GetBackToShadow(Pilot pilot, LightSensor light){

this.pilot = pilot;

this.light = light;

suppress = false;

inLight = false;

SensorPort.S3.addSensorPortListener(this);

}

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

if(light.readValue() > 20){

inLight = true;

}

}

public boolean takeControl(){

if(inLight){

LCD.clear();

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

inLight = false;

return true;

}

else {

return false;

}

}

public void suppress(){

do{

pilot.stop();

}while(light.readValue() < 20);

suppress = true;

}

public void action(){

while(!suppress){

int prev=light.readValue();

if(prev>20){

pilot.travel(20);

if(prev < light.readvalue())< div="">

{

pilot.rotate(90);

}

}

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

Thread.yield();

}

}

suppress = false;

}

}

light.readvalue())

import lejos.nxt.*;

import lejos.robotics.subsumption.*;

import lejos.robotics.navigation.*;

public class FindAWall implements Behavior, SensorPortListener{

private Pilot pilot;

private UltrasonicSensor distance;

private int sweep;

private boolean suppress;

private boolean findWall;

public FindAWall(Pilot pilot, UltrasonicSensor distance){

this.pilot = pilot;

this.distance = distance;

suppress = false;

findWall = false;

SensorPort.S3.addSensorPortListener(this);

}

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

if(distance.getDistance() < 20){

findWall = true;

}

}

public boolean takeControl(){

if(findWall){

LCD.clear();

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

findWall = false;

return true;

}

else {

return false;

}

}

public void suppress(){

suppress = true;

}

public void action(){

while(distance.getDistance()<20){

pilot.rotate(90);

}

suppress=false;

}

}

Agentes Reflexivos - 4 SALIR DE UN LABERINTO

OBJETIVO
Programar el robot para que utilizando el sensor ultrasónico pueda localizar obstáculos y girar para evitarlos. El robot también se debe programar para que utilizando estas habilidades (localizar obstáculos y girar) pueda salir de un laberinto de ángulos rectos.

import lejos.nxt.*;

import lejos.robotics.navigation.*;

import lejos.robotics.subsumption.*;

public class Labyrinth {

public static void main(String [] args){

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

UltrasonicSensor ultrasonic = new UltrasonicSensor(SensorPort.S1);

Behavior getOut = new GetOut(pilot, ultrasonic);

Behavior [] behaviorArray = {getOut};

Arbitrator arbitrator = new Arbitrator(behaviorArray);

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

Button.waitForPress();

arbitrator.start();

}

}

import lejos.nxt.*;

import lejos.robotics.subsumption.*;

import lejos.robotics.navigation.*;

public class GetOut implements Behavior{

private TachoPilot pilot;

private UltrasonicSensor ultrasonic;

private int distance;

private int lastDistance;

private int distanceDifference;

private int veryCloseLeft;

private int slightlyCloseLeft;

private int notCloseLeft;

private int slightlyFarRight;

private int veryFarRight;

private int basePowerLeft;

private int basePowerRight;

private Motor rightMotor;

private Motor leftMotor;

public GetOut(TachoPilot pilot, UltrasonicSensor ultrasonic){

this.pilot = pilot;

this.ultrasonic = ultrasonic;

distance = 0;

lastDistance = 0;

veryCloseLeft = 7;

slightlyCloseLeft = veryCloseLeft + 5;

notCloseLeft = slightlyCloseLeft + 5;

slightlyFarRight = notCloseLeft + 5;

veryFarRight = slightlyFarRight + 5;

basePowerLeft = 100;

basePowerRight = 100;

rightMotor = (Motor)pilot.getRight();

leftMotor = (Motor)pilot.getLeft();

}

public boolean takeControl(){

LCD.clear();

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

return true;

}

public void suppress(){

pilot.stop();

}

public void action(){

pilot.forward();

while(true){

int regSpeed = 270;

int changeSpeed = 333;

int noSpeed = 0;

rightMotor.setSpeed(regSpeed);

leftMotor.setSpeed(regSpeed);

lastDistance = distance;

distance = ultrasonic.getDistance();

distanceDifference = lastDistance - distance;

if(distance <= notCloseLeft){

if(distance <= veryCloseLeft){

rightMotor.setPower(basePowerRight);

rightMotor.backward();

leftMotor.setPower(basePowerRight);

leftMotor.forward();

}

else if(distance <= slightlyCloseLeft){

rightMotor.setSpeed(noSpeed);

rightMotor.setPower(0);

rightMotor.forward();

leftMotor.setSpeed(changeSpeed);

leftMotor.setPower(basePowerLeft);

leftMotor.forward();

}

else if(distance <= notCloseLeft){

leftMotor.setPower(basePowerLeft);

leftMotor.forward();

rightMotor.setPower(0);

rightMotor.flt();

}

}

else{

if(distance >= slightlyFarRight){

if(distanceDifference < 2){

leftMotor.setSpeed(noSpeed);

leftMotor.setPower(0);

leftMotor.forward();

rightMotor.setSpeed(changeSpeed);

rightMotor.setPower(basePowerRight);

rightMotor.forward();

}

}

else if(distance >= veryFarRight){

leftMotor.setPower(basePowerLeft/2);

leftMotor.forward();

rightMotor.setPower(basePowerLeft);

rightMotor.forward();

}

}

try {

Thread.sleep(30);

}

catch(InterruptedException e){

}

}

}

}

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)

Búsqueda 1

Para formalizar un problema se sugieren los siguientes puntos:

• El espacio de estados, es decir, el conjunto de todos los estados válidos posibles que cumplen con las restricciones del problema.
• La representación de los estados es consistente: la variable que define el estado inicial contiene los mismos elementos que la del estado objetivo.
• Los operadores específicos son en base a las variables representadas.
• El estado inicial puede ser una configuración cualquiera de las variables en caso de no tener una determinada.
• Los estados corresponden a estructuras de datos del programa.
• Los operadores se encargan de modificar con algoritmos las estructuras de datos.
• Completo significa que se representan todos los estados posibles. No redundante, que se eliminan ciclos.
• Los elementos esenciales de un nodo son: estado, profundidad, operador que lo creó y su nodo padre.

En el ejemplo de la búsqueda de un número telefónico teniendo el nombre y apellido de la persona a buscar, en clase se planteó lo siguiente:

Estado inicial: Directorio, Nombre, Apellido

Operadores: Cambiar directorio, verificar directorio, buscar en índice, ir a página, cambiar página, buscar en página, comparar apellido y nombre.

Estado objetivo: Directorio, Nombre, Apellido y número conocidos.

Costo de la ruta: Cuántas veces se cambió de directorio o página.

Como podemos observar, el número de variables en el estado inicial no concuerda con las variables del estado objetivo, por lo que tenemos un primer problema. Como siguiente observación, nos podemos dar cuenta que los operadores son muy generales y no están completos y/o correctos. Tenemos que recordar que los operadores deben ser lo más claros y específicos posibles.

Como segundo ejemplo se expuso la resolución del cubo de rubik, teniendo lo siguiente:

-Estado inicial: 6 caras cada una con una combinación de 9 bloques con un máximo de 6 distintos colores.

    *6 matrices de 3x3, cada una con 4 matrices adyacentes donde cada celda es de un color.

-Operadores: Giro de 90° hacia la derecha, izquierda, arriba o abajo.

    *Girar una cara 90°

-Estado objetivo: Cada cara del cubo tiene que tener todos los bloques del mismo color.

    *Todas las celdas de cada matriz deben tener sólo un color.

-Costo de la ruta: Número de movimientos realizados hasta llegar al estado objetivo.

En este caso se corrigió cada uno de los puntos expuestos arriba, de modo que las líneas que comienzan con asteriscos (*) indican la corrección de cada parte de la formulación de este problema. De nuevo, los operadores deben ser lo más específicos posibles pero también se deben minimizar en la medida de lo posible, como fue el caso de este planteamiento.

Analizando el Test de Turing

En el artículo "Computer Machinery and Intelligence" de A.M. Turing se plantea una prueba para validar la inteligencia de una máquina, y también se proponen algunas objeciones potenciales contra la búsqueda de una inteligencia artificial, entre ellas, la objeción que consideramos más relevante es la de Lady Lovelace.

Su argumento ofrece una visión empirista acerca de cómo pueden aprender las máquinas, establece que no podrían generar una inteligencia más allá de lo que sepamos ordenarles, y una vez que se alcance ese grado de investigación acerca del funcionamiento de la misma, traería más complicaciones que las iniciales.

Además, esto provoca que no exista una metacognición de un estado de inteligencia dentro de la máquina, por lo que el desarrollo de una inteligencia artificial siempre se verá limitado a las capacidades humanas y será sujeto a una interpretación de la percepción que se le otorgue de parte de quien este designando como inteligencia a las habilidades de la máquina.

Esto último, también en base a una expectativa humana, que espera resultados más allá de un conjunto de bits pero que al mismo tiempo espera que sólo sea un conjunto de mecanismos sin razonamiento.

Por otra parte, tomando en cuenta los más recientes avances tecnológicos, creemos que seguramente en este tiempo se han desarrollado más argumentos en contra de un desarrollo de la inteligencia artificial, pero al mismo tiempo existen esfuerzos a favor, como el premio Loebner, que se basan en la prueba de Turing, el cual consiste en una competición de carácter anual que concede premios al programa de ordenador que esté considerado como el más inteligentes de los que hayan sido presentados ante el jurado de dicha competencia.

Posiblemente sigan existiendo objeciones como las ya mencionadas por Alan Turing en 1950, y que se hayan generado nuevas objeciones desde ese tiempo y se sigan generando en un futuro. Sin embargo, también se deben de haber generado nuevas respuestas y justificaciones para respaldar el desarrollo de la inteligencia artificial, además de que difícilmente alguna persona no tendría la curiosidad de saber y/o ver a una máquina capaz de superar la prueba de Turing, y por lo tanto tener la inteligencia suficiente como para poder sostener una conversación con una persona o imitar cualquier otro comportamiento de los seres humanos.

El artículo fue escrito en 1950 y en éste Turing predice que para el año 2000 una computadora debería tener un 30% de probabilidades de pasar un Test de Turing de 5 minutos con un interrogador promedio (que no sea muy letrado). Tomando en cuenta que estamos en el 2011, en la era de las comunicaciones instantáneas, opinamos que no era la velocidad ni la memoria lo que hacía falta pues eso sí ha superado las expectativas que se tenían para esa época acerca de las futuras capacidades de una máquina, sino que se han ido descubriendo que se necesitan más cualidades que las anteriores para otorgar una respuesta aceptable dentro de la prueba de imitación de Turing.

A pesar de lo anterior, existen intentos de al menos simular una situación parecida a la propuesta en la prueba de Turing, con muy buenos resultados y muy cercanos a lo que se plantea en la prueba de Turing. Es por ello que creemos que, aunque no existe actualmente una computadora capaz de superar la prueba de Turing, es sólo cuestión de tiempo para que esto ocurra, es decir, algunos años solamente.

Algunos ejemplos de los intentos que mencionamos en el párrafo anterior para lograr simular una situación parecida a la de la propuesta de la prueba de Turing son:

- Dr. Abuse (psicoterapeuta computarizado)(Español)
http://www.psicoactiva.com/abuse/drabuse.htm

- Turinghub (Inglés)
http://www.turinghub.com/

- Jabberwacky (puedes enseñarle y usa emociones indicándoselas)(Inglés)
http://www.jabberwacky.com/

- Igod (simula chat con Dios)(Inglés)
http://www.titane.ca/concordia/dfar251/igod/main.html

- Watson (creada por IBM y concursó en Jeopardy)
http://www-03.ibm.com/innovation/us/watson/

Clase 1

Ejercicio de clase:

¿Qué sabemos acerca de inteligencia artificial y agentes inteligentes?
-Que se refiere a las técnicas usadas para tratar de simular la inteligencia humana.
-Existen algoritmos que se usan en este campo como son las redes neuronales y algoritmos genéticos.
-Es usado en la industria para reconocer patrones y tomar decisiones.
Usan procesos que aprenden y modifican su comportamiento de a cuerdo a su entorno.


¿Qué esperamos de la materia?
-Aprender algoritmos y aplicaciones de la inteligencia artificial.
-Aplicar lo aprendido usando los robots lego del curso.
-Ejemplos de uso de la IA en la vida diaria.
-Saber que son los sistemas multiagentes.

Curso de agentes inteligentes 2011

Curso de agentes inteligentes, ITESO 2011.

Equipo:
Edgard Francisco Caballero Zúñiga
Juan Pablo Garduño Calderón
Karla Maribel Zuloaga Sánchez