Comment puis-je implémenter un algorithme «20 questions»?

Depuis mon enfance, je me suis demandé comment fonctionnait le jeu électronique 20Q . Vous pensez à un objet, une chose ou un animal (par exemple, pomme de terre ou âne ). L'appareil vous pose ensuite une série de questions telles que:

• Est-ce plus gros qu'une miche de pain?
• Le trouve-t-on à l'extérieur?
• Est-il utilisé pour les loisirs?

Pour chaque question, vous pouvez répondre oui , non , peut - être ou inconnu . J'ai toujours imaginé qu'il fonctionnait avec d'immenses conditionnelles ( if-instructions) imbriquées. Cependant, je pense que c'est une explication peu probable en raison de sa complexité pour le programmeur.

Comment pourrais-je implémenter un tel système?

Je ne sais pas comment 20Q l'a fait spécifiquement, mais il y a beaucoup d'informations sur la façon de mettre en œuvre un jeu de 20 questions .

Il existe de nombreuses façons de résoudre ce problème, mais je vais décrire une façon. Ces jeux peuvent implémenter une sorte d' arbre de décision . Pour un jeu électronique comme 20Q, cet arbre serait précalculé et assez facile à parcourir. Il existe des méthodes d'utilisation des arbres de décision d'apprentissage où le jeu peut accepter de nouveaux objets à la fin de ses questions s'il est incapable de deviner ce que l'utilisateur demande.

Lorsque les questions sont une série de réponses oui ou non, vous vous retrouvez avec un arbre binaire. Chaque nœud est une question et les feuilles sont des réponses. Lorsque les réponses aux questions sont inconnues ou incertaines, les nœuds enfants peuvent être combinés et leurs questions posées en série pour mieux sélectionner les réponses possibles.

Fondamentalement, c'est le processus:

1. Commencez par une liste complète des objets. Ceux-ci peuvent tous commencer à une probabilité égale, ou ils peuvent être triés selon la probabilité que l'objet soit choisi lors du test.
2. Commencez par la première question de l'arbre de décision. Poussez-le dans la file d'attente des questions.
3. Posez la question en haut de la file d'attente.
4. Réponse du processus:
   1. Les réponses Oui / Non suppriment / ajoutent une quantité prédéterminée de probabilité de chaque réponse en fonction de la question.
   2. La réponse "Peut-être" supprime / ajoute une fraction de la quantité prédéterminée d'un "oui".
   3. "Inconnu" ne change pas les probabilités
5. Une réponse «inconnu» ou «peut-être» pousse les deux questions des nœuds suivants dans la file d'attente de questions. Une réponse "Oui" ou "Non" ajoute simplement le nœud oui / non respectif à la file d'attente de questions.
6. Passez à l'étape 3 jusqu'à ce qu'il n'y ait plus de questions ou que la probabilité d'une réponse unique dépasse le seuil de «certitude» prédéfini.
7. Fournissez la réponse la plus probable.

La génération de l'arbre est probablement le sujet d'une autre question. Mais en gros, c'est choisir des questions qui divisent les réponses autant que possible. Posez les questions qui divisent les questions le plus équitablement vers le début afin que le plus grand nombre de questions puisse être éliminé le plus rapidement.

La réponse est simple: le jeu portable 20Q a été créé à partir de l'intelligence artificielle qui se trouve sur http://20Q.net . Sur 20Q.net, vous pouvez jouer à différentes versions du jeu de vingt questions, similaires au jouet, sauf que le jeu apprend de chaque jeu joué. Le jouet portable utilise les mêmes algorithmes de réseau neuronal. Le réseau de neurones sélectionne les questions à poser ainsi que des suppositions. Cette approche signifie que l'IA devinera souvent correctement même si vous répondez à une question différemment de ce que l'IA a appris. Un autre avantage est que le jeu posera des questions différemment à chaque jeu même si vous pensez à la même chose.

Les algorithmes et le réseau neuronal du jeu anglais classique (Animal, Vegetable, Mineral) ont été créés en 1988 par Robin Burgener. . . moi.

Merci d'avoir posé la question.

J'ai googlé "code 20q" et trouvé ceci: http://mosaic.cnfolio.com/B142LCW2008A197

Cette version est uniquement pour les animaux, mais les 20 questions actuelles ont probablement un algorithme similaire.

Voici un aperçu rapide du code que j'ai lié:
Il existe plusieurs réponses codées en dur dans le programme. Plusieurs attributs TRUE ou FALSE leur sont alors attribués:

#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"
...

Comme vous pouvez le voir, une abeille n'est pas un mammifère mais elle vole, etc.

Il y a un tableau pour chaque groupe:

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

Lorsque chaque question est posée:

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

Le programme examine la définition de la catégorie appropriée et suit quel animal est probablement celui auquel vous pensez en fonction des valeurs VRAI ou FAUX et de votre réponse Oui ou Non à la question.

Cela se fait en:

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

Ce n'est pas un arbre de décision massif ou un tas d'instructions if / else codées en dur. Robin Burgener, l'inventeur, a complètement documenté son algorithme dans son dépôt de brevet en 2005. C'est ingénieusement simple.