Logo

Deep Reinforcement Learning (DRL) 算法在 PyTorch 中的实现与应用

强化学习PyTorchDRL算法深度学习人工智能Github开源项目
Ray

DRL-Pytorch

深度强化学习算法在PyTorch中的实现与应用

近年来,深度强化学习(Deep Reinforcement Learning, DRL)在人工智能领域取得了巨大的进展,成为了解决复杂决策问题的有力工具。本文将详细介绍多种流行的DRL算法在PyTorch中的实现,包括Q-learning、DQN(Deep Q-Network)、PPO(Proximal Policy Optimization)、DDPG(Deep Deterministic Policy Gradient)、TD3(Twin Delayed Deep Deterministic Policy Gradient)和SAC(Soft Actor-Critic)等。我们将探讨这些算法的原理、优缺点以及在实际问题中的应用。

DRL算法概述

深度强化学习结合了深度学习和强化学习的优点,能够在复杂的环境中学习最优策略。以下是一些主要的DRL算法:

  1. Q-learning: 经典的值迭代算法,用于离散动作空间。
  2. DQN: 将深度神经网络与Q-learning结合,能够处理高维状态空间。
  3. PPO: 基于策略梯度的算法,通过限制新旧策略的差异来稳定训练。
  4. DDPG: 适用于连续动作空间的确定性策略梯度算法。
  5. TD3: DDPG的改进版本,通过多个技巧提高了性能和稳定性。
  6. SAC: 结合了最大熵强化学习的思想,在探索与利用之间取得良好平衡。

PyTorch实现

PyTorch作为一个灵活而强大的深度学习框架,非常适合实现各种DRL算法。以下是这些算法在PyTorch中实现的关键点:

Q-learning

Q-learning是最基础的强化学习算法之一,它通过迭代更新Q值表来学习最优策略。虽然Q-learning本身不需要深度学习,但了解它有助于理解更复杂的DRL算法。

import torch

class QLearning:
    def __init__(self, state_dim, action_dim, learning_rate=0.1, gamma=0.99):
        self.Q = torch.zeros((state_dim, action_dim))
        self.lr = learning_rate
        self.gamma = gamma

    def update(self, state, action, reward, next_state):
        target = reward + self.gamma * torch.max(self.Q[next_state])
        self.Q[state, action] += self.lr * (target - self.Q[state, action])

    def get_action(self, state):
        return torch.argmax(self.Q[state]).item()

DQN (Deep Q-Network)

DQN通过使用深度神经网络来近似Q函数,极大地扩展了Q-learning处理复杂环境的能力。

import torch
import torch.nn as nn

class DQN(nn.Module):
    def __init__(self, state_dim, action_dim):
        super(DQN, self).__init__()
        self.fc1 = nn.Linear(state_dim, 64)
        self.fc2 = nn.Linear(64, 64)
        self.fc3 = nn.Linear(64, action_dim)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        return self.fc3(x)

class DQNAgent:
    def __init__(self, state_dim, action_dim, learning_rate=1e-3, gamma=0.99):
        self.q_network = DQN(state_dim, action_dim)
        self.target_network = DQN(state_dim, action_dim)
        self.target_network.load_state_dict(self.q_network.state_dict())
        self.optimizer = torch.optim.Adam(self.q_network.parameters(), lr=learning_rate)
        self.gamma = gamma

    def update(self, state, action, reward, next_state, done):
        state = torch.FloatTensor(state)
        next_state = torch.FloatTensor(next_state)
        q_values = self.q_network(state)
        next_q_values = self.target_network(next_state).detach()
        
        target = q_values.clone()
        target[action] = reward + (1 - done) * self.gamma * next_q_values.max()
        
        loss = nn.MSELoss()(q_values, target)
        self.optimizer.zero_grad()
        loss.backward()
        self.optimizer.step()

    def get_action(self, state):
        state = torch.FloatTensor(state)
        q_values = self.q_network(state)
        return torch.argmax(q_values).item()

