从射线感知到反向传播：手写神经网络赛车全链路避坑

简介：这是一份面向神经网络入门者与Python游戏AI爱好者的实战项目包，围绕“让神经网络学会操纵赛车游戏”展开，提供两条实现路线：一条基于TensorFlow框架搭建并训练模型，另一条从零手写神经网络，便于对照理解前向传播、参数更新与推理流程。压缩包共54个文件、约8.9MB，以Python源码、编译缓存、文本说明、XML工程配置、PNG素材和WMV演示视频为主，并包含训练数据、模型检查点与索引文件；源码覆盖游戏逻辑、地图与角色控制、数据采集、模型训练及AI测试等模块，演示素材还可观察AI与人工操控的差异。已有2064人学习下载，适合希望把深度学习概念落到小游戏场景中的读者参考，也可用于课程设计、入门实验或二次开发时对照完整工程结构、训练产物与演示效果。

1. 神经网络开车：真正难的不是调参，而是“不写规则”

第一次用 Python 自己实现神经网络去操纵赛车游戏，多数人预设的难点是调参——学习率、层数、激活函数，听着就像玄学。真跑起来才发现，卡住人的是另一件事：游戏引擎只会告诉你车现在在哪、速度多少、离墙多远，它永远不会告诉你“方向盘该打 0.37”。神经网络要做的，是把这一串物理量压成一个实数，再交给方向盘。这中间没有一条 if-else 可写，也没有“正确答案”可以对照，只有一条从感知到动作、再到梯度的通路。值得搞懂它，是因为整条链路往往只有几百行代码，每个中间量都能打印出来看——它是少数能把“感知怎么编码、前向怎么算、梯度从哪来、为什么翻车”全部看穿的场景。看懂一次，后面所有“输入特征怎么设计”“训练不收敛怎么查”的问题，都会回到同一套判断上。

2. 感知层：赛车游戏的一帧状态怎么变成网络能吃的向量

把游戏状态直接丢给网络的经典翻车方式是喂绝对坐标。车在 (320, 780) 附近该左转，这个结论对网络来说就是一条查表记录，赛道平移两百像素、或者换一个初始发车位，学到的东西全部作废。感知层的第一原则因此很朴素：只喂相对量。

2.1 车头坐标系：为什么射线必须从车自己看出去

游戏引擎给出的原始状态通常是世界坐标下的位置、朝向角、速度矢量、角速度，外加赛道的一堆线段。这些量里，位置和朝向是绝对的，速度和角速度是相对的。神经网络真正该看到的是“我的左前方 30 度、距离 120 像素处有墙”，而不是“墙在世界坐标 (512, 96)”。

常见的做法是在车身周围撒一圈射线，角度取相对车头的固定偏移，比如 -90、-60、-30、0、30、60、90 度共 7 条，再加两个标量特征：归一化速度、以及速度在车头方向上的投影（横滑时这两个值会明显分叉）。特征清单大致如下：

9 维输入对“沿着赛道跑”这个任务来说其实够用。有人会问：横向偏移、航向误差这些量不是能从 7 条射线里推出来吗？能，但让网络自己去拟合这个几何关系，等于让它花容量做一件你已经知道答案的事。显式给一份“整理好的简历”，收敛速度往往差好几倍。

2.2 射线求交：把“离墙多远”算成一个精确的数

射线的距离有两条实现路线：步进采样和解析求交。步进采样写起来最省事——沿方向每 10 像素采样一个点，判断点是否在赛道内，第一次出界就返回当前距离。它在直道上没问题，一到薄墙就出事：墙厚 2 像素，步长 10 像素，射线会直接穿过去，返回一个“前方畅通”的假距离，车就这么撞了。这个问题在第 5 章还会再提一次。

稳妥的做法是把它当成射线与线段的求交问题，用叉积解参数方程。下面是向量化版本，一次算完所有射线对所有线段：

