Hoe kan ik een “ 20 vragen ” algoritme implementeren?

Ik weet niet hoe 20Q het specifiek deed, maar er is veel informatie over hoe je een game van 20 vragen .

Er zijn veel manieren om dit op te lossen, maar ik zal één manier beschrijvenDeze spellen kunnen een soort beslissingsboom implementeren. Voor een elektronisch spel als 20Q zou deze boom vooraf berekend zijn en redelijk gemakkelijk te doorkruisen. Er zijn methoden om leerbeslissingsbomen te gebruiken waarbij het spel nieuwe objecten aan het einde van de vragen kan accepteren als het niet kan raden wat de gebruiker is vragen.

Als de vragen een reeks ja of nee antwoorden zijn, krijg je een binaire boomstructuur. Elk knooppunt is een vraag en de bladeren zijn antwoorden. Wanneer vragen worden beantwoord met onbekend of niet zeker, kunnen de onderliggende knooppunten worden gecombineerd en hun vragen in serie worden gesteld om de mogelijke antwoorden verder uit te zoeken.

In wezen is dit het proces:

1. Begin met een volledige lijst van de objecten. Deze kunnen allemaal even waarschijnlijk beginnen, of ze kunnen worden gesorteerd op hoe waarschijnlijk het was dat het object tijdens het testen werd gekozen.
2. Begin met de eerste vraag in de beslissingsboom. Duw het naar de vragenwachtrij.
3. Stel de vraag bovenaan de wachtrij.
4. Verwerk antwoord:
   1. Ja / Nee antwoorden verwijdert / voegt een vooraf bepaald aantal waarschijnlijkheid van elk antwoord op basis van de vraag.
   2. “Misschien” antwoord verwijdert / voegt een fractie toe van het vooraf bepaalde aantal “ja”.
   3. “Onbekend” verandert niets aan waarschijnlijkheden
5. Een “Onbekend” of “Misschien” antwoord duwt beide volgende knooppunten vragen in de vragenwachtrij. Een Ja of Nee antwoord voegt gewoon het ene respectievelijke ja / nee-knooppunt toe aan de vragenwachtrij.
6. Ga naar stap 3 totdat geen vragen meer zijn of de kans op een enkel antwoord groter is dan een vooraf gedefinieerde zekerheid ” drempel.
7. Geef het meest waarschijnlijke antwoord.

Het genereren van de stamboom is waarschijnlijk het onderwerp van een andere vraag. Maar in feite zijn het het kiezen van vragen die de antwoorden zoveel mogelijk splitsen. Zet de vragen die de vragen het meest gelijk verdelen aan het begin, zodat het grootste aantal vragen het snelst kan worden beantwoord.

Het simpele antwoord is dat het handheld-spel 20Q is gemaakt op basis van de kunstmatige intelligentie die leeft op http://20Q.net . Bij 20Q.net kun je verschillende versies van het spel Twenty Questions spelen, vergelijkbaar met het speelgoed, behalve dat het spel leert van elk spel dat wordt gespeeld. Het draagbare speelgoed gebruikt de dezelfde neurale netwerkalgoritmen. Het neurale netwerk kiest de vragen die moeten worden gesteld en doet ook gissingen. Deze benadering betekent dat de AI vaak correct raadt, zelfs als je een vraag anders beantwoordt dan de AI is geleerd. Een ander voordeel is dat het spel zal elke game anders vragen stellen, zelfs als je aan hetzelfde denkt.

De algoritmen en het neurale netwerk van het klassieke Engelse spel (Animal, Vegetable, Mineral) werd in 1988 gecreëerd door Robin Burgener.me.

Bedankt voor het vragen.

Reacties

• Hallo Robin, welkom op de site. Wie kan deze vraag beter beantwoorden dan de uitvinder zelf. Het ‘ is interessant om te weten hoe complex de 20Q eigenlijk is. Bedankt voor je bijdrage aan de site en meer nog voor je bijdrage aan kunstmatige intelligentie. Hopelijk bezoekt u ‘ de site af en toe en antwoordt u A.I. vragen :).
• hehe, hou ervan als dit gebeurt xD.

Ik googlede “20q code” en vond dit: http://mosaic.cnfolio.com/B142LCW2008A197

Deze versie is alleen voor dieren, maar de werkelijke 20 vragen hebben waarschijnlijk een soortgelijk algoritme.

Hier is een snel overzicht van de code die ik heb gelinkt:
Er zijn verschillende antwoorden die hard in het programma zijn gecodeerd.Er worden dan verschillende TRUE of FALSE attributen aan toegewezen:

#define ANIMALS_LIST "daddylonglegs bee penguin eagle giraffe octopus tiger elephant jellyfish bull \nparrot dolphin python crocodile cat leopard monkey zebra sheep rat \nowl spider frog polarbear snail tortoise rabbit salmon rhino fox" #define MAMMALS "0 0 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 1 1 1 0 0 0 1 0 0 1 0 1 1" #define FLYING_ANIMALS "1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0" #define WATER_ANIMALS "0 0 1 0 0 1 0 0 1 0 0 1 0 1 0 0 0 0 0 0 0 0 1 1 0 1 0 1 1 0" #define BEAK "0 0 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0" ... 

Zoals je kunt zien is een bij geen zoogdier, maar hij vliegt wel, enz.

Er is een array voor elke groep:

int mammals[ TOTAL_ANIMALS ] = { 0 }; int flying_animals[ TOTAL_ANIMALS ] = { 0 }; int water_animals[ TOTAL_ANIMALS ] = { 0 }; ... 

Wanneer elke vraag wordt gesteld:

 askUserQuestion( guesses, "\nQuestion %d: Is your animal a mammal? \n", mammals ); 

Het programma kijkt naar de definitie van de juiste categorie en volgt welk dier het meest waarschijnlijk is waaraan u denkt op basis van de WAAR of ONWAAR waarden en uw ingevoerde Ja of Nee antwoord op de vraag.

Dit wordt gedaan in:

void askUserQuestion( int guessNumber, char* question, int* animalData ); 

Het is geen enorme beslissingsboom of een hoop hardgecodeerde if / else-uitspraken. Robin Burgener, de uitvinder, heeft zijn algoritme volledig gedocumenteerd in zijn patentaanvraag in 2005. “is ingenieus eenvoudig.

Opmerkingen

• In plaats van naar de andere antwoorden te porren, wilt u misschien een korte beschrijving van het algoritme geven in plaats van alleeneen link ernaartoe plaatsen.
• voor het geval je de andere antwoorden gemist hebt, hij heeft hierboven gereageerd! misschien kan @ user22025 hier ook een korte uitleg geven: D