0Pricing
AI Agents · Leçon

Modèles du monde et planification prédictive

Des agents qui simulent les états futurs avant d’agir : la simulation mentale pour l’IA.

Modèles du monde et planification prédictive est une leçon AI Agents gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Agents, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Agents comprend 4 leçons au total.

Qu’est-ce qu’un modèle du monde ?

Un modèle du monde est la représentation interne de l’environnement par l’agent : les objets qui existent, leurs états, les règles qui régissent leur évolution et les actions que l’agent peut effectuer pour les influencer. Il s’agit de la simulation mentale du monde par l’agent.

Sans modèle du monde, l’agent ne peut que réagir aux observations. Avec un tel modèle, il peut prédire et planifier.

Représentation de l’état du monde

Un état du monde est un instantané de tous les faits pertinents concernant l’environnement à un moment donné. Pour un agent IdO, il peut s’agir des mesures actuelles des capteurs et de l’état des appareils. Pour un agent logiciel, il peut s’agir de l’état des fichiers, des API et des bases de données qu’il gère.

from dataclasses import dataclass, field
from datetime import datetime
from typing import Any

@dataclass
class WorldState:
    timestamp: str = ''
    entities: dict = field(default_factory=dict)  # entity_id -> attributes
    relationships: list = field(default_factory=list)
    agent_position: str = 'idle'
    pending_actions: list = field(default_factory=list)

    def __post_init__(self):
        if not self.timestamp:
            self.timestamp = datetime.utcnow().isoformat()

    def update_entity(self, entity_id: str, attributes: dict):
        current = self.entities.get(entity_id, {})
        self.entities[entity_id] = {**current, **attributes}

    def snapshot(self) -> dict:
        return {
            'timestamp': self.timestamp,
            'entities': dict(self.entities),
            'agent_position': self.agent_position
        }

# Example:
world = WorldState()
world.update_entity('server_room', {'temp_c': 22.5, 'humidity': 55})
world.update_entity('hvac_unit_1', {'status': 'off', 'setpoint': 22})
print(world.snapshot())

Modèle de transition

Un modèle de transition définit comment l’état du monde change en réponse à une action : next_state = transition(current_state, action). Il permet à l’agent de prédire à quoi ressemblera le monde après une action sans effectuer réellement cette action.

import copy

def transition(state: WorldState, action: dict) -> WorldState:
    """
    Predict next state given current state and action.
    Returns a new WorldState (does not modify original).
    """
    next_state = copy.deepcopy(state)

    action_type = action.get('type')
    target = action.get('target')
    params = action.get('params', {})

    if action_type == 'TURN_ON_HVAC':
        next_state.update_entity(target, {
            'status': 'on',
            'setpoint': params.get('setpoint', 22)
        })
        # Simulate temperature effect (simplified linear model)
        room = action.get('room', 'server_room')
        current_temp = next_state.entities.get(room, {}).get('temp_c', 25)
        next_state.update_entity(room, {
            'temp_c': max(current_temp - 2, params.get('setpoint', 22))
        })

    elif action_type == 'SEND_ALERT':
        next_state.pending_actions.append({'alert_sent': True})

    return next_state

# Predict effect of turning on HVAC:
action = {'type': 'TURN_ON_HVAC', 'target': 'hvac_unit_1',
          'room': 'server_room', 'params': {'setpoint': 20}}
next_world = transition(world, action)
print('After action:', next_world.entities.get('server_room'))

Planification par anticipation

La planification par anticipation simule N étapes dans le futur avant de s’engager dans une action. L’agent explore plusieurs séquences d’actions, évalue chaque état obtenu et choisit la séquence qui mène au meilleur résultat prédit.

def evaluate_state(state: WorldState) -> float:
    """
    Compute a scalar utility score for a world state.
    Higher = better for the agent's goals.
    """
    score = 1.0
    server_room = state.entities.get('server_room', {})
    temp = server_room.get('temp_c', 25)
    # Penalty for high temperature
    if temp > 30:
        score -= (temp - 30) * 0.2
    # Penalty for very low temperature (over-cooling)
    if temp < 18:
        score -= (18 - temp) * 0.1
    return max(0.0, score)