import numpy as np def ray_cast(x0, y0, dirs, seg_a, seg_b, max_len): """ dirs: (R, 2) 单位方向向量，相对世界坐标 seg_a: (S, 2) 线段起点 seg_b: (S, 2) 线段终点 返回: (R,) 每条射线到最近墙面的距离，未命中则为 max_len """ r = dirs[:, None, :] # (R, 1, 2) s = (seg_b - seg_a)[None, :, :] # (1, S, 2) qp = seg_a[None, :, :] - np.array([x0, y0]) # (1, S, 2) 起点指向线段起点 denom = r[..., 0] * s[..., 1] - r[..., 1] * s[..., 0] # cross(r, s) denom = np.where(np.abs(denom) < 1e-9, 1e-9, denom) # 平行时避免除零 t = (qp[..., 0] * s[..., 1] - qp[..., 1] * s[..., 0]) / denom # 射线参数 u = (qp[..., 0] * r[..., 1] - qp[..., 1] * r[..., 0]) / denom # 线段参数 hit = (t > 0.0) & (u >= 0.0) & (u <= 1.0) # t>0 在前方，u 在 0~1 落在线段内 t = np.where(hit, t, max_len) return np.minimum(t.min(axis=1), max_len)

t是沿射线的距离（因为dirs是单位向量，参数值就等于距离），u是落点在线段上的比例，u在 0 到 1 之间才说明交点真的在这条线段上而不是它的延长线上。denom是叉积，趋近 0 表示射线与线段平行，此时强制给一个极小值把除法推开，t会被算成一个大数，hit自然不成立。这个函数没有 Python 层的循环，7 条射线 × 上百条线段一帧不到一毫秒，后面想加射线数量也不会拖慢仿真。

2.3 归一化：像素值直接喂进去会出什么事

就算距离算对了，直接把它当特征也是给自己挖坑。赛道宽度两三百像素，射线距离最大能到 800，而权重初始化后第一层权重量级大约在 0.3 左右，9 个特征乘加出来的z轻松上到几百。隐藏层的 ReLU 不怕大值，但输出层的 tanh 只认 (-1, 1)，z一旦到几百，输出永远贴在 ±1，反向传播时 tanh 的导数1 - tanh(z)²约等于 0，梯度传不回去，网络看起来在训练，其实一动不动。

所以每条射线距离都除以最大探测距离，速度除以最大速率，让所有特征落在 0~1 这个同量级区间。这一步不只是数值稳定，它同时定义了“远”和“近”的语义边界。血泪经验是：训练时用max_len=300归一化，推理时换成了 500，模型会瞬间变傻，而代码里根本看不出哪里错了。归一化常量应当写进模型文件，加载时校验，别让它散落在两处代码里。

还有一处容易忽略的细节是决策频率。物理引擎可能跑在 60Hz，但神经网络没必要每秒决策 60 次——相邻两帧的状态几乎一样，输出会有高频抖动，方向盘看起来像在抽搐。把决策降到 20Hz，再对动作做一阶低通a_t = 0.7 * a_{t-1} + 0.3 * a_t，车身的姿态会立刻稳下来。这个滤波是纯工程手段，和网络本身无关，但它对最终效果的影响比换激活函数大得多。

3. 前向传播：一次矩阵乘法里藏着方向盘的转动

网络结构定下来之后，前向传播就是几行矩阵乘法。但“几行”里每个形状、每个函数选择都有理由，写错一个维度，报错信息通常指向一个完全无关的地方。

3.1 输入维度、隐藏层宽度与输出维度

以 9 维输入、单输出（只控转向）为例，两层隐藏层 32 和 16 是个合理的起点。参数总量可以手算：

