Welkom

Welkom op ons Zoeken, sturen en bewegen blog.

Wij zijn Frank Smit en Sander Beerepoot, eerstejaars bachelor kunstmatige intelligentie studenten aan de UvA.

Deze blog hebben wij aangemaakt om het proces te weergeven van ons project.

Conclusie

Vandaag is de laatste dag van het project.
We kunnen concluderen dat we meer bezig zijn geweest met de robotica dan met het AI gedeelte en dat dit goed gelukt is.

• We wilden een programma maken die gegeven een situatie kon bepalen wie er heeft gewonnen (mens of computer), deze moest de situatie doorgeven naar een programma die de bewegingen zou vastleggen.
• We hadden soms problemen met de robot die de kaarten niet helemaal netjes neerlegde dit hebben we kunnen oplossen.

Als we dit project zouden mochten uitbreiden hadden we nog verder gegaan met het rekenen met onzekerheden, waardoor we de robot dmv kansberekening zou kunnen bepalen of hij zou gaan spelen of niet. We zouden dan ook niet alleen een eindsituatie willen doen maar dan natuurlijk het hele spel.

De sourcecode is te vinden op de volgende site:
http://student.science.uva.nl/~fsmit/zsb/

Evaluatie testronde 2

In deze testronde zagen we dat alles ging zoals we dat zouden willen.

• De kaarten werden netjes op een rij gelegd
• De kaarten van de computer (die omgekeerd staan) werden ook netjes neergelegd

Om de kaarten allemaal netjes op een rij te leggen, hebben we dezelfde array gebruikt die we gebruiken voor de coordinaten van de kaarten. Alleen dan gebruikt de robot arm een andere y-waarde, namelijk 10 cm naar voren. We hebben gekozen voor voor de posities, voor kaart 2 tot en met kaart 6.

Door middel van een if..else statement hebben we ervoor gezorgd dat de omgekeerde kaarten met het plaatje omhoog worden neergelegd. Hier hebben we aangegeven dat als het om de eerste of de tweede kaart gaat dat hij bij het neerzetten naar voren gaat inplaats van naar achter.

Hieronder een screenshot van de input:

Testronde nummer 2

Na enige aanpassing in de code konden we vandaag testronde nummer 2 doen.
De volgende dingen wilde wij testen:

• We wilden de computer laten winnen en laten uitvoeren wat hij moet uitvoeren
• In deze testronde moest hij de winnende kaarten open, naast elkaar neerleggen
  

Zoals je aan het einde van het filmpje ziet, legt de robot arm de vijf kaarten van groot naar klein neer. Als hij een pair zou hebben dan pakt hij eerst de kaarten die de pair vormen en legt hij daarna de hoogste kicker ernaast etc.

Evaluatie na testronde 1

Tijdens de testronde kwamen we al snel achter een aantal problemen:

• De kaarten werden niet goed neergelegd, dit hebben we opgelost met een aantal tussenstappen en met een kleine verschuiving waardoor de kaart beter op de tafel valt.
• Onze intentie was om de hoek die de grijper maakt te veranderen zodat de kaarten echt konden worden neergelegd. Echter lukte ons dit niet, en hebben we voor de bovenstaande oplossing gekozen.
• Dat de grijper de kaarten iets te laag vasthield waardoor hij soms iets te laag zat met zijn berekeningen (en de kaart tegen de tafel aan drukte al wilde hij ze neerzetten). Dit hebben we opgelost door de kaart iets hoger te laten pakken.

We hebben er uiteindelijk voor gekozen om voorlopig even geen rekening te houden met de 70% winkans. Het is ons namelijk niet gelukt om hier een programma voor te schrijven die dit uitrekent. Een groot probleem dat voorkwam was het feit dat we niet precies wisten hoe we dit zouden moeten berekenen.

Testronde nummer 1

Vandaag stond het testen van ons programma op de agenda.
De test die we deden was een verliezende partij van de robot arm waarbij hij de kaarten omgekeerd zou wegleggen.

Hieronder is het filmpje te zien van de robot arm die de instructies uitvoert.



Op de video zijn een aantal dingen te zien:

• In de houder hebben we achter de kaarten nog een stuk papier gestopt zodat de kaarten wat rechterop staan. Dit hebben wij gedaan omdat het er 1: beter uitziet (het oog wilt ook wat) en 2: hierdoor zal de arm niet de kaart van de standaard afstoten als hij naar beneden gaat.
• Bij het neerleggen van de kaarten gaat de grijper van de robot arm eerst open, een stukje naar achter en dan pas omhoog. Dit hebben wij op deze manier gedaan omdat op deze manier de kaart omgekeerd valt (dit is dan ook de bedoeling want de robot heeft verloren).
• De kaarten zijn niet zichtbaar voor het publiek, dit is voor de show.
  

