通俗易懂讲透 Q-Learning：从零学会强化学习核心算法

通俗易懂讲透 Q-Learning：从零学会强化学习核心算法

Q-Learning 是无模型、基于价值迭代的经典强化学习算法，核心就是让智能体通过不断试错，记住每个状态下做什么动作收益最大，最终学到最优决策策略。

---

一、先搞懂：Q-Learning 到底在干什么？

用迷宫寻宝 一句话概括：

你在迷宫里找出口，每走一步都有奖励/惩罚，Q-Learning 就是帮你记一本"行动账本"，记录在哪个位置、往哪边走最划算，越走越聪明。

核心逻辑（3 步走）

1. 探索：一开始瞎走，试试不同方向
2. 记录：把每一步的好坏记在账本里（Q 值）
3. 利用：后面按账本选最优动作，少走弯路

最终目标：让智能体拿到最大的累计奖励。

---

二、关键概念：一看就懂

1. Q 值（动作价值函数）

• 全称：Q(s, a)
• 含义：在状态 s 下，做动作 a 未来能拿到的总收益
• 简单说：这个位置做这个动作"值不值"

2. 贝尔曼方程（Q 更新的依据）

这是 Q-Learning 的数学灵魂，不用怕，拆解开很简单：

Q(s, a) = 当前奖励 r + γ × 下一个状态的最大Q值

• r：做完动作立刻拿到的奖励
• γ（折扣因子） ：未来奖励的重要程度（0~1）
  • 接近1：更看重长远收益
  • 接近0：只看眼前好处

3. Q 值更新公式（最重要！）

Q(s,a) = Q(s,a) + α × [ r + γ×maxQ(s',a') − Q(s,a) ]

• α（学习率） ：每次更新改多少（0~1）
  • 大：学得快，容易震荡
  • 小：学得稳，速度慢
• maxQ(s',a') ：下一个状态里，最好动作的 Q 值

一句话理解：用"新的更好估计"去修正"旧的估计"。

4. 探索 vs 利用（核心矛盾）

• 探索（Explore）：随机选动作，找新路线
• 利用（Exploit）：按账本选最优动作
• ε-贪心策略 ：
  • ε概率随机探索
  • 1−ε概率选最优动作
  • 常用：训练初期ε大，后期ε慢慢减小

---

三、Q-Learning 标准流程（背下来也能用）

1. 初始化 Q 表
   所有状态-动作对的 Q 值初始化为 0 或小随机数。
2. 循环多轮训练（episode）
   1. 把智能体放回起点
   2. 用 ε-贪心选动作
   3. 执行动作，拿到奖励 r 和新状态 s'
   4. 按公式更新 Q 值
   5. 把当前状态换成新状态
3. 收敛后输出最优策略
   每个状态直接选 Q 值最大的动作。

伪代码（极简版）

初始化 Q 表全为0
设置 α, γ, ε
for 每一轮训练:
    初始化状态 s
    while 没到终点:
        用ε-贪心选动作 a
        执行a，得到r, s'
        更新 Q(s,a)
        s = s'

---

四、实战案例：用 Q-Learning 走迷宫

我们用一个9行8列迷宫，手把手跑通代码，本科生/研究生都能直接跑。

1. 迷宫环境定义

• 0：可走路径
• 1：墙（障碍物）
• 起点：(0, 0)
• 终点：(8, 0)

2. 奖励规则（关键！）

• 到终点：+10 奖励
• 撞墙：-1 惩罚
• 每走一步：-0.1（鼓励快点到终点）

3. 完整可运行代码（Python）

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

# 迷宫环境类
class Maze:
    def __init__(self, maze):
        self.maze = np.array(maze)
        self.n_rows, self.n_cols = self.maze.shape
        self.start = (0, 0)
        self.goal = (8, 0)
        self.state = self.start

    def reset(self):
        self.state = self.start
        return self.state

    def step(self, action):
        row, col = self.state
        # 0上 1右 2下 3左
        if action == 0:
            row = max(0, row - 1)
        elif action == 1:
            col = min(self.n_cols - 1, col + 1)
        elif action == 2:
            row = min(self.n_rows - 1, row + 1)
        elif action == 3:
            col = max(0, col - 1)
        
        self.state = (row, col)
        
        # 奖励设置
        if self.state == self.goal:
            reward = 10
            done = True
        elif self.maze[row, col] == 1:
            reward = -1
            done = True
        else:
            reward = -0.1
            done = False
        return self.state, reward, done

