Agentic World Modeling 深度解读：AI Agent 如何构建「内心世界的模型」

class WorldModel:
    """Agent 的内心世界模型"""
    
    def __init__(self):
        self.state_encoder = StateEncoder()
        self.transition_model = TransitionModel()
        self.reward_model = RewardModel()
        self.simulator = ImaginationEngine()
    
    def predict(self, current_state, action):
        """预测执行某个动作后的结果"""
        next_state = self.transition_model(current_state, action)
        reward = self.reward_model(next_state)
        return next_state, reward
    
    def imagine(self, current_state, plan, steps=10):
        """在内心模拟一个计划的多步结果"""
        state = current_state
        trajectory = [state]
        for action in plan:
            state, reward = self.predict(state, action)
            trajectory.append(state)
        return trajectory

def counterfactual_reasoning(agent, observed_outcome, alternative_action):
    """
    反事实推理：如果 Agent 采取了不同的行动，结果会怎样？
    这是 Agentic World Model 的核心能力之一
    """
    current_state = agent.world_model.current_state
    simulated_trajectory = agent.world_model.imagine(
        current_state=current_state,
        plan=[alternative_action],
        steps=5
    )
    
    actual_value = agent.evaluate(observed_outcome)
    counterfactual_value = agent.evaluate(simulated_trajectory[-1])
    
    return {
        "actual": actual_value,
        "counterfactual": counterfactual_value,
        "difference": counterfactual_value - actual_value,
    }

"""简易 Agentic World Model 实现"""
from dataclasses import dataclass
from typing import List

@dataclass
class WorldState:
    position: tuple
    goal: tuple
    obstacles: List[tuple]
    steps_taken: int = 0

class AgenticWorldModel:
    def __init__(self, grid_size=10):
        self.grid_size = grid_size
        self.actions = {
            "up": (-1, 0), "down": (1, 0),
            "left": (0, -1), "right": (0, 1)
        }
    
    def predict(self, state, action):
        dx, dy = self.actions[action]
        nx = max(0, min(self.grid_size-1, state.position[0]+dx))
        ny = max(0, min(self.grid_size-1, state.position[1]+dy))
        return WorldState(
            position=(nx, ny), goal=state.goal,
            obstacles=state.obstacles,
            steps_taken=state.steps_taken+1
        )
    
    def plan_with_imagination(self, state, max_depth=5):
        """通过内心模拟找到最优计划"""
        best_plan, best_score = [], float('inf')
        
        def dfs(current, plan, depth):
            nonlocal best_plan, best_score
            if depth > max_depth:
                return
            for action in self.actions:
                nxt = self.predict(current, action)
                if nxt.position in nxt.obstacles:
                    continue
                new_plan = plan + [action]
                dist = abs(nxt.position[0]-state.goal[0]) + abs(nxt.position[1]-state.goal[1])
                if dist == 0 and len(new_plan) < best_score:
                    best_score = len(new_plan)
                    best_plan = new_plan[:]
                dfs(nxt, new_plan, depth+1)
        
        dfs(state, [], 0)
        return best_plan