PPO (Proximal Policy Optimization)

PPO是一种基于策略梯度的算法,通过引入信任区域约束来提高训练的稳定性。

import torch
import torch.nn as nn
import torch.optim as optim

class PPO(nn.Module):
    def __init__(self, state_dim, action_dim):
        super(PPO, self).__init__()
        self.actor = nn.Sequential(
            nn.Linear(state_dim, 64),
            nn.Tanh(),
            nn.Linear(64, 64),
            nn.Tanh(),
            nn.Linear(64, action_dim),
            nn.Softmax(dim=-1)
        )
        self.critic = nn.Sequential(
            nn.Linear(state_dim, 64),
            nn.Tanh(),
            nn.Linear(64, 64),
            nn.Tanh(),
            nn.Linear(64, 1)
        )
        
    def forward(self, state):
        return self.actor(state), self.critic(state)

class PPOAgent:
    def __init__(self, state_dim, action_dim, lr=3e-4, gamma=0.99, epsilon=0.2):
        self.ppo = PPO(state_dim, action_dim)
        self.optimizer = optim.Adam(self.ppo.parameters(), lr=lr)
        self.gamma = gamma
        self.epsilon = epsilon

    def update(self, states, actions, rewards, next_states, dones, old_probs):
        states = torch.FloatTensor(states)
        actions = torch.LongTensor(actions)
        rewards = torch.FloatTensor(rewards)
        next_states = torch.FloatTensor(next_states)
        old_probs = torch.FloatTensor(old_probs)

        for _ in range(10):  # 多次更新
            new_probs, state_values = self.ppo(states)
            new_probs = new_probs.gather(1, actions.unsqueeze(1)).squeeze(1)
            
            ratio = new_probs / old_probs
            surr1 = ratio * rewards
            surr2 = torch.clamp(ratio, 1-self.epsilon, 1+self.epsilon) * rewards
            actor_loss = -torch.min(surr1, surr2).mean()
            
            critic_loss = nn.MSELoss()(state_values, rewards)
            
            loss = actor_loss + 0.5 * critic_loss
            
            self.optimizer.zero_grad()
            loss.backward()
            self.optimizer.step()

    def get_action(self, state):
        state = torch.FloatTensor(state)
        probs, _ = self.ppo(state)
        return torch.multinomial(probs, 1).item()

DDPG (Deep Deterministic Policy Gradient)

DDPG是一种适用于连续动作空间的算法,它结合了DQN和确定性策略梯度的思想。

import torch
import torch.nn as nn
import torch.optim as optim

class Actor(nn.Module):
    def __init__(self, state_dim, action_dim, max_action):
        super(Actor, self).__init__()
        self.fc1 = nn.Linear(state_dim, 400)
        self.fc2 = nn.Linear(400, 300)
        self.fc3 = nn.Linear(300, action_dim)
        self.max_action = max_action
        
    def forward(self, state):
        a = torch.relu(self.fc1(state))
        a = torch.relu(self.fc2(a))
        return self.max_action * torch.tanh(self.fc3(a))

class Critic(nn.Module):
    def __init__(self, state_dim, action_dim):
        super(Critic, self).__init__()
        self.fc1 = nn.Linear(state_dim + action_dim, 400)
        self.fc2 = nn.Linear(400, 300)
        self.fc3 = nn.Linear(300, 1)
        
    def forward(self, state, action):
        q = torch.cat([state, action], 1)
        q = torch.relu(self.fc1(q))
        q = torch.relu(self.fc2(q))
        return self.fc3(q)

