从蒙特卡洛到时序差分：无模型强化学习核心算法解析与实践

🚀 30+款热门AI模型一站整合，DeepSeek/GLM/Qwen 随心用，限时 5 折。 👉 点击领海量免费额度

如果你是一名生物、医学或生命科学领域的学生或研究者，对人工智能充满好奇，但面对强化学习（Reinforcement Learning, RL）中“无模型”（Model-Free）的算法感到无从下手，那么这篇文章正是为你准备的。在之前的文章中，我们可能已经了解了强化学习的基本框架（智能体、环境、状态、动作、奖励）和基于动态规划的经典方法。然而，现实世界中的许多问题，比如药物分子设计、蛋白质折叠模拟、生态种群动态分析，其内在的“环境模型”（即状态转移概率和奖励函数）往往是未知或极其复杂的。这时，我们就需要转向蒙特卡洛方法和时序差分算法这类强大的“无模型”学习器。

本文将带你从生物学的直觉出发，彻底搞懂这两种核心算法。我们不会堆砌复杂的数学公式，而是通过类比实验采样、条件反射等生物学概念，并结合完整的Python代码示例，让你亲手实现算法，直观看到学习过程。无论你是想将RL用于分析实验数据、优化实验流程，还是仅仅想拓宽计算生物学的研究工具库，掌握蒙特卡洛和时序差分都是关键一步。

1. 从“有模型”到“无模型”：为什么我们需要新方法？

在深入算法之前，我们先明确一个根本问题：什么是“无模型”（Model-Free）？为什么它对我们（尤其是生物背景的研究者）如此重要？

1.1 “有模型”学习的困境

在经典的动态规划方法（如策略迭代、价值迭代）中，我们假设智能体完全知晓环境的“内部运作机制”，即：

