强化学习实战项目详解与代码实现

好的，我们直接开始讲解一个经典的强化学习实战项目：基于Q-learning的迷宫寻宝。

项目目标

构建一个智能体（Agent），使其能在一个简单的网格迷宫中学习如何从起点（S）移动到宝藏（T）的位置，同时避开陷阱（X）。智能体通过与环境交互来学习最优路径。

迷宫环境示意图：

S …

. X . .

. . X T

• S：起点（Start）

• T：宝藏（Treasure），目标点，到达获得正奖励。

• X：陷阱（Trap），到达获得负奖励并结束回合。

• .：安全但无奖励的空地。

核心概念：Q-learning

Q-learning是一种无模型的强化学习算法。其核心是学习一个Q表。Q表是一个二维表格，其行代表所有可能的环境状态，列代表在每个状态下可以采取的所有动作。表格中的每个值 Q(s, a) 代表了在状态 s 下采取动作 a 所能获得的预期长期累积奖励。

智能体的目标就是学习到这个最优的Q表，之后在任意状态 s，只需选择Q值最高的动作 a，就能沿着最优路径到达目标。

Q值更新公式

智能体通过以下公式在每次交互后更新Q表：

Q(s, a) = Q(s, a) + α [ R + γ max(Q(s’, a’)) - Q(s, a) ]

其中：

• s：当前状态

• a：当前采取的动作

• s‘：执行动作 a 后进入的新状态

• R：从环境获得的即时奖励

• α：学习率，控制新信息覆盖旧信息的程度。

• γ：折扣因子，衡量未来奖励的重要性。

• max(Q(s’, a’))：在新状态 s’ 下，能获得的最大Q值。

公式中的 [ R + γ max(Q(s’, a’)) ] 是“新的现实目标”，Q(s, a) 是“旧的估计”。这个公式就是用新的目标来修正旧的估计。

代码实现

我们将分步骤实现整个项目。

第一步：创建迷宫环境

我们用一个4x4的网格世界，并定义其规则。

import numpy as np

import time

class MazeEnv:

    def **init**(self):

         定义迷宫：0=空地，1=陷阱，2=宝藏，3=起点

        self.grid = np.array([

            [3, 0, 0, 0],

            [0, 1, 0, 0],

            [0, 0, 1, 0],

            [0, 0, 0, 2]

        ])

        self.agent_pos = (0, 0)   智能体起始位置

        self.start_pos = (0, 0)

        self.done = False

     动作空间：上、右、下、左

    self.actions = ['up', 'right', 'down', 'left']

    self.action_effect = [(-1, 0), (0, 1), (1, 0), (0, -1)]

def reset(self):

    """重置环境，智能体回到起点"""

    self.agent_pos = self.start_pos

    self.done = False

    return self.agent_pos

def step(self, action):

    """执行一个动作，返回 (新状态， 奖励， 是否结束)"""

    if self.done:

        raise ValueError("Episode已经结束，请重置环境。")

     计算新位置

    row, col = self.agent_pos

    d_row, d_col = self.action_effect[action]

    new_row, new_col = row + d_row, col + d_col

     检查新位置是否超出边界

    if 0 <= new_row < self.grid.shape[0] and 0 <= new_col < self.grid.shape[1]:

        self.agent_pos = (new_row, new_col)

     获取新位置的类型

    cell_value = self.grid[self.agent_pos]

     根据格子类型决定奖励和是否结束

    if cell_value == 2:   找到宝藏

        reward = 10

        self.done = True

    elif cell_value == 1:   踩到陷阱

        reward = -10

        self.done = True

    else:   空地

        reward = -0.1   每多走一步都有微小惩罚，鼓励高效路径

    return self.agent_pos, reward, self.done

def render(self):

    """可视化当前迷宫状态"""

    grid_vis = self.grid.astype(str)

    grid_vis[grid_vis == '0'] = '.'

    grid_vis[grid_vis == '1'] = 'X'

    grid_vis[grid_vis == '2'] = 'T'

    grid_vis[grid_vis == '3'] = 'S'

    r, c = self.agent_pos

    if not (r == self.start_pos[0] and c == self.start_pos[1]):

        grid_vis[r, c] = 'A'   标记智能体位置

    for row in grid_vis:

        print(' '.join(row))

    print('')

第二步：实现Q-learning智能体