def lookahead(state: WorldState, possible_actions: list, depth: int = 3) -> dict:
    """Evaluate top-level actions by simulating depth steps ahead."""
    best_action = None
    best_score = -float('inf')

    for action in possible_actions:
        simulated = transition(state, action)
        # Simulate depth more steps (simplified: no branching)
        for _ in range(depth - 1):
            simulated = transition(simulated, {'type': 'NOOP'})
        score = evaluate_state(simulated)
        if score > best_score:
            best_score = score
            best_action = action

    return {'best_action': best_action, 'expected_score': round(best_score, 3)}

LLM comme modèle du monde

Pour les environnements complexes et difficiles à formaliser, le LLM lui-même peut servir de modèle du monde. Demandez-lui de prédire ce qui se produira si l’agent effectue une action précise. Vous échangez ainsi de la précision contre de la généralité : le LLM peut raisonner sur des domaines quelconques.

import anthropic
import json

client = anthropic.Anthropic(api_key='YOUR_API_KEY')

def llm_predict(
    current_state: dict,
    proposed_action: dict,
    domain_description: str = ''
) -> dict:
    prompt = (
        f'Domain: {domain_description}\n\n'
        f'Current state: {json.dumps(current_state, indent=2)}\n\n'
        f'Proposed action: {json.dumps(proposed_action, indent=2)}\n\n'
        'Predict the next world state after this action. '
        'Consider direct effects and second-order effects.\n'
        'Return JSON: {"predicted_state": dict, '
        '"confidence": float, "side_effects": [str]}'
    )
    response = client.messages.create(
        model='claude-opus-4-5', max_tokens=512,
        messages=[{'role': 'user', 'content': prompt}]
    )
    return json.loads(response.content[0].text)

Planification fondée sur un modèle ou sans modèle

Fondée sur un modèle : l’agent possède un modèle explicite du monde, simule les états futurs et planifie. Cette approche est plus économe en données et se généralise mieux. Sans modèle : l’agent apprend des couples action-valeur à partir de l’expérience, sans modèle. Cette approche est plus simple, mais nécessite davantage d’interactions pour apprendre une stratégie.

# Comparison table
COMPARISON = {
    'model_based': {
        'pros': [
            'Can plan before acting (lookahead)',
            'Works well with limited data',
            'Interpretable — you can inspect the world model',
            'Can simulate counterfactuals'
        ],
        'cons': [
            'Model can be wrong (model mismatch)',
            'Complex to build for arbitrary domains',
            'Planning is computationally expensive'
        ],
        'examples': 'AlphaGo, MCTS, agent with explicit WorldState'
    },
    'model_free': {
        'pros': [
            'No need to model the world explicitly',
            'Learns from raw experience',
            'Simpler architecture'
        ],
        'cons': [
            'Requires many interactions to learn',
            'Poor generalisation to new scenarios',
            'Cannot reason about unseen situations'
        ],
        'examples': 'Q-learning, policy gradient, basic RLHF'
    }
}

for approach, info in COMPARISON.items():
    print(f'{approach}: {info["examples"]}')

Incertitude dans les modèles du monde

Les modèles du monde sont des approximations. Tenez compte de l’incertitude en conservant une distribution de probabilité sur les états possibles plutôt qu’une estimation ponctuelle unique. Lorsque l’incertitude est élevée, effectuez des actions prudentes ou recueillez davantage d’informations avant d’agir.

from statistics import mean, stdev

@dataclass
class UncertainState:
    entity_id: str
    attribute: str
    samples: list  # multiple estimates

    def mean(self) -> float:
        return mean(self.samples) if self.samples else 0.0

    def uncertainty(self) -> float:
        if len(self.samples) < 2:
            return float('inf')
        return stdev(self.samples)

    def should_gather_more_data(self, threshold: float = 2.0) -> bool:
        return self.uncertainty() > threshold

