Exercice du lundi 27 avril 2015, par Gyncoca.

Énoncé

Bonjour,

Vous connaissez peut être Akinator ? Eh bien, c'est ce que vous allez créer aujourd'hui !

Le principe est le suivant : l'ordinateur vous demande de penser à un animal, il vous pose des question, vous répondez par oui ou non et à la fin il devine l'animal. S'l devine l'animal c'est bon et il est trop fort, sinon le programme vous demande de donner une question qui permet de spécifier l'animal. Il ajoute alors l'animal dans sa mémoire ainsi que la question que la personne ajoute.

Plus vous jouez, plus il apprend, plus il apprend, plus il devient efficace.

Donc aujourd'hui on crée un programme qui apprend tout seul !

Entrée

Affiche un message de bienvenue puis ensuite les questions. Il faut pouvoir répondre par oui ou non.

Sortie

On affiche le texte qui demande de penser à un animal et de cliquer quand on est prêt.

Si l'ordinateur trouve le bon animal alors il affiche un message de succès sinon il demande d'entrer le nom de l'animal et d'ajouter une question pour laquelle on pourra répondre "Oui". L'ordinateur met à jour la base de données. Vous apprenez à votre programme.

Pour le design vous faites ce que vous voulez et pour le stockage des données aussi.

Intelligence Artificielle

L’ordinateur doit apprendre, à chaque partie vous devez charger les résultats de toutes les ancienne parties.

Premier exemple

Bienvenue, merci de penser à un animal.

L'animal est un mammifère ? oui
L'animal vit dans l'eau ? oui
L'animal est gris ? oui

Je pense que l'animal est une baleine grise, j'ai raison ? non

Oh mince. Aide-moi à apprendre.
Quel est le nom de l'animal ? dauphin
Quelle question unique me permet de répondre oui pour le dauphin ? Est-ce que l'animal est très intelligent

Merci de m'avoir éclairé de votre savoir, ô grand maître de la connaissance.

Second exemple

Bienvenue, merci de penser à un animal.

L'animal est un mamifere ? oui
L'animal vit dans l'eau ? non
L'animal est gris ? oui

L'animal est un éléphant ? oui

Je suis trop intelligent, tu peux pas test, noob !

Voilà !

Travaux réalisés

Aucun pour l'instant.

Le plus pif des pifs
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

#define BRAINS_FILE "brains.db"
#define MEM_FILE "memories.db"

static long get_file_size(FILE *fp) {
  long cur, end;
  cur = ftell(fp);
  fseek(fp, 0, SEEK_END);
  end = ftell(fp);
  fseek(fp, cur, SEEK_SET);
  return end;
}

static char *get_file_contents(const char *path, long *total_len) {
  int ret;
  FILE *fp = NULL;
  long size;
  void *data = NULL;
  fp = fopen(path, "rb");
  if(!fp)
    goto failed;
  size = get_file_size(fp);
  if(size < 0)
    goto failed;
  if(!size) {
    if(total_len)
      *total_len = 0;
    fclose(fp);
    return NULL;
  }
  data = malloc(size);
  if(!data)
    goto failed;
  ret = fread(data, size, 1, fp);
  if(ret != 1)
    goto failed;
  *tota_len = size;
  fclose(fp);
  return data;

  failed:
    if(fp)
      fclose(fp);
    if(total_len)
      *total_len = -1;
    if(data)
      free(data);
    return NULL;
}

static int set_file_contents(const char *path, const char *contents, long total_len) {
  
}

static int load_brains(void) {
  char *raw_data;
  unsigned int raw_data_len;
  uint32_t nb_entries;
  raw_data = get_file_contents(BRAINS_FILE, &raw_data_len);
  if(!raw_data)
    return -1;
  nb_entries = *(uint32_t *)raw_data;
  raw_data += sizeof(uint32_t);
  for(unsigned int i = 0; i < nb_entries; i++) {
    unsigned int keyword_len;
    char *keyword;
    unsigned int *idx_list;
    keyword_len = *(uint32_t *)raw_data;
    raw_data += sizeof(uint32_t);
    keyword = malloc(keyword_len + 1);
    if(!keyword)
      return -1;
    memcpy(keyword, raw_data, keyword_len);
    keyword[keyword_len] = '\0';
    
  }
}

static int load_memories(void) {
  char *raw_data;
  raw_data = get_file_contents(MEM_FILE);
  if(!raw_data)
    return -1;
}

int main()
{
  
}
Booti's booting...
import Data.Char (toLower)
import Data.Binary
import System.Directory (doesFileExist)


data Tree a = Empty | Node a (Tree a) (Tree a)


instance (Binary a) => Binary (Tree a) where
	put x = case x of
		Empty -> put (0 :: Word8)
		Node x l r -> do
			put (1 :: Word8)
			put x
			put l
			put r

	get = do
		t <- get :: Get Word8
		case t of
			0 -> return Empty
			1 -> do
				x <- get
				l <- get
				r <- get
				return (Node x l r)


