DQN车间排产实战：马尔可夫建模、奖励塑形与训练排查

简介：这套代码面向车间排产调度优化，聚焦DQN算法在动态生产环境中的策略学习与调度决策，适合强化学习学习者、运筹优化研究人员及工业工程师参考复现。资源包共3个Python文件，整体约5KB，体量轻巧却结构完整，分别对应算法主体、gym风格调度环境建模和训练评估运行入口，便于按模块研读与二次改造。已有848人学习，具备一定关注度。代码围绕深度神经网络近似Q值、经验回放与目标网络等关键技术展开，并通过状态空间、动作空间和奖励函数搭建排产模拟环境；读者可据此理解如何将生产顺序优化转化为强化学习问题，观察训练、评估与可视化流程，借鉴环境封装和参数更新思路，用于课程实验、课题原型或调度策略对比测试。

1. 排产不是排序：为什么 DQN 能把车间调度当成一场马尔可夫决策

车间排产的教科书印象是「把一堆工序排个序」，真上手做过的人都知道远不止于此。机床不能同时干两件活、同一工件的工序有硬性先后、换型要额外时间，这些约束凑在一起，解空间随工序数指数级膨胀，是标准的 NP-hard 问题。更麻烦的是求解方式本身：派工规则毫秒级出结果却只看眼前一步，元启发式能出好解但每来一个新订单就得整锅重跑。深度强化学习里的 DQN 切进来的角度很反直觉——它不追求一次算出全局最优，而是把「某台机床空出来的那一刻该选哪个工序」当成一个马尔可夫决策过程，训练一个能在毫秒级给出决策的策略网络。这套建模约定怎么落到一个 gym 环境里、贝尔曼更新为什么能稳定下来、奖励怎么和最大完工时间对齐，才是这份代码真正值得逐行读的地方。

2. 把工序表塞进 gym：状态、动作与转移的概率化建模

强化学习的第一步几乎从不写在算法论文里，而是写在一个env.py里：怎么把一个静态的工艺路线表，变成能一步步推进、能返回奖励、能被采样成批量的环境对象。这一步错了，后面调任何超参都是在给错误的地基刷漆。

2.1 状态编码：从工艺路线表到定长张量

原始数据长这样：若干个工件，每个工件有一串有序工序，每道工序绑定一台机床和一个加工时长。它是变长的、带结构的，而神经网络的输入必须是定长数值张量。常见的三种编码思路，取舍差别很大。

第一种是把整个车间压成一个全局向量，比如每台机床的空闲时间、每个工件的剩余工作量，维度是机床数 + 工件数。这种编码维度小、训练快，缺点是网络看不到单道工序粒度的信息，只能学出「大概往哪个方向偏」的粗策略，遇到同型机床多、工序粒度细的车间就明显吃亏。

第二种是析取图表示，把每道工序当节点，工件内的先后关系画成实线弧，同一机床上待定先后关系的画成虚线弧，整体交给图神经网络。表达力最强，能把约束结构完整喂进模型，代价是实现复杂度上一个量级，训练也更吃数据。

这份代码走的是第三条路：每道工序一行特征，构成(工序总数 N, 特征数 F)的矩阵，再拼一个全局向量。每行通常这么填：

全局向量一般放当前仿真时刻、已完工工件数占比、机床平均利用率、剩余工序总数这几个标量。它们不针对任何具体工序，但对判断「现在处于排产的早段还是收尾段」很关键——同一道长工序放在开工初期和收尾阶段，代价完全不同。

提示：F一旦定死，换一个特征就要重训。把特征抽取单独写成一个feature_fn(env) -> np.ndarray函数，改编码时只动这一处，比散落在step里到处赋值省事得多。

2.2 动作空间与合法性掩码：排产里一半动作是废的

动作空间有两种主流设计，选错方向后面全是弯路。

派工规则型：动作是选一条规则，比如最短加工时间优先、最长加工时间优先、最早完工优先、临界比优先。动作维度只有 4 到 6，网络小、训练快，但表达力被规则集锁死——网络最多只能学出「在某状态下该用哪条规则」，学不出规则集合之外的决策。

工序选择型：动作是「从当前所有可开工工序里挑一个」，动作维度等于工序总数。表达力完整，代价是动作维度随问题规模线性增长，而且绝大多数动作在任意时刻都是非法的——某道工序的前序没完成、或者它所在的机床正在加工别的活，这个动作就不能选。