Pokergame.java

Vandaag een nieuwe klasse Pokergame.java geschreven. Deze klasse zorgt er nu voor dat aan de gebruiker de input wordt gevraagd en dat alles wordt verwerkt (dus dat de hand wordt bepaalt en er wordt bepaalt wie er heeft gewonnen).

We hebben er voor gekozen om de kaarten van de computer zelf op te geven inplaats van ze random te laten bepalen. Dit omdat

• het anders ontzettend lang kan duren voordat de computer een keer gewonnen heeft, dus het is niet praktisch om te demonstreren
• en aangezien we de kaarten zelf willen schudden geven wij de computer ook 2 kaarten. Daarom is het een beter idee om zelf de kaarten in te voeren.

Pokergame.java zorgt er voor dat er aan de robot klasse wordt doorgegeven welke kaarten hij moet pakken (als hij gewonnen heeft). Dit doen we door middel van een array (zoals dit in java zo mooi heet), het voordeel van het gebruik van een array in dit geval is dat de array langzaam kan worden afgelopen en de kaarten 1 voor 1 kunnen worden gepakt.

Afmetingen en het plan

De afmetingen van de kaart zijn gemeten.
De kaart is

• 87 mm hoog

• 56 mm breed

De standaard zelf is 385 mm breed
De kaarten passen net op de standaard met de laatste kaart die er een beetje naast hangt omdat
385 / 7 = 55 , dus elke kaart zou anders 1 mm moeten inleveren.

Hieronder een afbeelding van de standaard met de kaarten:















We plaatsen de standaard op punt 0,200 in cartesische coordinaten
De arm pakt elke kaart op X = 28+56*kaartnummer , de kaartnummer is de nummer uit de array en die start met positie 0 dus kaart 1 wordt op 28 gepakt , dus netjes in het midden. De y waarden kunnen wij vast zetten door dat we de standaard paralel aan de as zetten en de kaarten ook paralel spelen. De kaarten worden 10 centimeter naar voren geplaatst vanaf hun X postie naar de y waarde van 300 Het nummer van de kaarten worden doorgegeven en zo weet het programma welke kaarten deze moet pakken aan de hand van de andere array met be bijbehorende X coordinaten.

Hand evaluator

Met de hand evaluator die we hebben gebruikt van http://spaz.ca/poker/ (University of Alberta Hand Evaluator) is het mogelijk om twee handen met elkaar te vergelijken en daar een winnaar uit te bepalen.

Met een aantal kleine aanpassing is dit al te doen.
Aanpassing zijn:

• Vraag aan de gebruiker de input van 5 kaarten (flop turn river).
  
• Openstaande vraag: hoe bepalen we de 2 kaarten van de computer? Selecteren we random 2 kaarten of is dit een gegeven?
  
• Vraag de kaarten van de gebruiker
• Bepaal de 5 beste kaarten van beide
• Bepaal de waarde die elke hand heeft
• Bepaal een winnaar aan de hand van die waardens
  

Idee Project

Na enig onderzoek zijn wij aan het stuk: using probabilistic knowledge and simulation to play poker (https://www.aaai.org/Papers/AAAI/1999/AAAI99-099.pdf). In deze paper wordt beschreven hoe een poker-programma, genaamd Loki, in elkaar zit. Na enig onderzoek blijkt dit programma commercieel geworden en kunnen wij er geen gebruik van maken. Daarom hebben wij besloten om een deel van dit programma (de hand evaluator) te verwerken in ons eigen programma, en zelf iets te bedenken.

Het idee is dat wij de robot een eindsituatie van poker laten analyseren en dan besluit of hij gaat spelen of niet. De robot krijgt de informatie van zijn eigen 2 kaarten en de 5 die open liggen.

De belangrijke punten hierbij zijn:

Poker:

• gegeven situatie
• kansberekening voor hand/kaarten
• 70% winkans is ons doel om te spelen op het moment
• wanneer dit bereikt is pakt de robot de kaarten en legt ze neer
  

Robot:

• kaarten staan op een vaste locatie
• gebruik van cartesische coordinaten
• bewegingen op vergelijkbare wijze als schaken
• kaarten recht op naar ons toe geplaatst
• posities om kaarten neer te leggen ook op vaste locatie in cartesische coordinaten

Ready, Start .... Go!!

Vandaag is het dan zo ver, go where no one has gone before. Onze gedachte om poker aan de kaart te brengen is goedgekeurd en het project gaat van start!