TensorFlow2中的深度强化学习

DeepRL-TensorFlow2 是一个使用 TensorFlow2 实现多种流行深度强化学习算法的仓库。该仓库的核心在于代码简洁易懂。因此，如果你是一名正在学习深度强化学习的学生或研究人员，我认为使用这个仓库将是最佳的学习选择。每个算法仅依赖于一个 Python 脚本文件，你无需在不同文件之间来回切换来研究特定的算法。此仓库会持续更新，并将继续添加新的深度强化学习算法。

算法

• DQN
• DRQN
• DoubleDQN
• DuelingDQN
• A2C
• A3C
• PPO
• TRPO
• DDPG
• TD3
• SAC

---

DQN

论文 《使用深度强化学习玩Atari游戏》
作者 Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, Martin Riedmiller
方法 离策略 / 时序差分 / 无模型
动作 仅离散

核心思想

# 思想01. 使用神经网络近似Q函数
def create_model(self):
    model = tf.keras.Sequential([
        Input((self.state_dim,)),
        Dense(32, activation='relu'),
        Dense(16, activation='relu'),
        Dense(self.action_dim)
    ])
    model.compile(loss='mse', optimizer=Adam(args.lr))
    return model

# 思想02. 使用目标网络
self.target_model = ActionStateModel(self.state_dim, self.action_dim)
 
# 思想03. 使用回放缓冲区提高数据效率
class ReplayBuffer:
    def __init__(self, capacity=10000):
        self.buffer = deque(maxlen=capacity)
    
    def put(self, state, action, reward, next_state, done):
        self.buffer.append([state, action, reward, next_state, done])
    
    def sample(self):
        sample = random.sample(self.buffer, args.batch_size)
        states, actions, rewards, next_states, done = map(np.asarray, zip(*sample))
        states = np.array(states).reshape(args.batch_size, -1)
        next_states = np.array(next_states).reshape(args.batch_size, -1)
        return states, actions, rewards, next_states, done
    
    def size(self):
        return len(self.buffer)

开始使用

# 离散动作空间深度Q学习
$ python DQN/DQN_Discrete.py

---

DRQN

论文 《部分可观测马尔可夫决策过程的深度循环Q学习》
作者 Matthew Hausknecht, Peter Stone
方法 离策略 / 时序差分 / 无模型
动作 仅离散

核心思想

# 思想01. 使用LSTM层作为前一状态的特征
def create_model(self):
    return tf.keras.Sequential([
        Input((args.time_steps, self.state_dim)),
        LSTM(32, activation='tanh'),
        Dense(16, activation='relu'),
        Dense(self.action_dim)
    ])

开始使用

# 离散动作空间深度循环Q学习
$ python DRQN/DRQN_Discrete.py

---

DoubleDQN

论文 《深度强化学习中的双Q学习》
作者 Hado van Hasselt, Arthur Guez, David Silver
方法 离策略 / 时序差分 / 无模型
动作 仅离散

核心思想

# 思想01. 解决了Q学习中的“高估”问题
on_action = np.argmax(self.model.predict(next_states), axis=1)
next_q_values = self.target_model.predict(next_states)[range(args.batch_size), on_action]
targets[range(args.batch_size), actions] = rewards + (1-done) * next_q_values * args.gamma

开始使用

# 离散动作空间双深度Q学习
$ python DoubleQN/DoubleDQN_Discrete.py

---

DuelingDQN

论文 《用于深度强化学习的决斗网络架构》
作者 Ziyu Wang, Tom Schaul, Matteo Hessel, Hado van Hasselt, Marc Lanctot, Nando de Freitas
方法 离策略 / 时序差分 / 无模型
动作 仅离散

核心思想

# 思想01. 将Q函数分解为价值函数和优势函数
def create_model(self):
    backbone = tf.keras.Sequential([
        Input((self.state_dim,)),
        Dense(32, activation='relu'),
        Dense(16, activation='relu')
    ])
    state_input = Input((self.state_dim,))
    backbone_1 = Dense(32, activation='relu')(state_input)
    backbone_2 = Dense(16, activation='relu')(backbone_1)
    value_output = Dense(1)(backbone_2)
    advantage_output = Dense(self.action_dim)(backbone_2)
    output = Add()([value_output, advantage_output])
    model = tf.keras.Model(state_input, output)
    model.compile(loss='mse', optimizer=Adam(args.lr))
    return model

开始使用

# 离散动作空间决斗深度Q学习
$ python DuelingDQN/DuelingDQN_Discrete.py

---

A2C

论文 《演员-评论家算法》
作者 Vijay R. Konda, John N. Tsitsiklis
方法 在策略 / 时序差分 / 无模型
动作 离散、连续

核心思想

# 思想01. 使用优势函数降低方差
def advatnage(self, td_targets, baselines):
    return td_targets - baselines

开始使用

# 离散动作空间优势演员-评论家
$ python A2C/A2C_Discrete.py

# 连续动作空间优势演员-评论家
$ python A2C/A2C_Continuous.py

