用Matlab实现Q-learning：从迷宫寻路到强化学习入门

1. 迷宫是这个算法最好的"试验场"

我最早接触Q-learning的时候，第一反应是"又一个听起来很厉害但不知道能用来干嘛的算法"。直到有段时间在帮别人做课设，面对的问题就是一个简单的方形迷宫找路径，我才意识到：迷宫恰恰是理解和验证Q-learning最合适的项目，没有之一。

原因很简单。迷宫问题包含了强化学习的全部核心要素：智能体（agent）、环境（迷宫）、状态（格子位置）、动作（上下左右）、奖励（到达终点得分、撞墙扣分）。它的状态离散、动作有限、结果直观——你可以亲眼看着一个小方块在图上摸索、碰壁、绕路，最终找到一条从起点到终点的路。和那种抽象的函数逼近、游戏对局相比，迷宫把"强化学习到底在学什么"这件事变成了肉眼可见的过程。

具体到本项目的实现，我用的是Matlab。很多人习惯到Python生态里找现成的强化学习库，但如果你本身是Matlab用户，或者课题组的代码环境就以Matlab为主，那完全没必要为了一个迷宫问题去跨语言。Matlab实现Q-learning非常直接：状态用一个整数索引表示，Q表就是普通的二维矩阵，迷宫本身就是一个二维数组。这一套东西不需要任何额外工具箱，核心代码一百来行就能跑通，非常适合用来理解算法本质而不是被框架束缚。

适合看这篇文章的人，我总结下来有三类：一是学校课程里接触到强化学习、需要从零完成一个实验项目的同学；二是工作中偶尔要用强化学习但不想把环境搞得过重的工程人员；三是刚开始学强化学习、想在代码细节上把原理彻底搞明白的初学者。对于那些已经能熟练调库的人来说，这篇文章可能反而偏基础，但如果你想要一套"从迷宫生成到Q表更新到可视化都自己写"的完整参考，这里应该能帮到你。

2. 迷宫环境的建模思路：状态、动作、奖励怎么定

2.1 从"格子地图"到"可计算的环境"

迷宫在Matlab里最自然的表示方式，就是一个二维矩阵。这个矩阵里通常只有两种值：1代表墙，0代表通道。智能体只能在值为0的位置上移动，撞上1就说明这一步走不了。

举个例子，一个5×5的小迷宫可以是这样：

matlab复制M = [
1 1 1 1 1
1 0 1 0 1
1 0 1 0 1
1 0 0 0 1
1 1 1 1 1
];

这个矩阵中，坐标(2,2)、(2,4)、(3,2)、(3,4)、(4,2)、(4,3)、(4,4)是通道，其余都是墙。起点可以设(2,2)，终点设(4,4)。这样一个矩阵，就构成了我们全部的环境信息。

但光有矩阵还不够，要把迷宫喂给Q-learning，还需要把"状态"定义清楚。这里我采用的做法是：把每个可通行的格子映射成一个唯一的整数编号。比如把上面迷宫里的6个通道依次编为1、2、3、4、5、6，那么Q表就是一个6行4列的矩阵。状态编号是几，就对应Q表中的第几行；动作编号是几，就对应第几列。

这里的动作我用1到4四个整数表示上下左右。这里有个新手容易绕晕的地方：状态是线性索引，但判断"往某个方向走是否会撞墙"时，必须把线性索引还原成行列坐标才能查迷宫矩阵。我写过这样一个辅助转换，把格子索引和坐标之间的映射关系固定下来：

matlab复制% 预先找出所有通道格子的行列坐标，并按顺序编号
[row, col] = find(M == 0);
stateCoord = [row, col];  % 第i行的坐标即第i个状态对应的位置

这样状态i的坐标就是stateCoord(i,:)，要判断从状态i向上走是否可行，就看M(stateCoord(i,1)-1, stateCoord(i,2))是否为0。

2.2 奖励设计：不只是"到终点给分"那么简单

奖励决定了智能体学会的路径长什么样。最早我做这个项目时只设了两条规则：到达终点给正奖励，其他一律0。结果训练出的路径经常在原地绕圈，因为如果所有非终点状态的回报都是0，Q表中大量动作的价值会被"折扣因子"稀释得几乎没有差异，随机抖动就会持续很久。

后来我改成了三档奖励，效果明显变好：

• 到达终点：+10
• 撞墙（往墙的方向走）：-0.5
• 普通一步（进入通道但未到终点）：-0.02