这份代码用的是后者，于是动作掩码成了不可绕开的一环。它的作用是：在网络输出 Q 值之后、做 argmax 之前，把所有非法动作的 Q 值强行压到负无穷。缺了这一步，网络会很快学到一个「偷懒解」：反复选择已完成的工序，因为这些动作在多数实现里不改变状态，网络误以为拿到了零成本的稳定回报。这个坑非常隐蔽，因为损失函数照样在下降，只是策略学歪了。

import numpy as np import torch # 每个状态都要重新算一遍：哪些工序此刻真的可以开工 def build_mask(env): mask = np.zeros(env.n_ops, dtype=np.int8) for idx, (job_id, op_idx) in enumerate(env.op_index): # 已完工的工序不再作为候选 if env.op_done[idx]: continue # 工件的上一道工序必须已经结束，本工序才具备开工资格 if op_idx > 0 and not env.op_done[env.op_index.index((job_id, op_idx - 1))]: continue mask[idx] = 1 return mask def masked_argmax(q_values: torch.Tensor, mask: torch.Tensor) -> int: # 非法动作置为 -1e9 而不是 -inf，避免 softmax/梯度里出现 NaN masked_q = q_values.masked_fill(mask == 0, -1e9) return int(masked_q.argmax().item())

build_mask里判断的是「工件前序是否完成」，注意这里刻意不检查机床是否空闲。原因是排产决策的时机点应当定在「工件层面有工序解锁」而不是「机床空出来」，前者在一段仿真里产生的决策次数是固定的N次，后者会让决策次数依赖于策略本身的表现，episode 长度浮动，批量采样和回报计算都会变得别扭。masked_argmax里用-1e9而不是-inf是血泪经验：-inf一旦参与后续的gather或差分运算，很容易冒出nan，而nan在损失里会静默污染整个 batch 的参数。

2.3 step 的契约：一次决策如何推进整个车间

step(action)是整个环境的心脏，它要做四件事：找到动作对应工序的最早可开工时刻、更新机床和工件的状态、算出这一跳的奖励、判断 episode 是否结束。

def step(self, action): assert self.mask[action] == 1, f"收到非法动作 {action}" job_id, op_idx = self.op_index[action] mac, dur = self.jobs[job_id][op_idx] # 开工时刻 = max(机床空出来的时刻, 工件上一道工序完工的时刻) start = max(self.mac_free[mac], self.job_ready[job_id]) end = start + dur # 推进状态：机床下一次空闲、工件下一道可开工时刻 self.mac_free[mac] = end self.job_ready[job_id] = end self.op_done[action] = True # 工件全部工序完成时，记录它的完工时间 if op_idx == len(self.jobs[job_id]) - 1: self.job_finish[job_id] = end self.n_done_jobs += 1 # 势函数奖励：已完工工件完工时间均值的负值，越接近终点越接近 0 phi_new = -float(np.sum(self.job_finish)) / self.n_jobs reward = (phi_new - self.phi_prev) * self.reward_scale self.phi_prev = phi_new done = self.n_done_jobs == self.n_jobs if done: # 收尾时一次性把真实的 -C_max 补进奖励，保证回报与目标同向 reward += -float(max(self.job_finish)) * self.reward_scale self.mask = build_mask(self) return self._obs(), reward, done, {"makespan": max(self.job_finish) if done else None}

start那一行是整个环境最本质的一行代码，它同时表达了两种等待：机床等工件、工件等机床。self.mac_free[mac]记的是这台机床处理完上一道活的时间，self.job_ready[job_id]记的是这个工件上一道工序完工的时间，取较晚者就是这道工序真正能开始的时刻。排产的「插入式」和「非插入式」区别，很多时候就体现在这里要不要额外检查机床空档——这份代码是非插入式的，机床一旦开工会走完整段时长，实现简单、也更贴合多数离散制造现场的实际约束。

reward_scale这个参数不是为了好看，它决定了 Q 值的量级。如果让奖励直接等于「负的完工时间增量」，一个 500 道工序的算例里单步奖励可能到 -50，折扣累积几十步后 Q 值上到几百，配合较大的学习率非常容易发散。把奖励缩放到[-1, 0]附近，网络输出的 Q 值天然落在合理区间，学习率、梯度裁剪阈值都能用一套通用配置。收尾时补的那笔-C_max也值得留意：势函数奖励在同策略下不改变最优解，但它对「最后一台机床拖了多久」这件事的反应是迟钝的，末尾显式加一次真实目标值，能让网络对尾部决策更敏感。

3. DQN 的贝尔曼骨架：目标网络与经验回放究竟在压制什么