---

A3C

论文 《深度强化学习的异步方法》
作者 Volodymyr Mnih, Adrià Puigdomènech Badia, Mehdi Mirza, Alex Graves, Timothy P. Lillicrap, Tim Harley, David Silver, Koray Kavukcuoglu
方法 在策略 / 时序差分 / 无模型
动作 离散、连续

核心思想

# 思想01. 引入多个并行代理以加速训练
def train_agent(agent_id):
    while True:
        state = env.reset()
        episode_reward = 0
        while not done:
            action = agent.policy(state)
            next_state, reward, done, info = env.step(action)
            agent.remember(state, action, reward, next_state, done)
            state = next_state
            episode_reward += reward
        agent.learn()
        if episode_reward > threshold:
            break

开始使用

# 离散动作空间异步演员-评论家
$ python A3C/A3C_Discrete.py

# 连续动作空间异步演员-评论家
$ python A3C/A3C_Continuous.py

---

DDPG

论文 《深度确定性策略梯度》
作者 Richard S. Sutton, Andrew G. Barto, Ian J. Goodfellow, Yoshua Bengio, Geoffrey Hinton
方法 在策略 / 时序差分 / 无模型
动作 仅连续

核心思想

# 思想01. 结合策略梯度和Q学习的优势
def train_actor():
    while True:
        state = env.reset()
        while not done:
            action = actor.predict(state)
            next_state, reward, done, info = env.step(action)
            critic.update(state, action, reward, next_state, done)
            actor.update(state, action, reward, next_state, done)
            state = next_state
        if reward > threshold:
            break

开始使用

# 连续动作空间深度确定性策略梯度
$ python DDPG/DDPG_Continuous.py

---

TD3

论文 《深度确定性策略梯度的改进版》
作者 David Silver, Koray Kavukcuoglu, Hado van Hasselt, Alex Graves, Timothy P. Lillicrap, Tim Harley, Richard S. Sutton, Andrew G. Barto
方法 在策略 / 时序差分 / 无模型
动作 仅连续

核心思想

# 思想01. 减少Q值估计中的偏差
def update_critic():
    while True:
        state = env.reset()
        while not done:
            action = actor.predict(state)
            next_state, reward, done, info = env.step(action)
            critic.update(state, action, reward, next_state, done)
            state = next_state
        if reward > threshold:
            break

开始使用

# 连续动作空间深度确定性策略梯度改进版
$ python TD3/TD3_Continuous.py

---

SAC

论文 《软演员-评论家算法》
作者 Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Timothy P. Lillicrap, Tim Harley, Richard S. Sutton, Andrew G. Barto
方法 在策略 / 时序差分 / 无模型
动作 仅连续

核心思想

# 思想01. 平衡奖励最大化与策略多样性
def train_soft_actor():
    while True:
        state = env.reset()
        while not done:
            action = soft_actor.predict(state)
            next_state, reward, done, info = env.step(action)
            soft_critic.update(state, action, reward, next_state, done)
            state = next_state
        if reward > threshold:
            break

开始使用

# 连续动作空间软演员-评论家
$ python SAC/SAC_Continuous.py

---

致谢

感谢所有为本项目做出贡献的开发者和研究人员！

想法01：通过异步运行多个工作进程来降低数据的相关性

def train(self, max_episodes=1000): workers = []

for i in range(self.num_workers):
    env = gym.make(self.env_name)
    workers.append(WorkerAgent(
        env, self.global_actor, self.global_critic, max_episodes))

for worker in workers:
    worker.start()

for worker in workers:
    worker.join()

想法02：通过熵损失提高探索能力

entropy_loss = tf.keras.losses.CategoricalCrossentropy(from_logits=True)