不到一千个参数，训练几千帧就能收敛。宽度选 32 不是拍脑袋：输入只有 9 维、任务本质是“根据前方障碍调方向”，表达需求不高；层太宽容易把仿真器的某些偶然特性（比如某段路的曲率）记成硬规则，换条赛道就崩。反过来，如果输入换成俯视的小分辨率图像，这个结构就不够了，得换卷积——全连接层对像素的空间结构一无所知，这是它天然的上限，第 6 章会再谈。

输出维度取决于你要控几个量。只控转向是 1 维；要同时控油门和刹车就是 2 维，第一维映射到[-max_steer, max_steer]，第二维映射到[0, 1]的油门开度。多输出共用同一套隐藏层特征，这在工程上比训两个网络省事，但两路的梯度尺度要分别检查，油门那一路的梯度经常被转向那一路压住。

3.2 激活函数：隐藏层用 ReLU，输出层为什么是 tanh

隐藏层选 ReLU 的理由很实际：正区间导数恒为 1，梯度不会随层数指数衰减，计算也只有一个max。它的缺点是不连续可导、负区间梯度为 0，神经元一旦长期落在负区就可能“死掉”，永远不再更新。对这么小的网络，死一半神经元还能跑；对深网络就得考虑 LeakyReLU 之类带负斜率的变体。

输出层的选择由物理量决定。转向角的范围是对称的[-1, 1]，tanh 的值域正好是 (-1, 1)，且在 0 附近近似线性，方向盘在小角度时响应细腻，打到极限时自然饱和——这恰好符合真实车辆“角度越大越难继续打”的特性。用 sigmoid 再线性映射到[-1, 1]也能work，但中心在 0.5，输出天然偏置，初始化时网络会默认往一个方向打方向盘，训练初期车会一直画圈。如果是分类式输出（左转/直行/右转三选一），那才轮到 softmax，用在这里是错配。

3.3 权重初始化：全填 0 和全填 0.01 都会出事

初始化看着无关紧要，实际上决定了训练能不能启动。权重全填 0，同一层的所有隐藏单元收到的输入完全一样、梯度也完全一样，更新之后还是完全一样——整个隐藏层退化成一个大神经元，网络等价于线性模型，表达能力直接砍掉一大截。

全填一个很小的常数（比如 0.01）是另一个极端。每层的z方差会随着 fan_in 逐层缩小，两层之后信号幅度掉到千分之一，输出层几乎收不到有效梯度。反过来填大了，z爆炸，tanh 饱和，又是梯度消失。合适的做法是让每层输出方差保持稳定，He 初始化给出的尺度是sqrt(2 / fan_in)，系数 2 是给 ReLU 的一半负区间做补偿。

实际动手时，我会在训练前先跑一遍尺度检查，确认每层的激活分布正常：

def layer_stats(net, x): """打印每层线性输出与激活的分布，用于初始化后的体检""" a = x n = len(net.W) for i in range(n): z = a @ net.W[i] + net.b[i] a = np.tanh(z) if i == n - 1 else np.maximum(z, 0.0) dead = float((a <= 0).mean()) if i < n - 1 else 0.0 print(f"layer {i}: z.std={z.std():.3f} a.mean={a.mean():+.3f} dead={dead:.1%}") return a

判断标准很直接：z.std落在 0.5 到 2 之间算健康，低于 0.1 说明信号在衰减、要调大初始化尺度，高于 10 说明快饱和了；dead是隐藏层里被 ReLU 判负的比例，超过 50% 意味着相当一部分神经元在当前输入分布下不参与工作，要么换初始化，要么补输入多样性。这十几行代码能提前拦掉一大半“训练不动”的问题，比事后看损失曲线猜要快得多。

4. 训练信号：没有“正确答案”的时候，梯度从哪来

前向传播负责把状态映射成动作，真正的难点是：怎么告诉网络“这个动作好不好”。这里有两条完全不同的路线，取决于你手上有没有示范数据。

4.1 有示范数据：MSE 加反向传播