• 状态转移概率 P(s' | s, a)：在状态s下采取动作a后，转移到状态s‘的概率。
• 奖励函数 R(s, a, s')：在完成上述转移后，能获得多少奖励。

这就像你作为一个生物学家，已经拥有了一个细胞代谢通路的完整数学模型，知道每一个生化反应的确切速率和产物。你可以在这个“模型”上进行精确的计算和规划。

然而，绝大多数真实的生物系统是“黑箱”：

• 你不知道给细胞施加一种新药物后，其内部基因表达网络会如何精确演变（状态转移未知）。
• 你不知道某种突变对生物体适应度的具体影响是多少（奖励函数未知）。
• 你只能通过做实验、观察结果来获取数据。

1.2 “无模型”学习的核心思想

“无模型”强化学习放弃了事先知晓完整环境模型的奢望。它的哲学是：通过与环境直接交互产生的经验（样本）来学习。这完美契合了科学研究的实证主义精神——从观察中学习。

两种最主要的“无模型”学习方法就是：

• 蒙特卡洛方法：从完整的实验回合（Episode）中学习，必须等到实验结束才知道总结果，然后回头总结。
• 时序差分方法：在实验进行过程中就实时学习，根据相邻两步的观察结果来调整认知。

接下来，我们将分别深入这两种方法，并用生物学实验的视角来理解它们。

2. 环境准备与问题定义

在开始编码前，我们需要设定一个简单的实验环境。为了避免陷入复杂环境的细节，我们使用一个经典的网格世界问题，并将其类比为一个简单的“觅食”或“寻找目标”的生物学实验场景。

2.1 环境设置：网格世界

假设我们有一个4x4的网格（GridWorld），可以把它想象成一个简单的培养皿或实验场地。

• 状态：网格中的每一个格子，共16个状态。用坐标(行, 列)表示，例如(0,0)是左上角起点，(3,3)是右下角目标。
• 动作：智能体（可以想象为一个简单的微生物或实验动物）可以向上、下、左、右移动。
• 奖励：除了到达目标格子(3,3)获得+1的奖励外，在其他任何格子移动都获得-0.04的微小惩罚（这可以类比为在觅食过程中消耗的能量或时间成本）。如果撞墙（试图移出网格），则停留在原地并承受同样的惩罚。
• 目标：学习一个策略，使得从任何起点出发，都能高效地找到目标，最大化累计奖励。

2.2 Python环境与版本说明

我们将使用纯Python和基础库来实现算法，确保清晰易懂。

# 所需库：仅需标准库 import numpy as np import random from collections import defaultdict import matplotlib.pyplot as plt # 用于可视化，可选 # 版本建议：Python 3.6+， NumPy 1.19+ # 本文代码重点在于算法逻辑，对版本要求不严格，核心逻辑可移植。

3. 蒙特卡洛方法：从完整实验报告中学习

蒙特卡洛方法的核心思想源于统计学：通过大量随机采样的结果来估计一个未知量。在生物学中，这就像重复进行同一个实验很多次，然后根据所有实验的结果来估计某个生理参数的平均值。

3.1 算法核心：回报与平均

在蒙特卡洛强化学习中，我们通过运行多个完整的“实验回合”（Episode，从开始到结束的一次尝试）来学习状态或状态-动作对的价值。

关键步骤：

1. 生成回合：使用当前策略（可以是随机策略）让智能体与环境交互，直到回合终止（找到目标或达到最大步数）。记录下这个回合中经历的所有状态、动作和奖励序列。Episode: S0, A0, R1, S1, A1, R2, S2, A2, R3, ..., ST (终止)
2. 计算回报：从回合中的每一个时间点回头看，计算从该时刻开始到回合结束所获得的累计奖励（Return）。折扣因子γ（gamma）使得远期奖励价值降低。G_t = R_{t+1} + γ * R_{t+2} + γ^2 * R_{t+3} + ...
3. 更新价值：对于该回合中出现的每一个状态（或状态-动作对），用本次计算得到的回报G_t去更新其价值估计。通常采用增量平均的方式：新估计值 = 旧估计值 + (1/N) * (回报 - 旧估计值)其中N是该状态被访问的次数。

3.2 首次访问 vs. 每次访问

• 首次访问蒙特卡洛：在一个回合中，只对第一次出现的某个状态S用其回报G来更新价值。这能保证每个样本是独立同分布的估计。
• 每次访问蒙特卡洛：在一个回合中，每次出现状态S都用其对应的回报G来更新价值。虽然样本相关性更强，但在实践中也常能工作。

我们通常使用首次访问蒙特卡洛，因为它理论性质更好，更贴近于估计状态在策略下的“平均首次回报”。

3.3 代码实现：蒙特卡洛策略评估

让我们先实现蒙特卡洛方法用于评估一个给定策略的价值函数。

class GridWorld: """简单的4x4网格世界环境""" def __init__(self): self.rows = 4 self.cols = 4 self.state = (0, 0) # 起始状态 self.goal = (3, 3) # 终止状态 self.actions = ['up', 'down', 'left', 'right'] self.action_map = {'up': (-1, 0), 'down': (1, 0), 'left': (0, -1), 'right': (0, 1)} def reset(self): """重置环境到起始状态""" self.state = (0, 0) return self.state def step(self, action): """执行一个动作，返回(下一个状态, 奖励, 是否终止)""" move = self.action_map[action] next_state = (self.state[0] + move[0], self.state[1] + move[1]) # 检查边界 if not (0 <= next_state[0] < self.rows and 0 <= next_state[1] < self.cols): next_state = self.state # 撞墙，留在原地 self.state = next_state # 计算奖励 if next_state == self.goal: reward = 1.0 done = True else: reward = -0.04 # 每一步的小惩罚 done = False return next_state, reward, done def random_policy(state): """一个简单的随机策略，在所有状态下均匀选择四个动作""" return random.choice(['up', 'down', 'left', 'right']) def generate_episode(env, policy, max_steps=100): """使用给定策略生成一个完整回合的数据""" episode = [] state = env.reset() for t in range(max_steps): action = policy(state) next_state, reward, done = env.step(action) episode.append((state, action, reward)) if done: break state = next_state return episode def mc_prediction_first_visit(env, policy, num_episodes, gamma=0.9): """ 首次访问蒙特卡洛策略评估。 评估给定策略下的状态价值函数 V(s)。 """ # 初始化价值函数和访问计数器 V = defaultdict(float) returns_sum = defaultdict(float) returns_count = defaultdict(int) for episode_i in range(num_episodes): # 生成一个回合 episode = generate_episode(env, policy) states_in_episode = [step[0] for step in episode] rewards = [step[2] for step in episode] G = 0 # 回报 # 从后向前遍历回合 for t in reversed(range(len(episode))): state_t = states_in_episode[t] reward_t_plus_1 = rewards[t] G = gamma * G + reward_t_plus_1 # 首次访问检查：如果state_t在本回合中更早的时间点没出现过 if state_t not in states_in_episode[:t]: returns_sum[state_t] += G returns_count[state_t] += 1 V[state_t] = returns_sum[state_t] / returns_count[state_t] return V # 运行蒙特卡洛评估 env = GridWorld() num_episodes = 5000 V_mc = mc_prediction_first_visit(env, random_policy, num_episodes, gamma=0.9) # 打印部分状态的价值 print("蒙特卡洛评估结果（随机策略下的状态价值）：") for i in range(4): for j in range(4): state = (i, j) print(f"V({state}) = {V_mc.get(state, 0.0):.3f}", end='\t') print()

代码解读与生物学类比：

• generate_episode：就像进行一次完整的动物行为学实验。从起点开始，让动物（智能体）按照既定策略（如随机探索）行动，直到找到食物（目标）或超时，记录下每一步的位置（状态）、行为（动作）和反馈（奖励，如消耗能量或获得食物）。
• mc_prediction_first_visit：实验结束后，分析数据。对于动物在实验中第一次到达的每个位置，计算从那个位置开始到实验结束它获得的所有奖励总和（考虑折扣，即越早的奖励越重要）。然后，我们将所有实验中，动物第一次到达该位置所获得的总奖励求平均。这个平均值就是我们对该位置“价值”的估计——它代表了从该位置出发，按照当前策略（随机探索），平均能获得多少未来奖励。

运行结果分析：你会看到，靠近目标(3,3)的状态价值较高（接近+1），而远离目标、靠近起点(0,0)的状态价值较低（甚至为负），因为随机策略下从那里出发需要很多步才能到达目标，累积的负奖励（惩罚）很多。这符合我们的直觉。

3.4 蒙特卡洛方法的优缺点

优点：

• 概念直观：直接从完整的实验样本中学习，符合“从经验中学习”的直觉。
• 无需环境模型：不依赖于P和R，适用于真正的“黑箱”系统。
• 偏差小：回报G_t是价值vπ(s)的无偏估计。

缺点：

• 必须等待回合结束：在回合很长或连续任务中，学习延迟很大。就像生物实验必须等整个实验周期结束才能分析，无法中途调整。
• 高方差：基于单个回合的回报进行更新，方差可能很大，导致学习不稳定。不同实验的结果可能波动剧烈。
• 仅适用于回合制任务：对于没有明确终止状态的持续任务，蒙特卡洛方法难以直接应用。

4. 时序差分学习：实时学习与“条件反射”

时序差分（Temporal-Difference, TD）学习结合了蒙特卡洛的“从经验学习”思想和动态规划的“自举”（Bootstrapping）思想。它是强化学习中最核心、最迷人的概念之一。

4.1 核心思想：用估计来更新估计

TD学习的核心公式（TD误差）是：TD误差 δ = R_{t+1} + γ * V(S_{t+1}) - V(S_t)

生物学类比——巴甫洛夫的狗：

• 蒙特卡洛：每次摇铃（状态）后都喂食（奖励），实验结束后，狗回顾整个经历，才建立起“铃响≈食物”的强烈联系。
• 时序差分：在第一次摇铃后喂食，狗立刻更新了“铃响”的价值预测。第二次摇铃后，即使还没喂食，它也会根据第一次的经验（对“铃响后状态”的估计）和当前的观察（也许有新的线索）来调整预测。这是一种实时、渐进的学习，更像生物体在环境中不断试错和调整的“条件反射”过程。

公式解读：

• R_{t+1}：在状态S_t下采取动作后获得的即时奖励（实际观察）。
• γ * V(S_{t+1})：对下一个状态S_{t+1}的价值估计（预测的未来）。
• V(S_t)：对当前状态S_t的旧有价值估计。
• δ：TD误差，即“实际观察到的即时奖励+对未来状态的预测”与“对当前状态的旧预测”之间的差异。
  • 如果δ > 0，说明我们之前的预测偏低了，需要调高V(S_t)。
  • 如果δ < 0，说明我们之前的预测偏高了，需要调低V(S_t)。

更新规则：V(S_t) ← V(S_t) + α * δ其中α是学习率，控制更新的幅度。

4.2 TD(0) 算法

TD(0)是最简单的时序差分算法，它只向前看一步。

算法流程：

1. 初始化价值函数V(s)。
2. 对每个回合： a. 初始化状态S。 b. 当S不是终止状态： i. 根据策略选择动作A，执行，得到R和S‘。 ii. 计算TD误差：δ = R + γ * V(S') - V(S)iii. 更新价值：V(S) = V(S) + α * δiv.S = S'

4.3 代码实现：TD(0) 策略评估

让我们用TD(0)来评估同一个随机策略，并与蒙特卡洛的结果对比。

def td0_prediction(env, policy, num_episodes, alpha=0.1, gamma=0.9): """ TD(0) 策略评估。 评估给定策略下的状态价值函数 V(s)。 """ V = defaultdict(float) # 初始化价值函数 for episode_i in range(num_episodes): state = env.reset() done = False while not done: action = policy(state) next_state, reward, done = env.step(action) # 计算TD误差 td_target = reward + gamma * V[next_state] * (not done) # 终止状态的下一个价值为0 td_error = td_target - V[state] # 更新当前状态价值 V[state] += alpha * td_error # 转移到下一个状态 state = next_state return V # 运行TD(0)评估 env = GridWorld() # 重新初始化环境 num_episodes = 5000 V_td0 = td0_prediction(env, random_policy, num_episodes, alpha=0.1, gamma=0.9) print("\nTD(0)评估结果（随机策略下的状态价值）：") for i in range(4): for j in range(4): state = (i, j) print(f"V({state}) = {V_td0.get(state, 0.0):.3f}", end='\t') print()

4.4 蒙特卡洛 vs. TD(0)：直观对比

为了更直观地看到两种方法学习过程的差异，我们可以观察它们对某个特定状态（例如起点(0,0)）的价值估计随训练回合数的变化。

def compare_learning_curve(env, policy, num_episodes, gamma=0.9, alpha=0.1): """比较MC和TD(0)在学习过程中的价值估计变化""" V_mc = defaultdict(float) V_td = defaultdict(float) returns_sum_mc = defaultdict(float) returns_count_mc = defaultdict(int) target_state = (0, 0) mc_values = [] td_values = [] for episode_i in range(1, num_episodes+1): # --- TD(0) 更新 --- state_td = env.reset() done_td = False while not done_td: action = policy(state_td) next_state, reward, done_td = env.step(action) td_target = reward + gamma * V_td[next_state] * (not done_td) td_error = td_target - V_td[state_td] V_td[state_td] += alpha * td_error state_td = next_state td_values.append(V_td[target_state]) # --- 蒙特卡洛 更新 (为简化，每10个回合评估一次) --- if episode_i % 10 == 0: # 生成一个回合用于MC评估 episode = generate_episode(env, policy) states = [step[0] for step in episode] rewards = [step[2] for step in episode] G = 0 for t in reversed(range(len(episode))): state_t = states[t] reward_t_plus_1 = rewards[t] G = gamma * G + reward_t_plus_1 if state_t not in states[:t]: returns_sum_mc[state_t] += G returns_count_mc[state_t] += 1 V_mc[state_t] = returns_sum_mc[state_t] / returns_count_mc[state_t] mc_values.append(V_mc.get(target_state, 0.0)) return mc_values, td_values # 运行比较 env = GridWorld() mc_curve, td_curve = compare_learning_curve(env, random_policy, num_episodes=1000) # 绘制学习曲线 plt.figure(figsize=(10, 6)) plt.plot(mc_curve, label='Monte Carlo (First-Visit)', alpha=0.7) plt.plot(td_curve, label='TD(0)', alpha=0.7) plt.xlabel('Training Episodes') plt.ylabel(f'Value Estimate for State (0,0)') plt.title('Learning Curve Comparison: Monte Carlo vs. TD(0)') plt.legend() plt.grid(True) plt.show()

观察与解释：

• TD(0)学习更快：你会看到TD(0)的曲线（橙色）通常会更早地收敛到一个稳定值附近。因为它每一步都更新，利用了“自举”，信息传播更快。
• 蒙特卡洛方差更大：蒙特卡洛的曲线（蓝色）波动可能更大，因为它依赖于整个回合的回报，而单个回合的随机性很大。
• 两者收敛到相似值：在足够多的训练后，两者对状态价值的估计应该趋向于同一个真值（在给定策略下）。这验证了TD(0)的收敛性。

5. SARSA 与 Q-Learning：从策略评估到控制

到目前为止，我们都在做策略评估（Prediction）：给定一个策略（如随机策略），评估它的好坏（计算V(s)）。强化学习的终极目标是策略控制（Control）：找到最优策略π*。

这需要我们从学习状态价值函数V(s)转向学习动作价值函数Q(s, a)。Q(s, a)代表在状态s下采取动作a，然后遵循策略π所能获得的期望回报。

5.1 SARSA：同策略TD控制

SARSA的名字来源于其更新公式中涉及的五个元素：(S_t, A_t, R_{t+1}, S_{t+1}, A_{t+1})。 其更新公式为：Q(S_t, A_t) ← Q(S_t, A_t) + α * [ R_{t+1} + γ * Q(S_{t+1}, A_{t+1}) - Q(S_t, A_t) ]

核心特点：

• 同策略：它评估和改进的是它实际执行的那个策略。A_{t+1}是根据当前策略（如ε-greedy）在状态S_{t+1}下实际选择的动作。
• 保守的探索：由于它根据实际要执行的动作来更新Q值，因此策略的探索性（如ε-greedy中的随机探索）会直接影响学习过程。它学习到的是在探索策略下的Q值。

5.2 Q-Learning：异策略TD控制

Q-Learning是强化学习中最著名的算法之一。其更新公式为：Q(S_t, A_t) ← Q(S_t, A_t) + α * [ R_{t+1} + γ * max_{a} Q(S_{t+1}, a) - Q(S_t, A_t) ]

核心特点：

• 异策略：它评估和改进的是最优策略（贪婪策略），而实际执行的动作可以来自另一个探索性策略（如ε-greedy）。公式中的max_{a} Q(S_{t+1}, a)代表假设在下一个状态S_{t+1}下采取最优动作所能获得的价值。
• 更激进的学习：它直接朝着最优价值函数的方向更新，而不受当前探索策略的束缚。因此，Q-Learning通常比SARSA学习得更快、更直接，但也可能因为过于“乐观”而在某些危险环境中学会冒险的策略。

5.3 代码实现：SARSA vs. Q-Learning

让我们在一个简单的网格世界中实现并对比这两种算法。我们将使用ε-greedy策略进行探索。

def epsilon_greedy_policy(state, Q, epsilon, actions): """ε-贪婪策略""" if random.random() < epsilon: return random.choice(actions) else: # 选择当前状态下Q值最大的动作 q_values = [Q[(state, a)] for a in actions] max_q = max(q_values) # 如果多个动作有相同的最大Q值，随机选择一个 best_actions = [a for a, q in zip(actions, q_values) if q == max_q] return random.choice(best_actions) def sarsa_control(env, num_episodes, alpha=0.1, gamma=0.9, epsilon=0.1): """SARSA 控制算法，学习最优动作价值函数 Q* 和策略 π*""" Q = defaultdict(float) # 初始化Q表 actions = env.actions for episode in range(num_episodes): state = env.reset() action = epsilon_greedy_policy(state, Q, epsilon, actions) done = False while not done: # 执行动作 next_state, reward, done = env.step(action) # 根据当前策略选择下一个动作 next_action = epsilon_greedy_policy(next_state, Q, epsilon, actions) # SARSA 更新 current_q = Q[(state, action)] next_q = Q[(next_state, next_action)] if not done else 0.0 td_target = reward + gamma * next_q td_error = td_target - current_q Q[(state, action)] = current_q + alpha * td_error state, action = next_state, next_action # 从Q表导出贪婪策略（最优策略） policy = {} for i in range(env.rows): for j in range(env.cols): s = (i, j) if s == env.goal: policy[s] = 'Goal' continue q_vals = {a: Q[(s, a)] for a in actions} best_action = max(q_vals, key=q_vals.get) policy[s] = best_action return Q, policy def q_learning_control(env, num_episodes, alpha=0.1, gamma=0.9, epsilon=0.1): """Q-Learning 控制算法""" Q = defaultdict(float) actions = env.actions for episode in range(num_episodes): state = env.reset() done = False while not done: # 用ε-greedy选择动作 action = epsilon_greedy_policy(state, Q, epsilon, actions) # 执行动作 next_state, reward, done = env.step(action) # Q-Learning 更新 current_q = Q[(state, action)] # 下一个状态的最大Q值 next_state_q_vals = [Q[(next_state, a)] for a in actions] if not done else [0.0] max_next_q = max(next_state_q_vals) td_target = reward + gamma * max_next_q td_error = td_target - current_q Q[(state, action)] = current_q + alpha * td_error state = next_state # 导出贪婪策略 policy = {} for i in range(env.rows): for j in range(env.cols): s = (i, j) if s == env.goal: policy[s] = 'Goal' continue q_vals = {a: Q[(s, a)] for a in actions} best_action = max(q_vals, key=q_vals.get) policy[s] = best_action return Q, policy # 运行两种算法 env = GridWorld() num_episodes = 5000 print("训练SARSA...") Q_sarsa, policy_sarsa = sarsa_control(env, num_episodes, alpha=0.1, gamma=0.9, epsilon=0.1) print("训练Q-Learning...") Q_qlearn, policy_qlearn = q_learning_control(env, num_episodes, alpha=0.1, gamma=0.9, epsilon=0.1) # 打印学到的策略（以网格形式） def print_policy_grid(policy, rows, cols, goal): print("学到的策略 (箭头表示最优动作，G表示目标):") arrow_map = {'up': '↑', 'down': '↓', 'left': '←', 'right': '→', 'Goal': 'G'} for i in range(rows): for j in range(cols): s = (i, j) if s == goal: print(f" G ", end=' ') else: print(f" {arrow_map[policy[s]]} ", end=' ') print() print("\n=== SARSA 学到的策略 ===") print_policy_grid(policy_sarsa, env.rows, env.cols, env.goal) print("\n=== Q-Learning 学到的策略 ===") print_policy_grid(policy_qlearn, env.rows, env.cols, env.goal)

结果分析：在简单的网格世界中，SARSA和Q-Learning通常都能学会一个避开墙壁、走向目标的最优策略。你可能会看到类似以下的输出：

→ → → ↓ → → → ↓ → → → ↓ ↑ ↑ ← G

这表示在每个格子，智能体应该朝哪个方向移动。在更复杂或有“陷阱”的环境中，SARSA和Q-Learning可能会表现出差异：SARSA（同策略）会考虑到探索带来的风险（比如ε概率的随机动作可能导致掉入陷阱），从而学会一条更安全的路径；而Q-Learning（异策略）只关注最优路径，可能学会一条更短但更危险的路径。

6. 常见问题与排查思路

在实现和应用这些算法时，你可能会遇到以下典型问题：

7. 最佳实践与工程建议

将蒙特卡洛和时序差分算法从教学示例应用到实际生物信息学或计算生物学项目中，需要注意以下几点：

1. 问题建模是关键：强化学习的成功大半取决于如何将你的生物学问题形式化为RL问题。仔细定义状态空间（什么信息能代表当前系统？）、动作空间（你能采取哪些干预措施？）、奖励函数（如何量化“好”的结果？）。奖励函数的设计尤其重要，它是指引智能体学习的“指挥棒”。
2. 从简单版本开始：不要一开始就建模极其复杂的状态（如整个基因组序列）。从一个高度简化的模型开始（比如用几个关键特征作为状态），验证算法能工作，再逐步增加复杂度。
3. 善用仿真环境：在真实生物实验成本高昂的情况下，建立一个尽可能准确的计算仿真环境至关重要。这可以是基于已知生物物理规律的模拟器，也可以是基于历史数据的统计模型。在仿真环境中充分测试和调参。
4. 超参数调优：学习率α、折扣因子γ、探索率ε对算法性能影响巨大。需要进行系统的超参数搜索（如网格搜索、随机搜索）。对于ε，通常可以采用衰减策略（随时间或回合数逐渐减小），前期重探索，后期重利用。
5. 监控学习过程：像我们上面画学习曲线一样，始终监控关键指标：平均回合奖励、价值函数的变化、策略的稳定性。这能帮你判断算法是否在学习、是否收敛、是否过拟合。
6. 理解算法的偏差-方差权衡：
   • 蒙特卡洛：无偏，但高方差。适用于回合较短、奖励信号明确的问题。
   • TD(0)：有偏（因为自举），但低方差。适用于在线、连续学习场景，是大多数现代RL算法的基础。
   • TD(λ) / 资格迹：是两者的折中，通过参数λ在MC(λ=1)和TD(0)(λ=0)间平滑过渡，能有效平衡偏差和方差，是很多场景下的实用选择。
7. 迈向深度强化学习：当状态空间巨大或连续时（如分子结构图像、蛋白质序列），表格法（Q表）不再适用。这时就需要深度Q网络（DQN）等算法，用神经网络来近似Q函数。这是将RL应用于复杂生物系统的必经之路。

掌握蒙特卡洛和时序差分算法，你就拥有了解决“无模型”强化学习问题的两把核心钥匙。它们的思想——从完整经验中总结，或从相邻经验中推测——不仅适用于算法，也反映了科学研究中两种基本的推理模式。建议你亲手运行文中的每一段代码，调整参数观察变化，并尝试将其应用到你自己设想的一个简单生物学场景中，这是巩固理解的最佳方式。

🚀 30+款热门AI模型一站整合，DeepSeek/GLM/Qwen 随心用，限时 5 折。 👉 点击领海量免费额度