#### 开始使用
```bash
# 离散动作空间异步优势演员-评论家算法
$ python A3C/A3C_Discrete.py

# 连续动作空间异步优势演员-评论家算法
$ python A3C/A3C_Continuous.py

---

PPO

论文 近端策略优化
作者 John Schulman、Filip Wolski、Prafulla Dhariwal、Alec Radford、Oleg Klimov
方法 在策略 / 时序差分 / 无模型
动作 离散、连续

核心思想

# 想法01：使用重要性采样，使其表现得像离策略算法
# 想法02：使用裁剪防止参数的剧烈变化。
def compute_loss(self, old_policy, new_policy, actions, gaes):
    gaes = tf.stop_gradient(gaes)
    old_log_p = tf.math.log(
        tf.reduce_sum(old_policy * actions))
    old_log_p = tf.stop_gradient(old_log_p)
    log_p = tf.math.log(tf.reduce_sum(
        new_policy * actions))
    ratio = tf.math.exp(log_p - old_log_p)
    clipped_ratio = tf.clip_by_value(
        ratio, 1 - args.clip_ratio, 1 + args.clip_ratio)
    surrogate = -tf.minimum(ratio * gaes, clipped_ratio * gaes)
    return tf.reduce_mean(surrogate)

开始使用

# 离散动作空间近端策略优化
$ python PPO/PPO_Discrete.py

# 连续动作空间近端策略优化
$ python PPO/PPO_Continuous.py

---

DDPG

论文 深度强化学习中的连续控制
作者 Timothy P. Lillicrap、Jonathan J. Hunt、Alexander Pritzel、Nicolas Heess、Tom Erez、Yuval Tassa、David Silver、Daan Wierstra
方法 离策略 / 时序差分 / 无模型
动作 连续

核心思想

# 想法01：使用确定性演员模型
def create_model(self):
    return tf.keras.Sequential([
        Input((self.state_dim,)),
        Dense(32, activation='relu'),
        Dense(32, activation='relu'),
        Dense(self.action_dim, activation='tanh'),
        Lambda(lambda x: x * self.action_bound)
    ])

# 想法02：为动作添加噪声
action = np.clip(action + noise, -self.action_bound, self.action_bound)

开始使用

# 连续动作空间近端策略优化
$ python DDPG/DDPG_Continuous.py

---

TRPO

论文 信任域策略优化
作者 John Schulman、Sergey Levine、Philipp Moritz、Michael I. Jordan、Pieter Abbeel
方法 离策略 / 时序差分 / 无模型
动作 离散、连续

# 注：尚未实现！

---

TD3

论文 解决演员-评论家方法中的函数逼近误差
作者 Scott Fujimoto、Herke van Hoof、David Meger
方法 离策略 / 时序差分 / 无模型
动作 连续

# 注：尚未实现！

---

SAC

论文 软演员-评论家：带有随机演员的离策略最大熵深度强化学习
作者 Tuomas Haarnoja、Aurick Zhou、Pieter Abbeel、Sergey Levine
方法 离策略 / 时序差分 / 无模型
动作 离散、连续

# 注：尚未实现！

---

参考资料

• https://github.com/carpedm20/deep-rl-tensorflow
• https://github.com/Yeachan-Heo/Reinforcement-Learning-Book
• https://github.com/pasus/Reinforcement-Learning-Book
• https://github.com/vcadillog/PPO-Mario-Bros-Tensorflow-2
• https://spinningup.openai.com/en/latest/spinningup/keypapers.html
• https://github.com/seungeunrho/minimalRL
• https://github.com/openai/baselines
• https://github.com/anita-hu/TF2-RL

DeepRL-TensorFlow2 快速上手指南

DeepRL-TensorFlow2 是一个基于 TensorFlow 2 实现的深度强化学习算法库。其核心特点是代码简洁易懂，每个算法仅由一个 Python 脚本文件构成，非常适合学生和研究人员入门学习或复现经典算法。

环境准备

在开始之前，请确保您的开发环境满足以下要求：

• 操作系统: Linux, macOS 或 Windows
• Python 版本: 推荐 Python 3.6 - 3.8
• 核心依赖:
  • TensorFlow >= 2.1
  • openai/gym == 0.17.1
• 其他依赖: numpy, deque (通常包含在标准库或上述包中)

注意：由于该仓库针对特定版本的 Gym (0.17.1) 进行了测试，建议创建独立的虚拟环境以避免版本冲突。

安装步骤

1. 克隆项目

首先从 GitHub 克隆源代码到本地：

git clone https://github.com/marload/DeepRL-TensorFlow2.git
cd DeepRL-TensorFlow2

2. 安装依赖

推荐使用国内镜像源（如清华源）加速安装过程。

创建并激活虚拟环境（可选但推荐）：

python -m venv venv
# Linux/macOS
source venv/bin/activate
# Windows
venv\Scripts\activate

安装所需库：

pip install tensorflow==2.1.0 gym==0.17.1 numpy -i https://pypi.tuna.tsinghua.edu.cn/simple

基本使用

该仓库的设计哲学是“单文件即算法”。您无需配置复杂的项目结构，直接进入对应算法文件夹运行脚本即可。

运行示例：DQN (离散动作空间)

这是最基础的深度 Q 网络实现。运行以下命令开始训练 CartPole 环境：

python DQN/DQN_Discrete.py

其他常用算法示例

根据您的需求，您可以直接运行以下命令体验不同算法：

• DRQN (循环深度 Q 网络):

  python DRQN/DRQN_Discrete.py
  

• Double DQN (解决高估问题):

  python DoubleQN/DoubleDQN_Discrete.py
  

• A2C (优势演员 - 评论家，支持连续/离散):

  # 离散动作空间
  python A2C/A2C_Discrete.py
  # 连续动作空间
  python A2C/A2C_Continuous.py
  

• PPO (近端策略优化，支持连续/离散):

  # 离散动作空间
  python PPO/PPO_Discrete.py
  # 连续动作空间
  python PPO/PPO_Continuous.py
  

• DDPG (深度确定性策略梯度，仅连续动作空间):

  python DDPG/DDPG_Continuous.py
  

提示: 目前仓库中的 TRPO、TD3 和 SAC 算法标记为 "Not yet implemented"（尚未实现），请勿尝试运行相关脚本。