如果能录到人类玩家的操作——状态、方向盘角度成对出现——问题就退化成标准的监督回归，损失用均方误差，梯度推起来很干净：

def train_step(net, x, y): """x: (B, 9) 一批状态；y: (B, 1) 对应的方向盘角度""" pred = net.forward(x) # 前向，缓存中间激活 diff = pred - y loss = float((diff ** 2).mean()) # 标量损失，仅用于监控 dout = 2.0 * diff / diff.shape[0] # dL/dpred，已按 batch 求平均 net.backward(dout) # 反向传播并原地更新权重 return loss

dout里除以 batch size 这一步不能省：损失是整批样本的平均，对单个预测求导自然要带1/B，否则梯度会随 batch 大小线性放大，等效于把学习率乘了 B 倍，换个 batch 就得重调学习率。这段代码的前提是数据分布要覆盖网络将来会遇到的状态——人类示范里几乎没有“车头已经贴着墙、只剩 0.2 秒就要撞”的样本，而策略一旦偏离就正好会开进这种区域，这是后面第 5 章要专门说的问题。

4.2 没有标签：把“跑得远”当成适应度

大多数时候你手上没有示范数据，只有一个仿真器。它的物理计算不可微，撞墙那一刻也不提供任何梯度信息，反向传播在这里没有入口。常见的实现思路是把整个网络参数摊平成一个长向量，当成黑盒优化的搜索变量，用交叉熵方法（CEM）迭代：

def flatten(net): return np.concatenate([w.ravel() for w in net.W] + [b.ravel() for b in net.b]) def evaluate(net, env, episodes=3): """跑若干局，返回平均总回报""" scores = [] for ep in range(episodes): obs, done, total = env.reset(seed=1000 + ep), False, 0.0 while not done: action = net.forward(obs[None, :])[0] obs, reward, done = env.step(action) total += reward scores.append(total) return float(np.mean(scores)) def cem_train(env, net, iters=80, pop=32, elite=8, sigma0=0.5): mu = flatten(net) sigma = np.full_like(mu, sigma0) for it in range(iters): cand = mu + sigma * np.random.randn(pop, mu.size) # 采样一群参数 scores = np.array([evaluate(unflatten(net, cand[k]), env) for k in range(pop)]) idx = np.argsort(scores)[-elite:] # 取前 25% 精英 mu = cand[idx].mean(axis=0) # 精英均值作为新中心 sigma = cand[idx].std(axis=0) + 1e-3 # 精英离散度作为新步长 return mu

sigma是搜索半径，pop是每轮采样的候选个数，elite决定往哪些方向收敛。这个循环里没有任何反向传播，梯度由“谁得分高”隐式提供：精英参数的均值方向就是当前最优的上升方向。代价是样本效率低——每轮要真跑 32 局游戏，而反向传播一个 batch 就能拿到成千上万条状态的梯度。反过来说，如果仿真器够快，CEM 的优势是稳定、不需要调学习率、不怕梯度爆炸，对 865 个参数的小网络完全够用。

4.3 链式法则：反向传播里每一行对应一个偏导

不管训练信号来自示范数据还是适应度打分，只要有确定的输入输出对，反向传播就是同一套代码。下面这份实现把缓存和更新放在一起，配合train_step使用：

def backward(self, dout): n = len(self.W) # 输出层是 tanh，dL/dz = dL/da * (1 - a^2) g = dout * (1.0 - self.a[-1] ** 2) for i in reversed(range(n)): dW = self.a[i].T @ g # 本层权重梯度 = 输入^T · 误差 db = g.sum(axis=0, keepdims=True) # 偏置梯度 = 误差在 batch 维求和 if i > 0: # 误差回传给上一层，再穿过 ReLU 的开关 g = (g @ self.W[i].T) * (self.z[i - 1] > 0.0) self.W[i] -= self.lr * dW self.b[i] -= self.lr * db