class DDPGAgent:
    def __init__(self, state_dim, action_dim, max_action, lr=1e-4, gamma=0.99, tau=0.001):
        self.actor = Actor(state_dim, action_dim, max_action)
        self.actor_target = Actor(state_dim, action_dim, max_action)
        self.actor_target.load_state_dict(self.actor.state_dict())
        self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=lr)
        
        self.critic = Critic(state_dim, action_dim)
        self.critic_target = Critic(state_dim, action_dim)
        self.critic_target.load_state_dict(self.critic.state_dict())
        self.critic_optimizer = optim.Adam(self.critic.parameters(), lr=lr)
        
        self.gamma = gamma
        self.tau = tau

    def select_action(self, state):
        state = torch.FloatTensor(state.reshape(1, -1))
        return self.actor(state).cpu().data.numpy().flatten()

    def update(self, replay_buffer, batch_size=100):
        # 从经验回放中采样
        state, action, next_state, reward, done = replay_buffer.sample(batch_size)
        
        # 计算目标Q值
        target_Q = self.critic_target(next_state, self.actor_target(next_state))
        target_Q = reward + (1 - done) * self.gamma * target_Q.detach()
        
        # 更新Critic
        current_Q = self.critic(state, action)
        critic_loss = nn.MSELoss()(current_Q, target_Q)
        self.critic_optimizer.zero_grad()
        critic_loss.backward()
        self.critic_optimizer.step()
        
        # 更新Actor
        actor_loss = -self.critic(state, self.actor(state)).mean()
        self.actor_optimizer.zero_grad()
        actor_loss.backward()
        self.actor_optimizer.step()
        
        # 软更新目标网络
        for param, target_param in zip(self.critic.parameters(), self.critic_target.parameters()):
            target_param.data.copy_(self.tau * param.data + (1 - self.tau) * target_param.data)
        
        for param, target_param in zip(self.actor.parameters(), self.actor_target.parameters()):
            target_param.data.copy_(self.tau * param.data + (1 - self.tau) * target_param.data)

TD3 (Twin Delayed DDPG)

TD3是DDPG的改进版本,通过引入双Q学习、延迟策略更新和目标策略平滑等技巧来提高性能和稳定性。

import torch
import torch.nn as nn
import torch.optim as optim

class Actor(nn.Module):
    def __init__(self, state_dim, action_dim, max_action):
        super(Actor, self).__init__()
        self.fc1 = nn.Linear(state_dim, 400)
        self.fc2 = nn.Linear(400, 300)
        self.fc3 = nn.Linear(300, action_dim)
        self.max_action = max_action
        
    def forward(self, state):
        a = torch.relu(self.fc1(state))
        a = torch.relu(self.fc2(a))
        return self.max_action * torch.tanh(self.fc3(a))

class Critic(nn.Module):
    def __init__(self, state_dim, action_dim):
        super(Critic, self).__init__()
        self.fc1 = nn.Linear(state_dim + action_dim, 400)
        self.fc2 = nn.Linear(400, 300)
        self.fc3 = nn.Linear(300, 1)
        
    def forward(self, state, action):
        sa = torch.cat([state, action], 1)
        q = torch.relu(self.fc1(sa))
        q = torch.relu(self.fc2(q))
        return self.fc3(q)

class TD3Agent:
    def __init__(self, state_dim, action_dim, max_action, lr=1e-3, gamma=0.99, tau=0.005, policy_noise=0.2, noise_clip=0.5, policy_freq=2):
        self.actor = Actor(state_dim, action_dim, max_action)
        self.actor_target = Actor(state_dim, action_dim, max_action)
        self.actor_target.load_state_dict(self.actor.state_dict())
        self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=lr)
        
        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.critic1_target.load_state_dict(self.critic1.state_dict())
        self.critic2_target.load_state_dict(self.critic2.state_dict())
        self.critic1_optimizer = optim.Adam(self.critic1.parameters(), lr=lr)
        self.critic2_optimizer = optim.Adam(self.critic2.parameters(), lr=lr)
        
        self.max_action = max_action
        self.gamma = gamma
        self.tau = tau
        self.policy_noise = policy_noise
        self.noise_clip = noise_clip
        self.policy_freq = policy_freq