# Example: uncertain temperature estimate from multiple sensors
temp_state = UncertainState(
    entity_id='server_room',
    attribute='temp_c',
    samples=[22.1, 22.8, 21.9, 34.5, 22.3]  # one outlier
)
print(f'Mean temp: {temp_state.mean():.1f}C')
print(f'Uncertainty (stdev): {temp_state.uncertainty():.2f}')
print(f'Gather more data: {temp_state.should_gather_more_data()}')

Mise à jour du modèle du monde

Après chaque action, l’agent observe le résultat réel et met à jour son modèle du monde. Si la prédiction était incorrecte, le modèle est mis à jour pour gagner en précision. C’est le cycle observer-mettre à jour-planifier qui permet l’apprentissage des agents fondés sur un modèle.

class WorldModelAgent:
    def __init__(self):
        self.world = WorldState()
        self.prediction_errors = []

    def act(self, action: dict) -> dict:
        # 1. Predict next state
        predicted = transition(self.world, action)

        # 2. Take the action in the real world
        actual_observation = self._execute_action(action)

        # 3. Measure prediction error
        for entity_id, attrs in actual_observation.items():
            for attr, actual_val in attrs.items():
                predicted_val = predicted.entities.get(entity_id, {}).get(attr)
                if predicted_val is not None:
                    error = abs(actual_val - predicted_val)
                    self.prediction_errors.append(error)

        # 4. Update world model with actual observation
        for entity_id, attrs in actual_observation.items():
            self.world.update_entity(entity_id, attrs)

        return actual_observation

    def _execute_action(self, action: dict) -> dict:
        # Placeholder — in production this calls real APIs/sensors
        return {'server_room': {'temp_c': 23.0}}

    def model_accuracy(self) -> float:
        if not self.prediction_errors:
            return 1.0
        return max(0.0, 1.0 - mean(self.prediction_errors) / 10)

Planification avec le LLM : simuler 3 étapes

Pour les domaines en langage naturel, demandez au LLM de simuler 3 étapes d’un plan proposé avant de l’exécuter. Le LLM évalue le résultat prédit de chaque étape et signale les problèmes potentiels, empêchant ainsi l’agent d’effectuer des actions dont les conséquences prédites seraient néfastes.

import anthropic
import json

client = anthropic.Anthropic(api_key='YOUR_API_KEY')

def simulate_plan_steps(goal: str, proposed_steps: list) -> dict:
    steps_str = json.dumps(proposed_steps, indent=2)
    prompt = (
        f'Goal: {goal}\n\n'
        f'Proposed plan steps:\n{steps_str}\n\n'
        'Simulate executing each step in order. For each step predict:\n'
        '- What changes in the world?\n'
        '- What could go wrong?\n'
        '- Is this step reversible?\n\n'
        'Return JSON: {"step_simulations": [{"step": int, '
        '"predicted_outcome": str, "risks": [str], "reversible": bool}], '
        '"plan_safe": bool, "recommendation": str}'
    )
    response = client.messages.create(
        model='claude-opus-4-5', max_tokens=1024,
        messages=[{'role': 'user', 'content': prompt}]
    )
    result = json.loads(response.content[0].text)
    if not result['plan_safe']:
        print(f'Plan safety concern: {result["recommendation"]}')
    return result

Quand faire confiance au modèle du monde

Un modèle du monde n’est aussi bon que ne le sont la précision de sa fonction de transition et de son état initial. Dans des environnements qui évoluent rapidement, le modèle devient vite obsolète. Mettez en place un seuil d’obsolescence : si le modèle n’a pas été mis à jour depuis N secondes et qu’une action présente des enjeux élevés, observez d’abord à nouveau l’environnement.

from datetime import datetime, timedelta