# Q-Learning 智能体
class QLearning:
    def __init__(self, env, alpha=0.1, gamma=0.9, epsilon=0.3, episodes=1000):
        self.env = env
        self.alpha = alpha
        self.gamma = gamma
        self.epsilon = epsilon
        self.episodes = episodes
        # Q表：行×列×4个动作
        self.q_table = np.zeros((env.n_rows, env.n_cols, 4))
        self.path_per_episode = []

    def choose_action(self, state):
        if np.random.rand() < self.epsilon:
            return np.random.choice(4)
        else:
            row, col = state
            return np.argmax(self.q_table[row, col])

    def train(self):
        for episode in range(self.episodes):
            state = self.env.reset()
            done = False
            path = [state]
            while not done:
                action = self.choose_action(state)
                next_state, reward, done = self.env.step(action)
                row, col = state
                next_r, next_c = next_state
                
                # Q值更新
                self.q_table[row, col, action] += self.alpha * (
                    reward + self.gamma * np.max(self.q_table[next_r, next_c]) 
                    - self.q_table[row, col, action]
                )
                
                state = next_state
                path.append(state)
            
            self.path_per_episode.append(path)
            if state == self.env.goal:
                print(f"第 {episode+1} 轮到达终点！")

# 迷宫布局
maze = [
    [0,1,0,0,0,0,1,0],
    [0,1,0,1,1,0,1,0],
    [0,0,0,0,1,0,0,0],
    [1,1,1,0,1,1,1,1],
    [0,0,0,0,0,0,0,0],
    [0,1,1,1,1,1,1,1],
    [0,0,0,0,0,0,0,0],
    [1,1,1,1,1,1,1,0],
    [0,0,0,0,0,0,0,0]
]

# 初始化环境与智能体
env = Maze(maze)
agent = QLearning(env, episodes=1000)
agent.train()

# 动态可视化训练过程
fig, ax = plt.subplots(figsize=(8, 8))

def update(frame):
    path = agent.path_per_episode[frame]
    render = env.maze.copy()
    for (r, c) in path:
        render[r, c] = 2
    ax.clear()
    ax.imshow(render, cmap="coolwarm", vmin=0, vmax=2)
    ax.set_title(f"训练轮次：{frame+1}")
    ax.text(0, 0, "S", color="white", fontweight="bold")
    ax.text(0, 8, "G", color="white", fontweight="bold")
    return ax

ani = animation.FuncAnimation(fig, update, frames=len(agent.path_per_episode), repeat=False)
plt.show()

4. 代码说明（一看就懂）

• Maze 类：管迷宫环境，负责移动、给奖励
• QLearning 类：管智能体，选动作、更新 Q 表
• 可视化：动态展示每一轮的行走路径，越到后面路径越短、越直

---

五、Q-Learning 优缺点（面试/论文必背）

优点

1. 无模型：不用知道环境规则，直接交互学习
2. 简单稳定：公式清晰，容易实现
3. 收敛保证：满足条件时一定能学到最优策略

缺点

1. 维度灾难：状态/动作一多，Q 表巨大存不下
2. 收敛慢：高维空间需要大量训练
3. 连续空间不行：只能处理离散状态/动作

---

六、适用场景与实际应用

适用前提

• 状态和动作必须离散
• 有明确奖励/惩罚
• 能充分探索状态空间

实际落地场景

1. 游戏 AI：走迷宫、贪吃蛇、简单棋类
2. 机器人路径规划：AGV 小车、避障导航
3. 资源调度：数据中心负载、带宽分配
4. 广告/推荐：优化投放策略、点击率最大化

---

七、总结（最核心的 3 句话）

1. Q-Learning = 记 Q 表 + 按贝尔曼方程更新
2. 动作选择靠 ε-贪心 平衡探索与利用
3. 适合离散、小状态空间，大场景用 DQN 改进