普通一步给一个很小的负奖励，意图是让智能体在同等条件下倾向于步数更少的那条路。很多人会问：反正有折扣因子γ，多绕路远期回报打折，自然会走短路，为什么还要给每步惩罚？实践下来的答案是：步数惩罚能显著加快Q表的收敛。因为迷宫不大时，折扣因子对短路径的偏好表达得很微弱，Q值差异容易被学习率扰动淹没；而一个显式的步数惩罚，相当于把"弯路"的代价直接写进奖励里，Q值差异一下就拉开了。

撞墙给负奖励而不是直接禁止动作，这也有讲究。如果你在动作选择阶段直接把撞墙动作过滤掉，智能体永远体验不到"撞墙"这个负面结果，Q表对墙附近的动作倾向就会缺少刻度的区分。反过来，如果每一次撞墙都扣分，Q表会自动学习到"靠墙的动作不是好动作"。另外，撞墙后状态不移动，这一步经验依然可以更新原状态对应动作的Q值，所以撞墙惩罚不能设置过大，否则智能体会变得过度保守，宁可原地不动也不探索。

2.3 为什么要用"随机迷宫"

固定迷宫也能跑通Q-learning，但我最终把迷宫改成了"随机生成"版。原因是固定迷宫会让算法学到的是特例路径而不是泛化策略——你把迷宫墙的位置稍微动一格，原来的Q表就废了。而每次训练使用新生成的随机迷宫，Q表被迫适应不同连通结构下的通用规律：什么样的动作会导致撞墙、什么样的状态距离终点更近。这让整个项目从"背答案"上升到"学策略"，也更贴近强化学习的目标。

3. 算法核心拆解：Q-learning与ε-greedy在实际代码里长什么样

3.1 Q值更新公式的每一部分到底在干什么

Q-learning的核心公式是：

code复制Q(s,a) ← Q(s,a) + α * [r + γ * max(Q(s',a')) - Q(s,a)]

这个公式看起来很吓人，拆开其实就一句话：当前状态s做动作a的价值，要朝着"当前奖励 + 下一状态最佳动作价值"的方向修正一点。

代码里对应这样一行：

matlab复制Q(s, a) = Q(s, a) + alpha * (r + gamma * max(Q(nextS, :)) - Q(s, a));

其中r是从环境返回的奖励，max(Q(nextS,:))是到达下一个状态后，如果继续采取最优策略能获得的未来价值。alpha控制每次修正的幅度，相当于学习步长。这个更新方式有个很有意思的特点：它不需要走完一整条路径才更新，每一步走完立刻就能更新Q表，这在强化学习里叫时序差分学习。相比那种"走完一轮再回填奖励"的方式，它的收敛快得多，而且在迷宫问题里不需要完整轨迹就能持续学习，对回合内步数上限的容忍度也更高。

举个例子感受下：假设智能体在起点格子，向右走进入了通道，奖励r=-0.02，下一个格子距离终点很近，它的max(Q(nextS,:))是8。如果γ=0.99、α=0.1，原Q值假设是0，那么更新后：

code复制0 + 0.1 * (-0.02 + 0.99*8 - 0) ≈ 0.79

这个数值会逐步传播回去：靠终点近的格子Q值高，靠终点远的格子通过"看相邻格子价值"逐渐也抬高。这就是Q-learning能学到"从起点也能判断出哪条路大概对"的根本原因。

3.2 为什么必须用ε-greedy，以及ε怎么衰减

如果每次动作都选Q值最大的，那智能体将永远走它当前认为最好的路。问题是训练初期的Q表全为0，所谓"最好"完全是瞎猜，结果就是智能体一旦找到一条勉强能到终点的路，就死抱着不放，再也不会发现更好的路径。这叫做"探索不足"。

ε-greedy的思路非常朴素：以ε的概率随机选择一个动作（探索），以1-ε的概率选当前Q值最大的动作（利用）。代码实现就几行：

matlab复制if rand < epsilon
    a = randi(4);            % 随机探索
else
    [~, a] = max(Q(s, :));  % 利用当前经验
end

那ε取多少合适？我见过不少同学把ε设为固定0.1，然后发现训练两千回合路径还是不够短。问题在于：前期Q表是空白的，只有10%的探索概率根本不够覆盖迷宫中的岔路；后期Q表已收敛，30%的随机探索又会让智能体频繁走回头路。正确的做法是让ε从大往小衰减。

code复制初始 ε = 1.0（前期完全随机，让智能体充分乱撞）
每回合结束：ε = max(ε×0.995, 0.01)

衰减系数的选择通常这样判断：如果每回合步数上限是500步，那0.995这个系数大约在200回合内能把ε压到0.37，500回合压到0.08左右，和迷宫问题的收敛节奏基本匹配。如果你的迷宫更大、回合数更长，衰减系数可以往0.998甚至0.999调，让探索保持更久。

