Agent原理入门指南：从零理解智能代理的核心机制

1次阅读

没有评论

共计 2552 个字符，预计需要花费 7 分钟才能阅读完成。

Agent（智能代理）可以理解为一个能够自主感知环境、做出决策并执行动作的智能体。就像我们人类通过眼睛观察世界，大脑思考后做出行动一样，Agent 也遵循类似的流程。它的核心特性包括：

自主性 ：能够独立运行而不需要人为干预
反应性 ：能够感知环境变化并做出响应
目标导向 ：行为是为了达成特定目标
主动性 ：能够主动发起行为而不只是被动响应

Agent 的核心工作流程称为感知 - 决策 - 执行循环（Perception-Decision-Execution loop，简称 PDE 循环）：

感知 (Perception)：Agent 通过传感器获取环境信息
决策 (Decision)：基于内部规则或学习策略做出行动选择
执行 (Execution)：通过执行器将决策转化为实际动作

这个循环不断重复，使 Agent 能够持续与环境交互。

graph LR
    A[感知环境] --> B[决策]
    B --> C[执行动作]
    C --> A

让我们用 Python 实现一个在网格世界中导航的简单规则型 Agent。这个 Agent 需要找到从起点到终点的路径。

class GridWorldAgent:
    """
    简单的网格世界导航 Agent
    环境：5x5 网格，障碍物为 1，空地 0，起点 S，终点 G
    """
    def __init__(self, grid_size=5):
        self.grid_size = grid_size
        self.position = (0, 0)  # 初始位置
        self.goal = (4, 4)     # 目标位置

    def perceive(self, environment):
        """感知当前环境状态"""
        # 返回当前位置和周围信息
        x, y = self.position
        percept = {
            'current': self.position,
            'up': environment[x-1][y] if x > 0 else 1,  # 边界视为障碍
            'down': environment[x+1][y] if x < self.grid_size-1 else 1,
            'left': environment[x][y-1] if y > 0 else 1,
            'right': environment[x][y+1] if y < self.grid_size-1 else 1
        }
        return percept

    def decide(self, percept):
        """基于简单规则的决策"""
        # 优先向目标方向移动
        x, y = self.position
        gx, gy = self.goal

        # 计算目标方向
        if gx > x and percept['down'] == 0:
            return 'down'
        elif gx < x and percept['up'] == 0:
            return 'up'
        elif gy > y and percept['right'] == 0:
            return 'right'
        elif gy < y and percept['left'] == 0:
            return 'left'

        # 如果主要方向受阻，尝试其他方向
        for direction in ['right', 'down', 'left', 'up']:
            if percept[direction] == 0:
                return direction

        return 'stay'  # 无路可走

    def act(self, action):
        """执行移动动作"""
        x, y = self.position
        if action == 'up':
            self.position = (x-1, y)
        elif action == 'down':
            self.position = (x+1, y)
        elif action == 'left':
            self.position = (x, y-1)
        elif action == 'right':
            self.position = (x, y+1)
        # stay 不改变位置

    def run_episode(self, environment, max_steps=100):
        """运行一个完整回合"""
        for step in range(max_steps):
            if self.position == self.goal:
                print(f"到达目标！步数: {step}")
                return True

            percept = self.perceive(environment)
            action = self.decide(percept)
            self.act(action)

        print("未能在最大步数内到达目标")
        return False

# 测试环境
env = [[0, 0, 0, 1, 0],
    [0, 1, 1, 0, 0],
    [0, 0, 0, 0, 1],
    [1, 1, 0, 1, 0],
    [0, 0, 0, 0, 0]
]

agent = GridWorldAgent()
agent.run_episode(env)

上面的例子是一个典型的规则型 Agent，它的决策完全基于我们预先编写的规则。与之相对的还有学习型 Agent，特别是强化学习 Agent：