g从输出层开始，含义始终是“损失对本层线性输出的偏导”。self.a[i].T @ g这一行是链式法则的矩阵形式：本层输入a[i]的每一维，都要乘上对应样本的误差再累加，所以是转置乘，得到(fan_in, fan_out)的形状，和权重的形状严格一致——形状对不上就是转置写反了，这是最常见的 bug。g @ self.W[i].T把误差反向投回上一层，再乘(self.z[i-1] > 0)这个 0/1 掩码，是因为 ReLU 在负区间导数为 0，误差传到这里就断了。

有一点顺序上的讲究：g回传用的是更新前的self.W[i]。如果先更新权重再算回传，同一层在前向时用的是旧权重、反向时用的是新权重，梯度就不一致了，网络在小学习率下还能凑合，学习率一大会直接震荡。这类问题在代码里看不出错，只能靠数值梯度校验兜底，第 6 章会给出具体做法。

5. 排查清单：神经网络学车最容易翻车的五个地方

训练一个能跑完一圈的网络，大部分时间不是花在设计上，而是花在“它为什么不动”上。下面这几条是按出现频率排的，每一条都能对应到具体的代码位置。

5.1 车在原地画龙，方向盘左右打死

现象：训练刚开始或者跑起来的头几秒，车头左右猛摆，像在抽搐，很快就怼上墙。

原因通常是两件事叠加。一是输入没归一化，射线距离是几百的像素值，第一层z巨大，输出层 tanh 长期贴在 ±1 附近，1 - tanh²趋近 0，梯度回传不到前层，网络在饱和区里瞎猜。二是 60Hz 的决策频率让相邻两帧输出几乎独立地抖，物理层把这些抖动放大成了摆动。

解决：所有特征先归一到 0~1 再喂网络，用layer_stats确认z.std在合理区间；决策降到 20Hz；对动作加一阶低通。三件事做完，画龙基本消失。如果还在摆，检查是不是把角速度当成了输入特征却没做缩放。

5.2 损失曲线很漂亮，一上路就撞墙

现象：离线验证集上损失从 0.4 降到 0.01，模型在实时仿真里跑不到半圈。

原因是分布不一致。示范数据里，人类开车大部分时间在赛道中间，网络从没见过“车头已经偏了 40 度、距离墙只剩 30 像素”的状态；而策略一偏离，就会进入这个没见过的区域，动作随机化，偏离更大，形成正反馈。这在模仿学习里是标准的协变量偏移问题，跟网络容量、训练轮数都没关系。

解决有两个方向：一是数据侧，用当前策略自己跑、人在关键帧纠正，把纠正样本补回训练集，反复几轮；二是输入侧，把横向偏移和航向误差显式加进特征，让网络在没见过的状态下至少有一个可靠的参照量。另外要核对训练和推理的归一化常量、物理步长、最大转向角是否完全一致，这类不一致造成的掉分和协变量偏移长得一模一样。

5.3 训练越久越傻：输出饱和与策略塌缩

现象：前 20 轮适应度上涨，之后缓慢下滑，最终网络对几乎所有状态都输出同一个值。

原因一般出在奖励设计上。如果奖励只统计“存活时间”，那么贴着墙蹭、慢慢挪也能拿高分，CEM 会很快收敛到这个局部最优；如果学习率偏大加上 tanh 饱和，参数会被推到一个所有输入都映射到 ±1 的死区，之后梯度几乎为零，想爬出来也爬不出来。

解决：奖励里加上前进距离和撞墙惩罚，或者直接用“跑完的总路程”当适应度；检查输出分布的标准差，正常应该在 0.1 以上，趋近 0 就说明塌缩了；CEM 的sigma别降太快，保留一点探索空间。这种参数被推到饱和区、看起来还在训练实际已经停住的状态，是最像玄学的一类问题，只能靠分布检查而不是损失曲线来发现。

5.4 评测分数忽高忽低，看不出有没有进步