环境搭好之后，算法这一层看起来全是熟面孔：Q 网络、目标网络、经验回放、ε-greedy。熟面孔不等于理解，尤其在排产这种「episode 长、单步回报小、状态高度结构化」的场景下，每个组件压制的具体问题都不一样。

3.1 Q 值与 TD 误差：一次决策的收益怎么算

Q 函数回答的问题很具体：在状态 s 下选动作 a，从这个选择开始、按当前策略一直走到 episode 结束，能拿到的折扣累计奖励期望是多少。写成式子就是贝尔曼最优方程Q*(s,a) = r + γ·max_a' Q*(s',a')。

问题在于等式右边也含未知的 Q*，所以只能迭代去逼近。DQN 的做法是拿「一步真实奖励 + 下一状态的 bootstrap 估值」当作监督信号，让网络去拟合它：

q_sa = q_net(obs).gather(1, act.unsqueeze(1)).squeeze(1) with torch.no_grad(): q_next = target_net(obs_next).squeeze(-1) # (B, N) q_next = q_next.masked_fill(next_mask == 0, -1e9) # 下一状态的非法动作不参与 max a_star = q_next.argmax(dim=1) # Double DQN：用在线网选动作 q_bootstrap = q_next.gather(1, a_star.unsqueeze(1)).squeeze(1) q_target = reward + gamma * (1.0 - done) * q_bootstrap loss = F.smooth_l1_loss(q_sa, q_target)

这里有两处和排产强相关的细节。

一处是masked_fill出现在目标值的计算里，而不仅仅在动作选择时。如果下一状态里存在非法动作而它们的 Q 值恰好被高估，max就会优先选中这些不存在的动作，把虚高的估值一路回传，整个价值函数会被系统性抬高。在动作空间里非法比例越高的场景，这个错误的放大倍数越大，排产恰好就是这种场景。

另一处是a_star用在线网络选出、再用目标网络取值，这是 Double DQN 的写法。原始 DQN 用同一个网络既选动作又估价值，max操作天然偏向噪声大的动作，过估计是结构性的而非偶然的。换成 Double 之后，选动作和估值分离，过估计大幅缓解。在奖励信号本来就不算密集的排产任务里，过估计的后果不是「收敛慢一点」，而是网络长期偏好少数几个看起来「运气好」的动作，策略多样性直接塌掉。

F.smooth_l1_loss而非 MSE 也不是随手选的。排产里不同算例的完工时间量级差别很大，落进回放池的样本里难免混着量级悬殊的 TD 误差，Huber 损失在误差较大时退化成线性，相当于自动做了一次梯度限幅，这比手工调clip_grad_norm_更平滑。

3.2 目标网络：给追捕者一个慢半拍的靶子

如果去掉目标网络，让q_target也用在线网络算，会立刻遇到一个问题：监督信号的标签本身随参数更新而移动。每更新一次权重，右侧目标值就跟着变，网络在追一个永远在跑的目标，这在函数逼近下极易发散，尤其在特征之间存在强相关时。

目标网络的做法是维护一份参数的旧副本，隔若干个梯度步整体同步一次，或者每一步只做一次小幅度软更新θ⁻ ← τθ + (1-τ)θ⁻。这样在两次同步之间的窗口里，目标值相对静止，回归问题恢复成普通的监督学习形态。

class QNet(nn.Module): """每个工序独立打分，输出维度恒为 1，天然支持变工位数""" def __init__(self, feat_dim, glob_dim, hidden=128): super().__init__() self.op_enc = nn.Sequential( nn.Linear(feat_dim, hidden), nn.ReLU(), nn.Linear(hidden, hidden), nn.ReLU(), ) self.head = nn.Sequential( nn.Linear(hidden + glob_dim, hidden), nn.ReLU(), nn.Linear(hidden, 1), ) def forward(self, ops, glob): h = self.op_enc(ops) # (B, N, H) g = glob.unsqueeze(1).expand(-1, h.size(1), -1) # (B, N, G) return self.head(torch.cat([h, g], dim=-1)) # (B, N, 1) def soft_update(online: nn.Module, target: nn.Module, tau: float = 0.005): for p_o, p_t in zip(online.parameters(), target.parameters()): p_t.data.mul_(1.0 - tau).add_(p_o.data, alpha=tau)