avatar
0
0
0

相关项目

Project Cover
Practical_RL
Practical_RL是一个专注于强化学习实用性的开源课程，提供HSE和YSDA的课堂教学及线上学习支持，涵盖英语和俄语材料。课程从基础理论到实践应用，包括价值迭代、Q学习、深度学习、探索策略、策略梯度方法、序列模型及部分观察MDP等内容。学生可以通过GitHub改进课程，使用Google Colab或本地环境进行实践。适合希望在实际问题中应用强化学习的学生和研究者。
Project Cover
TensorLayer
TensorLayer 是一个基于 TensorFlow 的深度学习和强化学习库，为研究人员和工程师提供多种可定制的神经网络层，简化复杂 AI 模型的构建。它设计独特，结合了高性能与灵活性，支持多种后端和硬件，并提供丰富的教程和应用实例。广泛应用于全球知名大学和企业，如谷歌、微软、阿里巴巴等。
Project Cover
dopamine
Dopamine是一个用于快速原型设计强化学习算法的研究框架，旨在便于用户进行自由实验。其设计原则包括易于实验、灵活开发、紧凑可靠和结果可重复。支持的算法有DQN、C51、Rainbow、IQN和SAC，主要实现于jax。Dopamine提供了Docker容器及源码安装方法，适用于Atari和Mujoco环境，并推荐使用虚拟环境。更多信息请参阅官方文档。
Project Cover
PaLM-rlhf-pytorch
本项目实现了基于PaLM架构的强化学习与人类反馈（RLHF），适用于开放环境下的ChatGPT复现。结合了LoRA微调和Flash Attention技术，提供详细的安装和使用指南。加入社区，探索最新的PPO和RL技术进展。
Project Cover
neurojs
neurojs是一个浏览器内的JavaScript深度学习框架，特别专注于强化学习任务。它提供全栈神经网络支持、强化学习扩展以及网络配置的二进制导入和导出功能。用户可以通过2D自驾车等演示直观了解其功能。尽管该项目已停止维护，但仍可作为学习和实验工具，建议使用更通用的框架如TensorFlow-JS。
Project Cover
deep-neuroevolution
本项目提供分布式深度神经网络训练的多种实现，包括深度遗传算法(DeepGA)和进化策略(ES)，用于强化学习。基于并改进了OpenAI的代码，支持本地和AWS运行。项目还包括NeuroEvolution的视觉检测工具VINE和GPU优化加速。用户可通过Docker容器快速启动实验，并使用Mujoco进行高级实验。
Project Cover
lab
DeepMind Lab是一个基于id Software的Quake III Arena开发的3D学习环境，通过ioquake3和其他开源软件支持。本平台提供了一系列挑战性的3D导航和解谜任务，主要用于深度强化学习等人工智能领域的研究。构建于多个层次的任务和Lua脚本配置，DeepMind Lab支持广泛的研究应用和技术评估。适合学术研究者和技术开发者使用，可以通过专门文档获得更多构建和使用信息。
Project Cover
alpha-zero-general
该项目基于AlphaGo Zero论文，提供了简化和灵活的自学强化学习实现，适用于各种双人回合制对抗游戏和深度学习框架。用户可通过实现Game.py和NeuralNet.py中的类，为所选游戏自定义实现。项目提供了Othello、五子棋和井字棋等游戏示例，支持PyTorch和Keras框架，并包含核心训练循环、蒙特卡洛树搜索和神经网络参数设置的详细说明，此外还提供预训练模型和Docker环境设置。
Project Cover
ml-agents
Unity ML-Agents Toolkit是一个开源项目，利用游戏和模拟环境训练智能代理。集成了基于PyTorch的先进算法，用户可以轻松训练2D、3D和VR/AR游戏中的智能代理。支持强化学习、模仿学习和神经进化等方法，适用于NPC行为控制、自动化测试和游戏设计评估。该工具包为游戏开发者和AI研究人员提供了一个共享平台，助力在Unity丰富环境中测试AI进展，并惠及广泛的研究和开发社区。