class QLearningAgent:

    def **init**(self, env, learning_rate=0.1, discount_factor=0.9, exploration_rate=1.0, exploration_decay=0.995):

        self.env = env

        self.lr = learning_rate

        self.gamma = discount_factor

        self.epsilon = exploration_rate   探索概率

        self.epsilon_decay = exploration_decay

        self.epsilon_min = 0.01

     初始化Q表：维度为 (行数列数) x 动作数，初始值全为0

    n_states = env.grid.shape[0]  env.grid.shape[1]

    n_actions = len(env.actions)

    self.q_table = np.zeros((n_states, n_actions))

def state_to_index(self, state):

    """将坐标状态（行，列）转换为Q表的行索引"""

    row, col = state

    return row  self.env.grid.shape[1] + col

def choose_action(self, state):

    """基于ε-greedy策略选择动作"""

    state_index = self.state_to_index(state)

     探索：以epsilon的概率随机选择动作

    if np.random.uniform(0, 1) < self.epsilon:

        action = np.random.choice(len(self.env.actions))

     利用：选择当前Q值最大的动作

    else:

        action = np.argmax(self.q_table[state_index])

    return action

def learn(self, state, action, reward, next_state, done):

    """更新Q表"""

    state_index = self.state_to_index(state)

    next_state_index = self.state_to_index(next_state)

     当前状态-动作对的Q值

    current_q = self.q_table[state_index, action]

     下一状态的最大Q值

    next_max_q = np.max(self.q_table[next_state_index]) if not done else 0

     Q-learning更新公式

    target = reward + self.gamma  next_max_q

    new_q = current_q + self.lr  (target - current_q)

    self.q_table[state_index, action] = new_q

     如果回合结束，衰减探索率

    if done:

        self.epsilon = max(self.epsilon_min, self.epsilon  self.epsilon_decay)

第三步：训练智能体

我们将让智能体在迷宫中反复进行多次尝试，以学习最优策略。

**主训练循环**

if **name** == "**main**":

    env = MazeEnv()

    agent = QLearningAgent(env)

episodes = 500   训练回合数

for episode in range(episodes):

    state = env.reset()   重置环境，开始新回合

    total_reward = 0

    steps = 0

    while True:

         智能体选择动作

        action = agent.choose_action(state)

         执行动作，获取环境反馈

        next_state, reward, done = env.step(action)

         智能体学习，更新Q表

        agent.learn(state, action, reward, next_state, done)

        state = next_state

        total_reward += reward

        steps += 1

        if done:

            break

     每50回合打印一次训练信息

    if (episode + 1) % 50 == 0:

        print(f"Episode: {episode+1}, Total Reward: {total_reward:.2f}, Steps: {steps}, Epsilon: {agent.epsilon:.3f}")

print("
训练完成！")

第四步：测试训练好的智能体

训练完成后，我们关闭探索（epsilon=0），观察智能体如何行动。

python

 测试训练结果

print("开始测试智能体...")

state = env.reset()

env.render()

steps = 0

while steps < 20:   防止无限循环

    action = np.argmax(agent.q_table[agent.state_to_index(state)])   直接选择最优动作

    next_state, reward, done = env.step(action)

    state = next_state

    steps += 1

    print(f"步骤 {steps}: 执行动作 {env.actions[action]}")

    env.render()

    time.sleep(0.5)   暂停一下方便观察

    if done:

        if reward > 0:

            print("成功找到宝藏！")

        else:

            print("掉入陷阱！")

        break

项目总结与关键点

奖励设计：奖励函数是引导智能体学习的“指挥棒”。陷阱给予大的负奖励，宝藏给予大的正奖励，而每走一步的微小负奖励是为了鼓励智能体寻找最短路径，而不是在原地打转。

探索与利用的平衡：使用ε-greedy策略。在训练初期，epsilon值较高，智能体倾向于探索未知区域。随着训练进行，epsilon逐渐衰减，智能体越来越倾向于利用已学到的知识（选择Q值最高的动作）。

Q表的意义：训练完成后，Q表就代表了智能体学到的“知识”或“地图”。查看最终的Q表，你会发现从起点到终点路径上的Q值会明显高于其他区域。

超参数调优：学习率、折扣因子和探索衰减率等都是重要的超参数。不同的设置会显著影响学习速度和最终性能，需要根据具体问题进行调整。

通过这个完整的项目，你不仅实现了Q-learning算法，还亲手构建了一个能够通过试错学习解决实际问题的智能体。这是理解强化学习核心思想非常扎实的一步。