3.3 一个完整的训练主循环，每行都做了什么

我把上面所有元素串成一个训练主循环，整个流程非常紧凑：

matlab复制% 训练参数设置
alpha = 0.1;       % 学习率
gamma = 0.99;      % 折扣因子
epsilon = 1.0;     % 初始探索率
epsilonMin = 0.01; % 探索率下限
epsilonDecay = 0.995;
maxEpisodes = 1000;
maxSteps = 500;

% Q表初始化：全部置0
Q = zeros(numStates, 4);

for episode = 1:maxEpisodes
    s = startState;
    step = 0;
    while s ~= goalState && step < maxSteps
        % 选择动作：ε-greedy
        if rand < epsilon
            a = randi(4);
        else
            [~, a] = max(Q(s, :));
        end
        
        % 环境交互：根据动作计算下一状态和奖励
        [nextS, r] = takeAction(s, a, M, startState, goalState);
        
        % Q值更新
        Q(s, a) = Q(s, a) + alpha * (r + gamma * max(Q(nextS, :)) - Q(s, a));
        
        % 状态推进
        s = nextS;
        step = step + 1;
    end
    
    % 每回合结束衰减ε
    epsilon = max(epsilonMin, epsilon * epsilonDecay);
end

takeAction函数负责一切环境逻辑：按方向计算目标坐标、判断目标是否为墙、判断是否越界、判断是否到达终点、返回相应奖励并把新状态编号换算出来。我单独写一个函数而不是在循环里展开，是因为训练循环的复杂度已经够高了，环境逻辑不该混在里面。这个函数大概长这样：

matlab复制function [nextS, r] = takeAction(s, a, M, startState, goalState)
    % 根据动作编号1-4，计算目标坐标（上、下、左、右）
    deltas = [-1 0; 1 0; 0 -1; 0 1];
    dr = deltas(a, 1);
    dc = deltas(a, 2);
    
    r_current = stateCoord(s, 1);
    c_current = stateCoord(s, 2);
    r_next = r_current + dr;
    c_next = c_current + dc;
    
    % 检查是否越界或撞墙
    if r_next < 1 || r_next > size(M,1) || c_next < 1 || c_next > size(M,2) || M(r_next, c_next) == 1
        nextS = s;      % 状态不变
        r = -0.5;       % 撞墙惩罚
        return;
    end
    
    % 找到新状态编号
    nextS = find(stateCoord(:,1) == r_next & stateCoord(:,2) == c_next);
    
    % 判断是否到达终点
    if nextS == goalState
        r = 10;
    else
        r = -0.02;
    end
end

这里有个很关键的细节：撞墙不能直接给一个负大值然后结束回合，否则Q表里面墙上方向的价值被压得过低，以后就算绕路走到一个"三面是墙"的格子附近，算法也会因为这个格子周边动作价值异常而对它产生错误的判断。合理的做法是撞墙只扣小分、不结束回合，让智能体通过多次尝试明白"这面墙不是死路，只是走不通"。

4. 随机迷宫怎么生成：递归回溯与矩阵打通法

4.1 迷宫生成算法选型：递归回溯为什么最合适

随机迷宫的生成算法有好几种，最常见的是递归回溯（深度优先）和随机Prim。两者生成的迷宫风格差异非常明显，我实际都写过一遍，感受是：

考虑到Q-learning需要"探索——反馈"的循环，路径结构太复杂反而让收敛速度变得很慢，而且长走廊迷宫的Q值传播梯度更清晰（相邻格子Q值递进关系一目了然），所以最终我选了递归回溯。

4.2 矩阵形式的迷宫打通思路

用矩阵表示迷宫时有个约定俗成的技巧：让迷宫矩阵的行列数都是奇数。这样奇数行奇数列是真正的"格子"，偶数行偶数列以及奇偶混合的位置都可以是"墙"。递归回溯不是把格子直接打通，而是把两个相邻格子之间夹着的那堵墙置为0。

核心步骤是这样的：

1. 初始化全为1的矩阵，尺寸(2n+1)×(2n+1)。
2. 把所有奇数行奇数列的位置设为0，代表"房间"。
3. 从某个房间出发，随机选一个相邻的未访问房间，打通它们之间的墙，递归进入对方。
4. 如果当前房间的所有邻居都已经访问过，就回退到上一个房间继续找未访问的邻居。

这里的"相邻"指的是相隔一个墙的单位距离，比如(2,2)和(2,4)之间的墙位于(2,3)。打通这堵墙就是把M(2,3)从1改成0。实际代码里我更推荐用显式的栈代替递归，避免迷宫大时递归层级过深，虽然几十格的迷宫递归完全没问题，但养成用栈的习惯以后在更大世界观里不容易踩坑。