这个网络结构本身就是一处设计取舍。它不对「动作」做 one-hot 输入，而是每道工序独立算一个分数，输出维度恒为 1。好处是动作维度不再被写进网络结构——同一个网络，只要喂不同的N，就能处理 20 道工序和 200 道工序的算例。坏处是工序之间的横向比较完全交给最后的argmax，网络本身不做任何 pair-wise 比较，如果你的状态特征里缺少「相对优先级」信息，它会表现得很平庸。相比之下，把整个状态摊平成一维向量、直接输出N维 Q 值的写法在网络表达能力上略强，但一旦换规模就得换网络。

tau取值要结合 episode 长度看。排产 episode 动辄几百步，梯度步数多、目标变化本来就慢，软更新系数取0.005到0.01之间比较合适；如果取 0.1，目标网络几乎等于在线网络，防发散的作用就被稀释了。

3.3 经验回放：打破样本之间天然的时序相关

排产环境有个很讨厌的特性：相邻状态高度相似。一次决策只推进一道工序，前后两个状态在特征矩阵上可能只差几个数位，而 DQN 用的是随机梯度下降，连续喂这种强相关样本会让梯度方向在几步内高度一致，网络表现为「朝一个方向猛冲，然后被下一个完全不同的算例拉回来」。

回放池解决的就是这个。把转移(s, a, r, s', done, mask, next_mask)存起来，训练时均匀采样一个批量。这样一来同一个 batch 里既有 episode 开头机床空闲、加工时段和收尾阶段的样本，梯度方向被平均掉，稳定性明显好转。

class ReplayBuffer: def __init__(self, capacity: int): self.capacity = capacity self.buf = [] self.ptr = 0 def push(self, transition): if len(self.buf) < self.capacity: self.buf.append(transition) # 未满时追加 else: self.buf[self.ptr] = transition # 满了之后环形覆盖最老的样本 self.ptr = (self.ptr + 1) % self.capacity def sample(self, batch_size: int): idx = np.random.randint(0, len(self.buf), size=batch_size) batch = [self.buf[i] for i in idx] return collate(batch) # 把变长的 mask 张量堆成定长，见下文说明

掩码必须跟状态一起存。这一点很容易漏：训练时要用「当前动作的掩码」去核对q_sa与q_target的一致性，用「下一状态的掩码」去算 bootstrap，两个掩码都不是从状态张量里能反推出来的，只能显式存储。漏存的后果是训练用的掩码和采样时的掩码对不上，损失函数在非法动作上给出虚假的强梯度。

collate这一步也不是免费的。如果不同算例的工序数不同，把多个样本堆成 batch 需要 padding 到最大长度，同时把 padding 位置的掩码置零，否则网络会把这些位置当作合法候选去打分。工程上更省事的做法是固定一个 episode 只用单一算例，批量内N相同；跨算例的泛化交给「同一个网络跑不同算例」来验证，而不是塞进同一个 batch。两种做法各有代价，前者要求你在采样时按N分组，后者要求网络对变长输入真正鲁棒。

4. 奖励与完工时间的对齐：稀疏目标怎么不把人饿死

强化学习项目里最容易翻车的地方，八成不在算法，在奖励。排产的目标是让最大完工时间C_max尽可能小，而这个值只有 episode 结束时才真正确定。如果严格按目标给奖励，前面几百步全是 0，只有最后一步有信号，网络基本学不动——这就是稀疏奖励的经典困境。

4.1 奖励塑形：三种能用的做法

做法一，终点型。每步奖励 0，结束时给-C_max。最忠实于目标，但样本效率极低，除非算例特别小，否则不建议直接用。

做法二，增量型。每完成一道工序，奖励-(end - start)或者-dur。信号变密了，但它引导的是「让每道工序尽快完工」，不等于「让整体尽早完工」。一个反例：某道长工序提前做完了，但它占用的机床恰好是另一条关键路径上等着的那台，整体完工时间反而被拖长。增量型奖励会给出正向反馈，把策略往错的方向带。

做法三，势函数型。定义Φ(s)为衡量「离结束还有多远」的标量，令r = Φ(s') - Φ(s)。这样构造的塑形奖励在理论上不改变最优策略——你给了网络一个更密的梯度，但没让它有机会去「刷分」。这是这份代码选的路子。

Φ的常见取法有两种：一种是「已完成工序总加工时长 / 全局总加工时长」，直观但忽略了关键路径；另一种是「已完工工件的完工时间均值的负值」，也就是上面step里那段。后者的好处是它对尾部工件尤其敏感——均值不会被少数几个早完工的工件拉低太多，拖尾一旦发生，Φ立刻变差。

def compute_potential(env) -> float: # 只有全部工序完成的工件才计入，未完成工件按已完成部分折算， # 避免网络学会"抢着把简单工件做完刷势函数" total, weight = 0.0, 0.0 for j in range(env.n_jobs): if env.job_finish[j] is not None: total += env.job_finish[j] * 1.0 weight += 1.0 else: done_ratio = env.job_progress[j] / len(env.jobs[j]) total += env.job_ready[j] * done_ratio weight += done_ratio return -(total / max(weight, 1e-6))

如果只用「已完成工件」，势函数在一个工件刚完工的瞬间会跳变，网络会学出一种投机行为：集中资源把一个工件从头做到尾，迅速把势函数推上去，然后再处理别的。加上未完成工件的折算项，相当于把「部分完成」的价值也计进势函数，投机空间明显收窄。这是个典型的「理论上是势函数，工程上还得再拧一下」的例子。

4.2 折扣因子与完工时间之间的隐藏耦合

γ在小算例里常被当作可有可无的超参，在排产里它其实是个业务参数。

排产 episode 长度等于工序总数N。如果γ = 0.99，那么第N步的奖励传回第 1 步时权重是0.99^N。N = 200时这个数约等于 0.134，也就是说尾部决策对开头的影响力只剩一成多。网络会偏向「先把手头这些活干得漂亮点」，对远期后果不敏感。

γ = 1.0可以避免这个衰减，但会带来另一个问题：Q 值量级随 episode 长度线性增长，网络输出层的数值范围被拉大，配合塑形奖励容易不稳。折中的常见做法是γ取0.98到0.995，同时把奖励缩放到[-1, 0]，让 Q 值总量落在几百以内。

还有一个容易被忽略的细节：γ与塑形奖励组合时，Φ的尺度必须和原始奖励同量级。如果Φ输出的值域是[-5000, 0]，而原始奖励在[-1, 0]，那么塑形项会完全主导梯度，网络实际上在拟合势函数而不是在优化完工时间。上面代码里乘的reward_scale，本职就是干这个的。

4.3 评估口径：别拿训练曲线当效果

训练奖励在涨，不等价于排产效果在变好。至少有三个地方会让这两件事脱钩。

第一，训练时走的是 ε-greedy，带随机探索；评估必须关掉探索、纯贪心。用同一个带噪声的策略去算 makespan，数字会天然偏差且不可复现。

第二，训练算例和评估算例要分开。训练集用固定的一批工序表，评估用另一批同分布但不同随机种子的表，才看得出泛化。如果两边是同一批，模型很可能在记忆而不是在学习。

第三，必须和派工规则对比才有意义。任何排产算法的最低门槛是打赢「最短加工时间优先」这类朴素规则，如果 DQN 的C_max只是打平甚至更差，那它唯一的价值就是推理快；而这个价值在工序数很少时又不足以抵消训练成本。评估表至少要有三行：SPT 基线、DQN 贪心结果、一个近优解参考（小规模算例可用精确求解器跑出来，大规模可以用长时间运行的元启发式近似）。

5. 训练排查：DQN 在排产环境里翻车的五个高频现场

下面这五条基本覆盖了从环境写完到模型勉强能用这段时间里，八成会撞上的问题。每条按「看到什么」「为什么」「怎么改」组织。

5.1 现象：奖励曲线纹丝不动，Q 值却一路疯涨

原因：非法动作没有在目标值计算里被屏蔽。下一状态里那些本不该被选的动作 Q 值偏高，max每次都挑它们，虚高的估值被反复回传，价值函数整体被抬起来，和真实回报脱钩。因为损失函数是在拟合这个虚高目标，loss 反而看起来在下降，极其误导。

解决：检查q_target的计算路径，确保masked_fill作用在q_next上、且在argmax和gather之前。同时确认存进回放池的next_mask和训练时用的next_mask是同一份，不是重新算出来的。

5.2 现象：训练很早就不动了，策略看起来像某条固定派工规则

原因：探索不足。ε 衰减太快，或者 ε 的下限设得太低，网络在还没见过足够多状态的时候就锁死了输出。另一种情况是回放池容量小于单轮训练样本量，早期样本被反复重采样，网络在几十个状态上过拟合。

解决：ε 从 1.0 线性衰减到 0.05，衰减跨度覆盖至少十万步；回放池容量设为单 episode 样本数的十倍以上。判断标准是看策略的动作分布熵，如果熵在训练早期就掉到接近 0，基本可以确定是探索出了问题。

5.3 现象：loss 突然跳到 nan，之后再也恢复不了

原因：三个常见来源。一是masked_fill用了-inf，参与gather后产生 nan；二是奖励没缩放，q_target数值过大，Huber 损失的梯度在极端误差下依然能推爆参数；三是学习率配得偏大，加上软更新系数tau也偏大，两处同时放松导致正反馈。

解决：掩码统一用-1e9；奖励乘reward_scale缩到[-1, 0]；加clip_grad_norm_(params, 10)兜底；tau先降到0.005再逐步试。排查顺序建议从掩码开始，因为它的表现最像「随机出现」的 nan。

5.4 现象：训练环境跑得很好，换一批算例就崩

原因：状态特征里的某个量用了绝对刻度，比如直接用「加工时长」的原始值，而不同算例的时长分布差别很大。网络学到的是「时长超过 40 的工序优先」，而不是「相对这台机床平均时长偏长的工序优先」，一换分布就失效。

解决：所有时间类特征做相对化，除以该算例的总加工时长或该机床的平均工序时长。工序数不同的算例还要注意掩码的 padding 位置不能参与打分。评估时固定随机种子，跑至少 30 个算例取均值，单个算例的结果没有参考价值。

5.5 现象：训练集上 makespan 比 SPT 还差

原因：塑形奖励和目标错位，或者势函数尺度远大于原始奖励，网络实际在优化势函数而不是完工时间。还有一种可能：评估时忘了切到纯贪心，ε 还开着，随机动作直接毁掉 makespan。

解决：先打印一批 episode 里势函数项和终点项各自的累计贡献，看哪一项占了绝对多数。如果塑形项占九成以上，说明reward_scale没起作用或者Φ尺度失控。然后确认评估函数里没有random.random() < eps这条分支。最后对比训练集上的贪心 makespan 与训练过程中的平均回报，两者如果一个降一个不降，说明奖励设计的引导方向确实偏了。

6. 设计取舍：DQN 到底该出现在排产系统的哪一层

把 DQN 用在排产上，最需要想清楚的不是网络结构，是它在这个系统里的位置。DQN 属于 value-based 方法，天然只处理离散动作，而排产动作本来就是离散的，这一点对得上。但它的 Q 值是对每个动作单独估的，动作数随工序数线性增长，一旦工序数上千，输出层的计算量和每个动作分到的样本量都会成问题。这也是为什么代码里把网络写成「每道工序独立打分、输出恒为 1」——它绕开了固定动作维度的限制，但没绕开「动作越多、每个动作的样本越稀」这个根本矛盾。

对比一下另外两条路。策略梯度方法直接输出动作分布，天然支持变长动作空间，配合指针网络能处理工序数不固定的算例，代价是方差大、样本效率低于 DQN。派工规则零训练成本、完全可解释、在稳定生产环境下表现其实相当能打，它的弱点是短视——每一步只看当前最紧的那台机床，看不到三步之后的连锁反应。DQN 真正的价值区间在中间：环境有扰动（插单、设备故障、返工），规则调不过来，元启发式又来不及重算的时候，一个毫秒级出决策、且能感知远期后果的策略就有意义了。

比较务实的落地形态通常不是「DQN 全权决策」，而是两级结构：底层保留规则调度做安全兜底，DQN 只在它的候选集上做重排序，或者用规则生成的示范轨迹先做模仿学习预热，再上强化学习微调。这样即使网络训崩了，产线也不会停。

验证方法我习惯固定成一套：同一批算例（训练集之外）、同一个随机种子、每个方法跑 20 次取均值和标准差，横向比 SPT、LPT、ECT 三条规则，纵向比一个跑了很久的元启发式当作参考上界。判断一个 DQN 模型值不值得留，看的不是它比规则好多少，而是「好出来的那部分能不能覆盖训练和调参的成本」，以及「换一批分布略有差异的算例之后，这个优势还在不在」。后者掉得越快，说明模型学到的越是某个特定分布的特征，而不是排产这件事本身的规律。

注意：跨规模泛化一定要单独测。用 50 工序训出来的网络直接跑 200 工序，即使网络结构支持变长输入，表现也经常断崖式下跌，这不是 bug，是状态特征的相对化没做到位或者训练分布压根没覆盖这个规模。

从那以后我每次动奖励函数或者状态特征，都会强制先跑一遍「规则基线 + 小算例精确解」的对照，确认改动之后 gap 是缩小而不是被势函数项掩盖了。这套动作比看训练曲线啰嗦，但它能把「模型在学」和「模型在自欺」这两件事分开。希望帮到你。

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