test_generalisation.py

import sys
import argparse
import json

import pacman
import layout
import ghostAgents
import qlearningAgents
import textDisplay

def run_phase(agent, layout_name, ghost_type, num_episodes, training=False):
    """
    Lance une série de parties avec l'instance d'agent existante.
    """
    # 1. Chargement du layout
    lay = layout.getLayout(layout_name)
    if lay is None:
        raise Exception(f"Layout {layout_name} introuvable dans layout.py")

    # 2. Configuration des fantômes
    if ghost_type == "RandomGhost":
        ghosts = [ghostAgents.RandomGhost(i+1) for i in range(lay.getNumGhosts())]
    elif ghost_type == "DirectionalGhost":
        ghosts = [ghostAgents.DirectionalGhost(i+1) for i in range(lay.getNumGhosts())]
    else:
        raise Exception(f"Type de fantôme inconnu : {ghost_type}")

    # 3. Affichage (NullGraphics pour aller vite sans fenêtre)
    display = textDisplay.NullGraphics()
    
    # 4. Règles et lancement
    # On passe l'agent DÉJÀ ENTRAÎNÉ à la fonction runGames
    games = pacman.runGames(lay, agent, ghosts, display, num_episodes, record=False, numTraining=num_episodes if training else 0)
    
    # 5. Calcul du score moyen
    scores = [game.state.getScore() for game in games]
    avg_score = sum(scores) / float(len(scores)) if scores else 0
    return avg_score

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    # On reçoit tous les hyperparamètres (alpha, epsilon...) en une seule chaîne
    parser.add_argument('--agent_args', default="") 
    args = parser.parse_args()

    # --- 1. Parsing des hyperparamètres ---
    agent_opts = {}
    if args.agent_args:
        # Nettoyage des guillemets éventuels passés par le shell
        clean_args = args.agent_args.replace('"', '').replace("'", "")
        # Format attendu: "epsilon=0.1,alpha=0.2,..."
        pairs = clean_args.split(',')
        for p in pairs:
            if '=' in p:
                k, v = p.split('=')
                agent_opts[k] = v

    # --- 2. Création de l'agent (UNE SEULE FOIS) ---
    # C'est ici que le réseau de neurones est initialisé
    try:
        print(f">>> Initialisation de l'agent avec: {agent_opts}")
        agent = qlearningAgents.ApproximateQAgent(**agent_opts)
    except Exception as e:
        print(f"Erreur critique lors de l'init de l'agent: {e}")
        sys.exit(1)

    # --- 3. Définition du Protocole Scientifique ---
    # On définit les phases à exécuter séquentiellement sur le même agent
    scenarios = {
        "train":             ("smallClassic", "RandomGhost", 1000, True),   # Phase d'apprentissage
        "test_baseline":     ("smallClassic", "RandomGhost", 50, False),    # Contrôle (A a-t-il appris ?)
        "test_grid":         ("mediumClassic", "RandomGhost", 50, False),   # Variable : Taille Grille
        "test_ghost":        ("smallClassic", "DirectionalGhost", 50, False), # Variable : Intelligence Fantôme
        "test_full":         ("mediumClassic", "DirectionalGhost", 50, False) # Variable : Les deux (le plus dur)
    }

    results = {}
    print(">>> DÉBUT DU PROTOCOLE")

# --- 4. Exécution Séquentielle ---
    for phase_name, (lay, ghost, n_games, is_train) in scenarios.items():
        print(f"--- Phase: {phase_name} [Map: {lay}, Ghost: {ghost}] ---")
        
        if is_train:
            # On remet les valeurs d'origine pour apprendre
            agent.epsilon = float(agent_opts.get('epsilon', 0.05))
            agent.alpha = float(agent_opts.get('alpha', 0.2))
        else:
            # On coupe l'exploration et l'apprentissage pour le test
            agent.epsilon = 0.0 
            agent.alpha = 0.0 

        try:
            score = run_phase(agent, lay, ghost, n_games, training=is_train)
            results[phase_name] = score
            print(f"    Score moyen: {score}")
        except Exception as e:
            print(f"    Erreur: {e}")
            results[phase_name] = -9999

    # --- 5. Sortie JSON pour l'orchestrateur ---
    # finetune_generalisation.py va lire cette ligne spécifique
    print("\nFINAL_JSON_RESULT:" + json.dumps(results))