matlab复制function M = generateMaze(n)
    % 生成 (2n+1)×(2n+1) 的迷宫矩阵
    M = ones(2*n+1, 2*n+1);
    M(2:2:end, 2:2:end) = 0;  % 所有奇数行奇数列房间置0
    
    visited = false(n, n);
    stack = {[1, 1]};   % 从左上角房间开始
    visited(1, 1) = true;
    
    while ~isempty(stack)
        cur = stack{end};
        r = cur(1); c = cur(2);
        
        % 收集未访问的邻居
        neighbors = [];
        if r > 1 && ~visited(r-1, c), neighbors(end+1,:) = [r-1, c]; end
        if r < n && ~visited(r+1, c), neighbors(end+1,:) = [r+1, c]; end
        if c > 1 && ~visited(r, c-1), neighbors(end+1,:) = [r, c-1]; end
        if c < n && ~visited(r, c+1), neighbors(end+1,:) = [r, c+1]; end
        
        if isempty(neighbors)
            stack(end) = [];  % 回退
        else
            % 随机选一个邻居
            idx = randi(size(neighbors, 1));
            nr = neighbors(idx, 1);
            nc = neighbors(idx, 2);
            
            % 打通墙：两个房间坐标映射到矩阵坐标，中间的墙置0
            wallR = 2*min(r, nr);
            wallC = 2*min(c, nc);
            M(2*r-1 + (nr-r), 2*c-1 + (nc-c)) = 0;
            M(wallR, wallC) = 0;  % 正确方式见下方说明
            
            visited(nr, nc) = true;
            stack{end+1} = [nr, nc];   % 压栈
        end
    end
end

上面代码里有一处我故意写得有点啰嗦——打通墙的那一行。实际上正确逻辑是：两个房间坐标分别为(r,c)和(nr,nc)，对应的矩阵坐标是(2*r-1, 2*c-1)和(2*nr-1, 2*nc-1)，夹在中间的墙的矩阵坐标是(r+nr-1, c+nc-1)（因为它们只在一个方向上相差1）。所以打通墙就一句话：

matlab复制M(r+nr-1, c+nc-1) = 0;
M(2*r-1, 2*c-1) = 0;
M(2*nr-1, 2*nc-1) = 0;

如果你直接用我注释里那种M(2*r-1 + (nr-r), 2*c-1 + (nc-c))的写法，虽然数学上等价，但可读性差。这种细节在实际调试时很容易出问题——矩阵索引的差1错误是迷宫生成类代码出错的高发区，建议生成完迷宫后立刻imagesc(M)看一眼整体结构。

4.3 可视化：让迷宫和智能体"活"起来

迷宫生成完毕，用imagesc配一个简单的颜色映射就能显示黑白迷宫图。如果想让智能体训练过程可见，可以在每一步更新后重绘当前格子对应的图形。

我用的方案是保留一个空白的figure，把智能体当前所在的位置用一个高亮方块叠加到迷宫图上。最简单的方式是把迷宫矩阵复制一份，把智能体当前坐标改成2，然后：

matlab复制imagesc(M_display)
colormap(gray)
axis equal off
drawnow

但如果每帧都重新imagesc，画面会闪烁而且很慢。更好的做法是先把迷宫底图用imagesc画好，然后用一个patch或rectangle对象表示智能体，每次更新只移动这个对象的位置。

matlab复制hold on;
agent = rectangle('Position', [c-0.5, r-0.5, 1, 1], 'FaceColor', 'r', 'EdgeColor', 'none');
% 训练循环中移动时：
set(agent, 'Position', [c_next-0.5, r_next-0.5, 1, 1]);
drawnow;

这样运行时能实时看到智能体探索迷宫的轨迹：前期横冲直撞，后期沿着一条流畅的路径直奔终点，这个观察过程本身就是对算法原理最好的验证。

5. 训练出来的结果怎么判断"学得好不好"

5.1 三条靠谱的观察指标

Q表收敛后，光看智能体能不能走到终点是不够的。我一般会看三个量：

第一是每回合总奖励曲线。这个值在训练前期应该是波动的，随着ε衰减逐渐攀升并稳定。如果曲线一直在低处震荡、没有明显上升，多半是奖励设计或探索率衰减参数有问题。

第二是每回合到达终点的步数曲线。这个指标比总奖励更直观。理想情况下步数应该从几百步（大量绕路）快速下降到接近理论最短路径长度。如果步数下降但最终停留在比最短路径长很多的值，说明智能体找到了"一条能走的路"但没找到"最优的路"——这通常是ε衰减太快，后期不再探索导致的。