class StaleAwareWorldModel:
    def __init__(self, max_age_seconds: int = 60):
        self.state = WorldState()
        self.max_age = timedelta(seconds=max_age_seconds)
        self.last_observation_time = datetime.utcnow()

    def is_stale(self) -> bool:
        age = datetime.utcnow() - self.last_observation_time
        return age > self.max_age

    def refresh(self, observation_fn):
        new_observations = observation_fn()
        for entity_id, attrs in new_observations.items():
            self.state.update_entity(entity_id, attrs)
        self.last_observation_time = datetime.utcnow()
        print(f'World model refreshed')

    def plan_action(self, action: dict, observation_fn) -> dict:
        if self.is_stale():
            print('World model stale — refreshing before planning')
            self.refresh(observation_fn)
        return lookahead(self.state, [action], depth=3)

Raisonnement contrefactuel

Un modèle du monde permet le raisonnement contrefactuel : « Que se serait-il passé si j’avais effectué l’action A au lieu de l’action B ? » C’est un outil puissant pour tirer des leçons de ses erreurs sans les répéter : l’agent peut simuler le scénario contrefactuel afin de comprendre pourquoi son choix a conduit à un résultat sous-optimal.

import anthropic
import json

client = anthropic.Anthropic(api_key='YOUR_API_KEY')

def counterfactual_analysis(
    actual_state_before: dict,
    action_taken: dict,
    actual_outcome: dict,
    alternative_action: dict
) -> dict:
    prompt = (
        'Analyse a counterfactual scenario:\n\n'
        f'Initial state: {json.dumps(actual_state_before, indent=2)}\n'
        f'Action taken: {json.dumps(action_taken, indent=2)}\n'
        f'Actual outcome: {json.dumps(actual_outcome, indent=2)}\n\n'
        f'Alternative action considered: {json.dumps(alternative_action, indent=2)}\n\n'
        'What would likely have happened with the alternative action?\n'
        'Return JSON: {"counterfactual_outcome": str, '
        '"better_choice": str, "lesson": str}'
    )
    response = client.messages.create(
        model='claude-opus-4-5', max_tokens=512,
        messages=[{'role': 'user', 'content': prompt}]
    )
    return json.loads(response.content[0].text)

Vérification des connaissances

Quel est le principal avantage d’un agent fondé sur un modèle par rapport à un agent sans modèle ?

Récapitulatif : modèles du monde et planification prédictive

Excellent travail ! Points essentiels à retenir :

  • État du monde : instantané de tous les attributs pertinents des entités à un moment donné
  • Modèle de transition : next_state = transition(state, action) — prédit les effets
  • Anticipation : simuler N étapes à l’avance, évaluer les résultats et choisir la meilleure action
  • LLM comme modèle du monde : utile dans les domaines difficiles à formaliser
  • Incertitude : conserver des distributions plutôt que des estimations ponctuelles ; éviter d’agir lorsque l’incertitude est élevée
  • Obsolescence : observer à nouveau l’environnement avant les actions à enjeux élevés si le modèle est ancien

Ensuite : les difficultés liées à l’alignement — pourquoi il est difficile de créer des agents autonomes véritablement bénéfiques.

Questions Fréquemment Posées

La leçon « Modèles du monde et planification prédictive » est-elle gratuite ?

Oui — le texte complet de « Modèles du monde et planification prédictive » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Agents, passe à CoddyKit PRO. Le cours AI Agents comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Modèles du monde et planification prédictive » ?

Des agents qui simulent les états futurs avant d’agir : la simulation mentale pour l’IA. Tu pratiques AI Agents avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Agents ?

Aucune expérience préalable n'est requise. AI Agents sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Modèles du monde et planification prédictive » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Agents ?

Oui. Chaque leçon AI Agents inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. De l’assistant à l’agent autonome
  2. Modèles du monde et planification prédictive
  3. Défis d’alignement des agents autonomes
  4. Frontières de la recherche : AGI et au-delà
← Retour à AI Agents