强化学习 14 —— TD3 算法详解与TensorFlow 2.0实现

一、TD3算法核心原理与改进动机

1.1 从DDPG到TD3的演进逻辑

深度确定性策略梯度（DDPG）算法在连续控制任务中表现出色，但其存在两个关键缺陷：过估计偏差和策略滞后更新。过估计偏差源于Q网络对动作值的过高估计，在最大值操作（max operator）中累积误差；策略滞后更新则导致策略网络无法及时响应Q网络的改进，形成”追赶效应”。

TD3（Twin Delayed Deep Deterministic Policy Gradient）通过三项核心改进解决这些问题：

• 双Q网络（Twin Q-Network）：使用两个独立Q网络估计目标值，取较小值作为更新目标，有效抑制过估计
• 目标策略平滑（Target Policy Smoothing）：在目标动作上添加噪声，形成正则化效果
• 延迟策略更新（Delayed Policy Update）：策略网络更新频率低于Q网络，确保策略稳定性

1.2 算法数学基础

TD3的损失函数包含两个部分：

1. Critic损失（双Q网络）：

   L(θ_i) = E[(y - Q_θi(s,a))²], i=1,2
   y = r + γ min(Q_θ1'(s',a'), Q_θ2'(s',a'))
   a' = π_φ'(s') + clip(ε, -c, c)

2. Actor损失（策略网络）：

   L(φ) = -E[Q_θ1(s, π_φ(s))]

   其中ε服从正态分布N(0,0.1)，c=0.5控制噪声范围，γ为折扣因子（通常0.99）。

二、TensorFlow 2.0实现架构

2.1 网络结构设计

import tensorflow as tf
from tensorflow.keras import layers, Model
class Critic(Model):
    def __init__(self, state_dim, action_dim):
        super().__init__()
        self.l1 = layers.Dense(256, activation='relu')
        self.l2 = layers.Dense(256, activation='relu')
        self.l3 = layers.Dense(1)
        self.state_proj = layers.Dense(256)
        self.action_proj = layers.Dense(256)
    def call(self, state, action):
        x = tf.concat([self.state_proj(state), 
                      self.action_proj(action)], -1)
        x = self.l1(x)
        x = self.l2(x)
        return self.l3(x)
class Actor(Model):
    def __init__(self, state_dim, action_dim, max_action):
        super().__init__()
        self.l1 = layers.Dense(256, activation='relu')
        self.l2 = layers.Dense(256, activation='relu')
        self.l3 = layers.Dense(action_dim, activation='tanh')
        self.max_action = max_action
    def call(self, state):
        x = self.l1(state)
        x = self.l2(x)
        return self.max_action * self.l3(x)

设计要点：

• 使用独立的状态/动作投影层提升特征提取能力
• 策略网络输出采用tanh激活，通过max_action参数缩放至实际动作范围
• 双Critic网络共享相同架构但独立参数

2.2 目标网络更新机制

@tf.function
def update_target(target_model, main_model, tau=0.005):
    for t, e in zip(target_model.trainable_variables, 
                    main_model.trainable_variables):
        t.assign(tau * e + (1 - tau) * t)

采用软更新（Polyak averaging）而非硬更新，通过tau参数控制更新强度，典型值0.005。

三、完整实现流程

3.1 初始化参数

class TD3Agent:
    def __init__(self, state_dim, action_dim, max_action):
        self.actor = Actor(state_dim, action_dim, max_action)
        self.actor_target = Actor(state_dim, action_dim, max_action)
        self.critic1 = Critic(state_dim, action_dim)
        self.critic2 = Critic(state_dim, action_dim)
        self.critic1_target = Critic(state_dim, action_dim)
        self.critic2_target = Critic(state_dim, action_dim)
        self.actor_optimizer = tf.keras.optimizers.Adam(3e-4)
        self.critic_optimizer = tf.keras.optimizers.Adam(3e-4)
        self.max_action = max_action
        self.tau = 0.005
        self.policy_noise = 0.2
        self.noise_clip = 0.5
        self.policy_freq = 2

3.2 训练核心逻辑

@tf.function
def train_step(self, states, actions, next_states, rewards, dones):
    # 目标策略平滑
    noise = tf.random.normal(tf.shape(actions), 0, self.policy_noise)
    noise = tf.clip_by_value(noise, -self.noise_clip, self.noise_clip)
    next_actions = self.actor_target(next_states)
    next_actions = next_actions + noise
    next_actions = tf.clip_by_value(next_actions, -self.max_action, self.max_action)
    # 计算目标Q值
    target_q1 = self.critic1_target(next_states, next_actions)
    target_q2 = self.critic2_target(next_states, next_actions)
    target_q = tf.minimum(target_q1, target_q2)
    target = rewards + (1 - dones) * 0.99 * target_q
    # 更新Critic
    with tf.GradientTape() as tape:
        current_q1 = self.critic1(states, actions)
        current_q2 = self.critic2(states, actions)
        critic1_loss = tf.reduce_mean((current_q1 - target) ** 2)
        critic2_loss = tf.reduce_mean((current_q2 - target) ** 2)
    critic_grads1 = tape.gradient(critic1_loss, self.critic1.trainable_variables)
    critic_grads2 = tape.gradient(critic2_loss, self.critic2.trainable_variables)
    self.critic_optimizer.apply_gradients(
        zip(critic_grads1, self.critic1.trainable_variables))
    self.critic_optimizer.apply_gradients(
        zip(critic_grads2, self.critic2.trainable_variables))
    # 延迟策略更新
    def update_actor():
        with tf.GradientTape() as tape:
            actions = self.actor(states)
            actor_loss = -tf.reduce_mean(self.critic1(states, actions))
        actor_grads = tape.gradient(actor_loss, self.actor.trainable_variables)
        self.actor_optimizer.apply_gradients(
            zip(actor_grads, self.actor.trainable_variables))
        return actor_loss
    if self.train_step_counter % self.policy_freq == 0:
        actor_loss = update_actor()
        update_target(self.actor_target, self.actor)
        update_target(self.critic1_target, self.critic1)
        update_target(self.critic2_target, self.critic2)

四、实践建议与调优策略

4.1 超参数选择指南

参数	典型值	调整建议
批大小	256	复杂环境可增至512
折扣因子γ	0.99	长时序任务可适当降低
策略噪声	0.2	根据动作空间维度调整
目标网络τ	0.005	稳定环境可增至0.01
策略更新频率	2	高维动作空间可增至5

4.2 常见问题解决方案

1. 训练不稳定：

   • 检查目标网络更新频率，降低τ值
   • 增加批大小提升估计准确性
   • 添加梯度裁剪（clipvalue=1.0）

2. 收敛速度慢：

   • 增大actor学习率（1e-4→3e-4）
   • 减少策略噪声（0.2→0.1）
   • 检查奖励函数设计是否合理

3. 过估计现象：

   • 确保双Q网络独立初始化
   • 监控target_q1和target_q2的差异
   • 增加目标策略平滑噪声

五、扩展应用场景

TD3算法在以下场景表现优异：

1. 机器人连续控制：如MuJoCo环境中的Ant、Humanoid任务
2. 自动驾驶决策：车辆轨迹跟踪、速度控制
3. 工业控制：电机转速调节、温度控制系统
4. 金融交易：高频交易中的仓位控制

改进方向建议：

• 结合经验回放优先级采样（Prioritized Experience Replay）
• 引入分层强化学习结构处理复杂任务
• 使用并行环境加速数据收集（如Vectorized Environment）

通过系统掌握TD3算法原理与TensorFlow 2.0实现技巧，开发者能够构建更稳定、高效的连续控制智能体。实际工程中需结合具体问题调整网络结构与超参数，建议从简单环境（如Pendulum）开始验证，逐步过渡到复杂任务。