goLeft :: Tree a -> Tree a
goLeft (Node _ l _) = l


goRight :: Tree a -> Tree a
goRight (Node _ _ r) = r


fileSave = "save.dat"


initialQuestions :: Tree String
initialQuestions =
	Node "Animal gris ?"
		(Node "Nage ?"
			(Node "Baleine" Empty Empty)
			(Node "Rat" Empty Empty)
		)
		(Node "Vol ?"
			(Node "Colibri" Empty Empty)
			(Node "Cochon" Empty Empty)
		)


getAnimalName :: Tree String -> String
getAnimalName (Node name _ _) = name


askQuestions :: Tree String -> IO (Tree String)
askQuestions q@(Node name Empty Empty) = return q
askQuestions q@(Node name l r) = do
	putStrLn name
	input <- getLine
	case map toLower input of
		"oui" -> do askQuestions $ goLeft q
		"non" -> do askQuestions $ goRight q
		_     -> do
			putStrLn "Il faut répondre par oui ou par non."
			askQuestions q


correctAnimal :: IO Bool
correctAnimal = do
	input <- getLine
	case map toLower input of
		"oui" -> return True
		"non" -> return False
		_     -> do
			putStrLn "Il faut répondre par oui ou par non."
			correctAnimal


askAnimalName :: IO String
askAnimalName = do
	putStrLn "Oh mince. Aide-moi à apprendre."
	putStrLn "Quel est le nom de l'animal ?"
	getLine


askAnimalQuestion :: String -> IO String
askAnimalQuestion name = do
	putStr "Quelle question unique me permet de répondre oui pour \""
	putStr name
	putStrLn "\" ?"
	getLine


getQuestions :: IO (Tree String)
getQuestions = do
	fileSaveExists <- doesFileExist fileSave
	if fileSaveExists then
		encodeFile fileSave initialQuestions :: IO (Tree String)
	decodeFile fileSave :: IO (Tree String)


main :: IO ()
main = do
	questions <- getQuestions
	animal <- askQuestions questions
	putStr "Je pense à \""
	putStr $ getAnimalName animal
	putStrLn "\", ai-je raison ?"
	correct <- correctAnimal
	if correct then do
		putStrLn "Je suis trop intelligent, tu peux pas test, noob !"
	else do
		animalName <- askAnimalName
		animalQuestion <- askAnimalQuestion animalName
		putStrLn "Merci de m'avoir éclairé de votre savoir, ô grand maître de la connaissance."
Le plus pif des pifs

Le code est plutot dégueu (particulièrement la partie sérialisation ^^) mais ça fonctionne à merveille :)

NB : il faut que vous ayez un fichier nommé "cerveau" pour qu'il enregistre/lise les questions :)

type abq = Question of (string * abq * abq)
		 | Final of string;;

(*let rec go_to_oparen f =
	match input_char f wit*)

let rec read_in_quote f =
	match input_char f with
	| '"' -> ""
	| c -> (String.make 1 c)^(read_in_quote f) ;;

let rec abq_of_file f = 
	let qf = input_char f in
	let blk = input_char f in
	if qf = 'Q' then (
		let q = read_in_quote f in
		let ay = abq_of_file f in
		let an = abq_of_file f in
		Question (q,ay,an)
	) else Final (read_in_quote f);;

let rec string_of_abq abq =
	match abq with 
	| Final q -> ("F\""^q^"\"")
	| Question (q, y, n) -> ("Q\""^q^"\""^(string_of_abq y)^(string_of_abq n));;

let get_q abq = 
	match abq with
	| Question (q,_,_) -> q
	| Final q -> q;;

let ask q =
	let () = print_string q in
	read_line ()

let rec askqyn abq =
	let qst = get_q abq in
	let () = print_string qst in
	let rep = read_line() in
	match rep with 
	| "oui" | "o" | "yes" | "y" -> true
	| "non" | "n" | "no" -> false
	| _ -> (print_string "Pas compris... Répondez par o/n (ou oui/non)"; askqyn abq);;

let demander_amelioration abq =
	let per = ask "Oh zut... A qui pensiez vous?" in
	let ques = ask "Une question qui les distingue?" in
	Question(ques, Final per, abq);;

let rec demander abq =
	let rep = askqyn abq in
	match abq, rep with 
	| Question (q, y, n), true -> Question (q, demander y, n)
	| Question (q, y, n), false -> Question (q, y, demander n)
	| Final q, true -> (print_string "Ouaiiiis :D"; Final q)
	| Final q, false -> (demander_amelioration abq);;

Printf.fprintf (open_out "cerveau") "%s" (string_of_abq(demander (abq_of_file (open_in "cerveau"))));;

et un exemple de fichier cerveau

Q"Animal gris ?"Q"Nage ?"F"Baleine"F"Rat"Q"Vol ?"F"Colibri"F"Cochon"

Vous devez être inscrit pour répondre à ce sujet.