相关文章

Article Cover
深度神经进化：遗传算法在深度强化学习中的应用与发展
2 个月前
Article Cover
Unity ML-Agents: 革新游戏AI开发的开源工具包
2 个月前
Article Cover
PaLM-rlhf-pytorch:基于PaLM架构实现的RLHF模型
2 个月前
Article Cover
TensorLayer: 强大灵活的深度学习和强化学习库
2 个月前
Article Cover
Practical_RL: 一门实用的强化学习课程
2 个月前
Article Cover
AlphaZero通用框架:一种强大的自学习AI算法
2 个月前
Article Cover
TensorHouse: 企业级AI/ML应用的开源工具箱
2 个月前
Article Cover
Transformers学习指南：从入门到精通
2 个月前
Article Cover
Deep Learning Papers Reading Roadmap: 一份深度学习论文阅读指南
2 个月前

最新项目

Project Cover
豆包MarsCode
豆包 MarsCode 是一款革命性的编程助手，通过AI技术提供代码补全、单测生成、代码解释和智能问答等功能，支持100+编程语言，与主流编辑器无缝集成，显著提升开发效率和代码质量。
Project Cover
AI写歌
Suno AI是一个革命性的AI音乐创作平台，能在短短30秒内帮助用户创作出一首完整的歌曲。无论是寻找创作灵感还是需要快速制作音乐，Suno AI都是音乐爱好者和专业人士的理想选择。
Project Cover
商汤小浣熊
小浣熊家族Raccoon，您的AI智能助手，致力于通过先进的人工智能技术，为用户提供高效、便捷的智能服务。无论是日常咨询还是专业问题解答，小浣熊都能以快速、准确的响应满足您的需求，让您的生活更加智能便捷。
Project Cover
有言AI
有言平台提供一站式AIGC视频创作解决方案，通过智能技术简化视频制作流程。无论是企业宣传还是个人分享，有言都能帮助用户快速、轻松地制作出专业级别的视频内容。
Project Cover
Kimi
Kimi AI助手提供多语言对话支持，能够阅读和理解用户上传的文件内容，解析网页信息，并结合搜索结果为用户提供详尽的答案。无论是日常咨询还是专业问题，Kimi都能以友好、专业的方式提供帮助。
Project Cover
吐司
探索Tensor.Art平台的独特AI模型，免费访问各种图像生成与AI训练工具，从Stable Diffusion等基础模型开始，轻松实现创新图像生成。体验前沿的AI技术，推动个人和企业的创新发展。
Project Cover
SubCat字幕猫
SubCat字幕猫APP是一款创新的视频播放器，它将改变您观看视频的方式！SubCat结合了先进的人工智能技术，为您提供即时视频字幕翻译，无论是本地视频还是网络流媒体，让您轻松享受各种语言的内容。
Project Cover
AIWritePaper论文写作
AIWritePaper论文写作是一站式AI论文写作辅助工具，简化了选题、文献检索至论文撰写的整个过程。通过简单设定，平台可快速生成高质量论文大纲和全文，配合图表、参考文献等一应俱全，同时提供开题报告和答辩PPT等增值服务，保障数据安全，有效提升写作效率和论文质量。
Project Cover
稿定AI
稿定设计 是一个多功能的在线设计和创意平台，提供广泛的设计工具和资源，以满足不同用户的需求。从专业的图形设计师到普通用户，无论是进行图片处理、智能抠图、H5页面制作还是视频剪辑，稿定设计都能提供简单、高效的解决方案。该平台以其用户友好的界面和强大的功能集合，帮助用户轻松实现创意设计。
使用协议隐私政策广告服务
投诉举报邮箱: service@vectorlightyear.com
@2024 懂AI·鲁ICP备2024100362号-6·鲁公网安备37021002001498号