Transcript Robotica

AI
Kunstmatige Intelligentie (AI)
Hoofdstuk 25 van Russell/Norvig = [RN]
Robotica
voorjaar 2014
College 8, 8 april 2014
www.liacs.nl/home/kosters/AI/
1
AI—Robotica
Robots
Een robot is een “actieve, kunstmatige agent wiens omgeving de fysieke wereld” is. Het woord stamt uit 1921 (of
eerder), en is gemaakt door de Tsjechische broers Capek.
En softbots: RoboCom, internet programma’s.
Van de science fiction schrijver Isaac Asimov (auteur van
“I, Robot”) zijn de drie (later vier) wetten van de robotica:
1. Een robot mag een mens
geen kwaad doen.
2. Een robot moet menselijke
orders gehoorzamen (tenzij
dat tegen 1. ingaat).
3. Een robot moet zichzelf beschermen (tenzij dat tegen
2
1. of 2. ingaat).
AI—Robotica
Robot-simulatie
Een leuke robotsimulatie, van Michael Genesereth en Nils
Nilsson, is de volgende.
Bedenk een taak, bijvoorbeeld een toren maken van een
paar gekleurde blokken. Stel je nu een “robot” voor die uit
vier mensen bestaat:
Brein krijgt input van Ogen, maar kan zelf niet zien; geeft
opdrachten aan Handen; maakt plannen
Ogen weet niet wat het doel is
Handen, Links en Rechts voeren simpele opdrachten uit;
ze zijn geblinddoekt
3
AI—Robotica
Mobiele robots
Curiosity
Sony Aibo
Hiroshi Ishiguro’s
robot (en hijzelf)
Honda ASIMO
4
AI—Robotica
Begrippen
Enkele begrippen uit de robot-wereld zijn:
statisch stabiel stabiel zonder te bewegen
dynamisch stabiel robot verongelukt bij gedwongen rust
holonome robot totaal aantal vrijheidsgraden (onafhankelijke richtingen waarin robot of zijn “effectors” kunnen bewegen) = aantal controleerbare vrijheidsgraden
Voorbeeld niet-holonoom: auto (effectief 3: x, y, θ resp.
2: vooruit/achteruit, draaien); erger: met aanhanger
configuratie-ruimte bestaande uit bijvoorbeeld 6 hoeken
voor een robot-arm
5
AI—Robotica
Stanford manipulator
De Stanford manipulator ziet er als volgt uit:
P
R
R
R
R
R
P: prismatic joint; R: revolute joint
De configuratie van de robot wordt gespecificeerd door 6
getallen: dus 6 vrijheidsgraden (“degrees of freedom” =
DOFs).
De arm van de mens heeft > 6 vrijheidsgraden (plaats hand
op tafel en beweeg elleboog).
6
AI—Robotica
Online-algoritme
Een robot moet —in een 2-dimensionale wereld— van begin naar doel, weet precies waar hij is (GPS), en heeft een
tastsensor. Een online-algoritme voor zo’n robot is:
1. Bereken de rechte lijn ℓ van begin naar doel, en begin
langs ℓ richting doel te bewegen.
2. Als je botst: onthoud positie Q. Wandel met de klok
mee om het obstakel heen, terug naar Q. Detecteer
onderweg waar je ℓ kruist, en onthoud welk punt P het
dichtst bij het doel is.
3. Loop van Q naar P (met de klok mee of er tegenin, wat
het kortste is), en ga via 2. zo verder.
7
AI—Robotica
Online-algoritme — Analyse
Dit algoritme heeft een “competitive ratio” van ten hoogste 1 + 1.5B/|ℓ| (|ℓ|: afstand van begin naar doel via ℓ; B:
som van lengtes van randen van obstakels), de slechtst
mogelijke verhouding tussen gevonden en kortste route.
Bewijs: de verhouding gevonden staat tot kortste is hooguit
|ℓ| + 1.5B
= 1 + 1.5B/|ℓ|,
|ℓ|
en je kunt die grens bereiken: leg een rafelig smal object
met omtrek B op (en in de richting van) ℓ; de kortste weg
heeft dan lengte ≈ |ℓ|.
8
AI—Robotica
Subsumption architectuur
De subsumption architectuur is een idee van Rodney Brooks
van MIT uit 1986, zie zijn artikel (via de AI-website).
Een robot bestaat hier uit verschillende finite state machines met klokken. Deze worden netjes gesynchroniseerd en
gecombineerd. Zo vermijd je problemen met gigantische
configuratieruimtes.
Het werkt goed voor ´
e´
en kleine taak, maar wat er gebeurt is soms lastig te snappen. Zie je hiervan iets terug
bij Lego/RoboCom?
9
AI—Robotica
Twee voorbeelden
• hardware: Lego
• software: RoboCom
10
AI—Robotica
Lego-robots Ξ
Heel vroeger gebruikten we Lego voor de tweede opgave.
Een simpel programma voor een Lego-robot is:
task main ( ) {
while ( true ) {
OnFwd (OUT_A + OUT_C);
Wait (Random (100) + 40);
OnRev (OUT_A);
Wait (Random (85) + 30);
}
}
Dit laat de robot schijnbaar willekeurig rondlopen. En dat
ziet er al heel intelligent uit!
11
AI—Robotica
Lego — NQC Ξ
Je kunt Lego-robots programmeren in Dave Baum’s NQC
(Not Quite C) met behulp van Mark Overmars’ RCX Command Center, zie handleidingen op de websites.
#define MOVE_TIME 100
#define TURN_TIME 85
task main ( ) {
while ( true ) {
OnFwd (OUT_A + OUT_C); //
Wait (Random (MOVE_TIME) +
OnRev (OUT_A);
//
Wait (Random (TURN_TIME) +
}//while
}//main
motoren op A en B aan
40);
en die op A achteruit
30);
Nadelen: maximaal 32 (integer) variabelen, maximaal 10
“parallelle” tasks, alleen eenvoudige functies: subroutines
(sub), online functies (void) en macro’s (#define).
12
AI—Robotica
Lego — Hard- en software Ξ
13
AI—Robotica
Lego — Sensoren Ξ
Er zijn tastsensoren en lichtsensoren, met 3 aansluitpunten:
task main ( ) {
SetSensor (SENSOR_1,SENSOR_TOUCH);
SetSensor (SENSOR_2,SENSOR_LIGHT);
SetSensor (SENSOR_3,SENSOR_TOUCH);
OnFwd (OUT_A + OUT_C);
while ( true ) {
if ( SENSOR_1 == 1 ) ...
else if ( SENSOR_2 > 40 ) ...
}//while
}//main
// 0 of 1
// 0..100
Er kunnen ook meerdere sensoren op ´
e´
en input worden
gezet, en ze kunnen preciezer (“raw”) worden uitgelezen.
14
AI—Robotica
Lego — Parallelle tasks Ξ
task main ( ) {
SetSensor (SENSOR_1,SENSOR_TOUCH);
start check_sensors;
while ( true ) {
OnFwd (OUT_A + OUT_C); Wait (100);
OnRev (OUT_C); Wait (85);
}//while
}//main
task check_sensors ( ) {
while ( true ) {
if ( SENSOR_1 == 1 ) {
OnRev (OUT_A + OUT_C); Wait (50);
OnFwd (OUT_A); Wait (85); OnFwd (OUT_C);
}//if
}//while
}//check_sensors
Deze acties interfereren! Oplossing: of stop of semaforen:
until ( sem == 0 ); sem = 1; /*motoractie*/ sem = 0;
15
AI—Robotica
Lego — Proximity sensor Ξ
int level;
task geefsignaal ( ) {
while ( true ) { SendMessage (0); Wait (10); }//while
}//geefsignaal
task checksignaal ( ) {
while ( true ) {
level = SENSOR_2;
if ( SENSOR_2 > level + 200 ) { // snelle fluctuatie
OnRev (OUT_C); Wait (85); OnFwd (OUT_A+OUT_C);
}//if
}//while
}//checksignaal
task main ( ) {
SetSensor (SENSOR_2,SENSOR_TYPE_LIGHT);
SetSensorMode (SENSOR_2,SENSOR_MODE_RAW); // 0..1023
OnFwd (OUT_A+OUT_C);
start geefsignaal;
start checksignaal;
}//main
In werkelijkheid zit de “ruwe” waarde tussen 300 (licht) en
800 (donker).
16
AI—Robotica
RoboCom — vroeger Ξ
Er zijn allerlei robot-simulaties.
We gebruikten ooit RoboCom, een opvolger van “CoreWar”, van Dennis Bemmann: kleine robot-programma’s
vechten in een vierkant stuk computergeheugen met 20×20
vakjes (= velden). Zie ook: “Robocode”.
Software (RoboCom Workshop 3.1),
voor Windows XP(?) en Linux:
http://robocom.rrobek.de/
Er is nog meer: uitgebreide instructieset, multitasking.
17
AI—Robotica
RoboCom — Software Ξ
18
AI—Robotica
RoboCom — Robots Ξ
Een robot is een klein assembler-achtig programma dat in
´
e´
en van de 20 × 20 velden van het “speelveld” zit. Dit veld
is een “torus”: links grenst aan rechts, boven aan beneden.
Een robot ziet ´
e´
en veld in de “kijkrichting”: het reference
field. Een robot kan nieuwe bewegende robots maken.
Er zijn drie instruction sets: basic (0; met ADD, BJUMP, COMP,
DIE, JUMP, MOVE, SET, SUB en TURN), advanced (1; met SCAN
en TRANS erbij) en super (2; met ook nog CREATE erbij).
Een robot heeft interne integer prive-variabelen #1, #2, . . . ,
#20. De variabele #Active geeft aan of de robot actief is
(waarde ≥ 1) of niet. En de constante $Mobile (0/1) is de
mobiliteit, $Banks het aantal “banken” — zie verderop.
19
AI—Robotica
RoboCom — Banken Ξ
Een robot-programma is opgedeeld in maximaal 50 banken
(≈ functies). Executie begint bij de eerste. Als je een bank
uitloopt begin je weer bij de eerste bank: “auto-reboot”.
Voorbeeldprogramma, met ´
e´
en bank:
; voorbeeldprogramma, een ";" duidt op commentaar
NAME DoetNietVeel
BANK Hoofdprogramma
SET #3,7
;
@EenLabel
;
ADD #3,1
;
TURN 1
;
JUMP @EenLabel ;
variabele 3 wordt 7
definieer een label
hoog variabele 3 met 1 op
draai 90 graden rechtsom (0: linksom)
spring terug naar label
20
AI—Robotica
ADD #a,b
BJUMP a,b
COMP a,b
CREATE a,b,c
DIE
JUMP a
MOVE
SCAN #a
SET #a,b
SUB #a,b
TRANS a,b
TURN a
RoboCom — Instructies Ξ
tel b bij #a op
spring naar instructie b van bank a
sla volgende instructie over als a = b
maak in reference field nieuwe robot met
instruction set a, b banken en mobiliteit c
robot gaat dood
spring a verder (naar label @Iets mag ook)
ga naar reference field
bekijk reference field; #a wordt 0 (leeg),
1 (vijandige robot) of 2 (bevriende robot)
#a krijgt waarde van b
trek b van #a af
kopieer eigen bank a naar de b-de bank
van robot in reference field
draai linksom als a = 0, anders rechtsom
Hierbij: #a: variabele; a, b, c: elke type.
21
AI—Robotica
RoboCom — Diversen Ξ
Instructies kosten tijd, de ene meer dan de andere.
Van de eventuele robot op het reference field kun je de activiteit benaderen (en wijzigen!) via de “remote” %Active.
Als na een “auto-reboot” de eerste bank leeg blijkt, gaat
de robot dood van “data-honger”.
De beginrobot staat altijd stil (mobiliteit 0).
Er zijn allerlei speciale gevallen, nog meer instructies . . .
22
AI—Robotica
RoboCom — Opgave Ξ
Een oude tweede opgave was het maken van een aantal
(on)vriendelijke robot-programma’s en deze met elkaar en
met bestaande robots vergelijken:
cooperatief Twee klonen X en Y van een en dezelfde robot
vormen samen een figuur als
X Y X Y X Y
met “in te stellen” aantal herhalingen van X Y.
competitief En een “vijandige” robot die zichzelf en de
rest van de wereld bestrijdt.
23
AI—Robotica
RoboCom — Voorbeeld Ξ
; een klein robot-programma
NAME Mine
BANK Mine
@Loop
TURN 1
SCAN #1
COMP #1,1
JUMP @Loop
SET %Active,0
TRANS 2,1
SET %Active,1
; auto-reboot
;
;
;
;
;
;
;
;
;
eerste bank
label
draai rechtsom
scan reference field
een tegenstander?
nee, verder draaien
ja, deactiveer tegenstander (eerder?)
en kopieer narigheid
re-activeer
BANK Poison
DIE
; tweede bank: narigheid
; vergif
24
AI—Robotica
RoboCom — Nog een voorbeeld Ξ
; nog een klein robot-programma
NAME Flooder/Shielder
BANK Flood
@Loop
TURN 0
SCAN #5
COMP #5,0
JUMP @Loop
CREATE 2,1,0
TRANS 1,1
SET %Active,1
; auto-reboot
;
;
;
;
;
;
;
;
;
eerste bank
label
draai linksom
scan reference field
leeg?
nee, verder draaien
ja; creeer nieuwe robot
en kopieer jezelf
activeer hem/haar
25
AI—Robotica
Huiswerk
Het huiswerk voor de volgende keer (dinsdag 15 april 2014):
lees Hoofdstuk 18, 19.1 en 21.1/3, p. 693–758, p. 768–
776 (en p. 830–845) van [RN] over Leren eens door. Kijk
naar de vragen bij dit hoofdstuk.
Lees eens wat over RoboCup: voetbalwedstrijden voor robots, zie www.robocup.org
Denk na over de derde programmeeropgave: Tablut; ga
naar de werkcolleges. Deadline: 22 april 2014. Werkcollege
op 8 april: www.liacs.nl/home/kosters/AI/opgaven1.pdf
NB: Ξ betekent “geen tentamenstof”.
26