第三是Q表本身的结构。收敛后，沿着任意通道格子看它的4个Q值，凡是撞墙方向对应的Q值应当明显偏低，而指向终点方向的动作Q值应当高。这说明Q表里"存"的确实是关于迷宫结构的知识，而不仅仅是走通一条路。

5.2 参数调优的实践心得

这几个参数我在试过几十组组合之后，总结出的规律如下：

• α在0.05到0.3之间通常表现良好。太大（>0.5）会导致Q值来回震荡，训练曲线像锯齿；太小（<0.01）则收敛太慢。迷宫这种规模的问题，0.1是个稳妥起点。
• γ更接近1会让路径更短。γ=0.9时智能体明显更"短视"，只顾眼前少扣分，经常走绕路但早期奖励高的路径；γ=0.99以上时才会主动牺牲暂时的步数惩罚去换取整体的最优。
• ε衰减系数要看总回合数。如果跑1000回合，0.995到0.998都合理；如果只跑300回合，衰减系数要更激进（比如0.98），否则训练结束前探索率还降不下来。
• 每回合最大步数设太小会害了训练。如果最大步数只有50，而迷宫最短路径恰好50步，那智能体在探索阶段永远走不到终点，得不到正奖励，Q表一直学不到"终点在哪"。宁可设置成最短路径长度的5倍以上。

5.3 提取和检验最终策略

训练完后，把Q表固定住，从起点开始反复执行max(Q(s,:))对应的动作，就能得到一条完整路径。有个必要检查：打印这条路径的坐标序列，如果出现"在两个格子之间来回跳"的死循环，说明Q表出现了局部震荡——某个状态的两个动作Q值差不多，按max取到的动作引导回到前一个状态，而前一个状态又导回来。解决方案不外乎两种：给步数惩罚增加，拉大正常路径和绕路之间的Q值差异；或者训练结束后对Q表做一次轻微的平滑处理。我通常优先用前者，因为从根上消除震荡比事后补救更可靠。

6. 踩过的坑和后续扩展方向

6.1 三个最典型的坑

状态编号错位。这是新手最容易遇到的问题。通道格子编号的生成顺序要和stateCoord里存坐标的顺序严格一致，否则Q表的行对应关系和迷宫实际位置就错位了，训练自然完全不收敛。排查的方法是取几个已知坐标的状态编号手算验证一下。

撞墙逻辑与坐标边界同时出错。如果只检查撞墙忘了检查越界，智能体在迷宫边缘会出现索引负数的报错；如果只查越界不查撞墙，智能体会直接穿过墙。这两者必须成对出现。

探索率衰减过快导致早熟。如果你的迷宫每次都是随机生成的，前100回合恰好生成了几个简单的迷宫，智能体很快找到了几条路径，然后ε降得很低——这时突然生成一个复杂的迷宫，智能体的Q表根本不适应，但因为ε太低几乎不探索，它会在里面反复撞墙走不出去。应对办法是：ε衰减的回合数要大于严格大于迷宫复杂度可能出现变化的范围，或者直接改用基于收敛状态的动态ε策略，当连续多回合Q表更新量都很小时再继续降ε。

6.2 从这个小项目还能走向哪里

迷宫版的Q-learning跑通之后，往哪个方向扩展都顺理成章。比如把迷宫尺寸从10左右扩展到几百以上，你会立刻发现普通Q表的内存占用量增长极快——这时候就该考虑价值函数逼近（或者直接上DQN这类算法）。又比如增加动态墙体（地图像素在训练过程中按一定概率变化），环境就不再是静态的，这能让你体会到强化学习面对非平稳环境时的脆弱性和应对思路。

我个人最推荐做的扩展是把格子坐标从离散变成连续：把方形迷宫视为连续二维空间，智能体在任意坐标都可以朝任意方向移动一段小距离。这样状态空间瞬间变得无穷大，Q表方案彻底失效，但整个问题的框架不变——这时你已经在触摸现代强化学习的核心挑战了，而你在迷宫项目里学到的"环境、奖励、Q值更新"这套思考方式，依然完全适用。

回到最开始的问题：Q-learning到底是什么、能干什么？经过这个项目，我的体会是它不只是一个公式，而是通过反复试错把"哪些动作带来好结果"的信息编码进一张表里的一种机制。迷宫只是载体，但载体选择得好不好，直接决定了抽象概念能不能落地成自己能掌控的代码。这个Matlab版本，至少对我来说，把这件事儿说清楚了。