现象：同一个模型跑三次，得分 120、450、80，改了个超参再跑，根本分不清是改动有效还是随机波动。

原因是评测的随机性没控制住：初始位姿随机、赛道扰动随机、决策与物理的步长比例不固定，每次都像换了个考试卷。

解决：固定一组评测种子，比如 20 个确定的初始位姿，每次评测都跑满这 20 个，报均值和中位数两个数；训练和评测使用同一套物理步长与决策频率；单次结论至少基于 5 局以上。做到这一步，很多“调参有效”的错觉会自己消失。

5.5 射线穿墙：贴墙行驶时传感器报“前方畅通”

现象：车贴着一段薄墙走，7 条射线全部显示远距离，下一秒直接穿墙或者撞上去。

原因是步进式射线采样，步长 10 像素，墙厚 2 像素，采样点全部落在墙的两侧。距离越远，漏检概率越高。

解决：换成第 2 章那份解析求交实现，射线-线段求交是精确的，不存在漏检；如果坚持用采样，步长要压到 1 像素以下，计算量涨十倍，而且高速行驶时仍然可能漏。这一条修起来最便宜，但不修的话，前面所有训练都建立在错误的感知上。

6. 设计取舍：手写反向传播值不值，以及怎么验证它真的在学

从零写一个 865 参数的小网络，最大的收益不是省了几个依赖，而是每个数字都能对齐。用框架时，形状错了框架会帮你广播，梯度算错了损失照样下降，你只能看到一个最终分数；手写时，dW的形状和W不一样，立刻就报错。这份“可验证性”在调试期价值极高，尤其是你要判断“是网络不行还是感知不行”的时候，能逐层打印激活和梯度，比任何可视化工具都直接。

代价也很明确：手写版本没有自动微分，没有 GPU 加速，层数一多就得自己维护缓存和反向规则。所以取舍的界线是任务复杂度。9 维输入、1 维输出、不到一千个参数，全连接网络加手写反向传播完全够，代码短到可以一晚上读完。一旦输入换成俯视图像，全连接层就废了——它对像素的空间结构一无所知，同样一辆车平移几个像素，在它眼里就是完全不同的输入，只有卷积的平移等变性才能把参数量压下来。同理，如果要做带记忆的决策（比如根据前几帧判断前车意图），就得堆帧或者上循环结构，手写反向传播的复杂度会陡增，那时候引入框架是合理的。

验证反向传播有没有写对，最实用的不是看损失下降，而是两个测试。第一个是数值梯度校验：取一小批固定样本，对某个权重加减小量eps，用差分估计梯度，和反向传播算出来的对比，相对误差应该在1e-6量级。第二个更狠，叫单步过拟合：只取 8 条样本，把学习率调大，训练到损失小于1e-3。如果做不到，说明反向传播一定有 bug，因为一个能拟合 8 条样本的网络连这点容量都不缺。这两个测试我都会在改动网络结构后重跑一遍，比重新训练一晚上再回来看结果省太多时间。

最后说一个只有踩过才知道的取舍：感知层的特征设计和网络结构是一体的。射线数量从 7 条加到 15 条，输入维度变了，第一层的初始化尺度、归一化常量、甚至隐藏层宽度都得跟着调；而如果把横向偏移这类几何量显式喂进去，网络反而可以更小。我一开始迷信“端到端”，把所有能拿到的原始量都塞进输入，结果训练三轮就过拟合到某段赛道的曲率上，换条路直接不会开。从那以后我每次加特征前都强制问一句：这个量是不是网络自己能推出来的、推出来要花多少容量；也强制在改完结构后跑一遍单步过拟合和数值梯度校验，两个都过了才让它上赛道。希望这些踩坑记录能帮你少走几段弯路，剩下那些只有自己跑起来才会遇到的细节，就留给你在那几百行代码里慢慢挖了。

本文还有配套的精品资源，点击获取