from TD3 to SAC

最新推荐文章于 2024-08-21 20:59:34 发布
最新推荐文章于 2024-08-21 20:59:34 发布
阅读量941 收藏 8
点赞数 1
分类专栏： RL 文章标签： 机器学习 算法 深度学习 人工智能 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41061258/article/details/115375595
版权

TD3

DDPG常常会遇到Q值overestimate的问题，这将会导致Critic部分给出错误的评判，导致Actor部分错误利用了这部分知识进行学习。TD3则是为了解决这个问题。

  • 技巧一:快速双q学习。TD3学习两个q函数而不是一个q函数(即twin)，并使用两个q值中较小的一个作为Bellman误差损失函数中的目标。
  • 技巧二:延迟的政策更新。TD3更新策略(和目标网络)的频率低于q函数。本文建议每两个q函数更新一次策略更新。这样可以有效避免policy带来的偏差问题。
  • 技巧三:目标政策平滑。TD3为目标动作添加了噪声，使得策略更难利用Q函数误差，因为Q在动作中的变化是平滑的。

要点

最特别的一点就是要学习两个Q函数

两个q函数都使用一个单一的目标，使用两个q函数中的任何一个给出一个较小的目标值进行计算

在这里插入图片描述

对目标使用较小的q值，并向较小的q值回归，有助于防止q函数中的高估。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SjuzHSFp-1617262314466)(C:\Users\liuyi\AppData\Roaming\Typora\typora-user-images\image-20210331195639208.png)]

SAC

SAC是一种将随机策略优化方法和DDPG算法（确定性策略）相结合的算法。它虽然也使用了双裁剪的Q学习方法，但是它并不能严格算成TD3的改进版本。它的一个重要特点就是加入了熵的方法。

Entropy-Regularized Reinforcement Learning

该方法在传统RL方法的基础上，加入了熵的思想。普通方法在执行完一个决策之后，都会获得一个即时reward，而该方法除了即时reward外，还加入了一个基于熵的reward。

在这里插入图片描述

SAC

Q学习

与TD3方法的相同与不同

相同点：

  • 和TD3一样，两个q函数都是通过MSBE最小化来学习的，通过回归到一个单一的共享目标
  • 与TD3一样，共享目标是使用目标Q-network计算的，目标Q-network是通过polyak对训练过程中的Q-network参数进行平均得到的。
  • 与TD3中一样，共享目标使用剪切的双q技巧。

不同点

  • 与TD3不同，该目标还包括一项，该项来自SAC对熵正则化的使用
  • 与TD3不同，目标中使用的下一状态操作来自当前策略，而不是目标策略。
  • 与TD3不同，没有明确的目标政策平滑。TD3训练了一个确定性策略，因此它通过向下一状态动作添加随机噪声来实现平滑。SAC训练了一个随机策略，因此来自该随机性的噪声足以获得类似的效果。

SAC利用这种对目标的样本近似，为每个q函数设置MSBE损耗。这里唯一尚未确定的是，用哪个Q函数来计算样本备份:像TD3一样，SAC使用剪切双Q技巧，并在两个Q近似器之间取最小Q值。但这里需要注意的是，计算目标值的时候的那个动作产生，是由本身策略产生的，而不是由目标策略产生的。
在这里插入图片描述在这里插入图片描述

疑问：

为什么这里就不需要设置目标的策略参数了呢？

Enoch Liu98
关注
专栏目录
如何选择深度强化学习算法：MuZero/SAC/PPO/TD3/DDPG/DQN/等算法
丨汀、的博客
07-14 3179
如何选择深度强化学习算法：MuZero/SAC/PPO/TD3/DDPG/DQN/等算法
强化学习算法TD3论文的翻译与解读：延迟学习、软更新、策略噪声、梯度截取
丨汀、的博客
07-15 1678
强化学习算法TD3论文的翻译与解读：延迟学习、软更新、策略噪声、梯度截取
强化学习策略梯度梳理4-SOTA中（DDPG TD3 SAC SAC-dicrete 附代码）
thousandsofwind的博客
07-19 3319
强化学习策略梯度梳理-SOTA下强化学习策略梯度梳理-SOTA下进阶方向2Q-learningDDPG连续空间TD3SAC 强化学习策略梯度梳理-SOTA下 同前文 这个部分仍然参考周博磊老师的第六节的顺序 主要参考课程 Intro to Reinforcement Learning，Bolei Zhou 相关文中代码 https://github.com/ThousandOfWind/RL-basic-alg.git 进阶方向2 Q-learning 这里标出Q-learning只是为了强调 DQN的ta
深度强化学习算法：DDPG TD3 SAC
zKAwJqD的博客
01-19 1453
在实验环境中，机器人MuJoCo提供了一个丰富的仿真平台，可以用来验证这些算法的有效性和性能。TD3（Twin Delayed Deep Deterministic Policy Gradient）算法是DDPG算法的改进版本，通过引入双Q网络和延迟更新策略来提高算法的性能和稳定性。这些算法能够通过与环境的交互来学习最优策略，并实现高效的决策和控制。实验结果显示，DDPG算法在处理连续动作问题时表现良好，TD3算法在处理高维状态和动作空间时更具优势，而SAC算法在探索和利用的平衡上表现出更好的性能。
DDPG ,TD3,SAC
aaaaPIKACHU的博客
05-18 1945
DDPG与SAC的区别： DDPG训练得到的是一个deterministic policy确定性策略，也就是说这个策略对于一种状态state只考虑一个最优的动作。Deterministic policy的最终目标找到最优路径。 Stochastic policy随机策略在实际应用中往往是更好的做法。比如我们让机器人抓取一个水杯，机器人是有无数条路径去实现这个过程的，而并不是只有唯一的一种做法。因此，我们就需要DRL算法能够给出一个随机策略，在每一个state上都能输出每一种action的概率，比如有3个
Quadratic_MLPs_in_RL:具有Quadratic-MLP（Q-MLP）作为参与者策略网络的TD3和SAC算法
03-06
强化学习中的二次MLP 我们随附的论文“用于无模型强化学习的二次方参与者网络”的源代码和数据。 具有Quadratic-MLP（Q-MLP）作为参与者策略网络的TD3和SAC算法。 如果您使用我们的代码或数据，请引用本文。 要求 TD3和SAC在连续控制任务中进行了测试。 使用Pytorch 1.7.1 + cu110和Python 3.8.7训练Neural Netorks。 用法 要使用Q-MLP actor策略运行实验，请分别在SAC和TD3文件夹中运行以下Shell脚本。 ./run_Q_td3_nohup.sh ./run_Q_sac_nohup.sh 要运行基线实验，请分别在SAC和TD3文件夹中运行以下Shell脚本。 ./run_td3_nohup.sh ./run_sac_nohup.sh 致谢 TD3和SAC代码紧密基于 。 TD3代码基于 。 SAC代码基于和
带有火炬的深度增强学习：DQN，AC，ACER，A2C，A3C，PG，DDPG，TRPO，PPO，SAC，TD3和PyTorch实施...
01-30
状态：活动（在活动开发中，可能会发生重大更改） 该存储库将实现经典且最新的深度强化学习算法。 该存储库的目的是为人们提供清晰的pytorch代码，以供他们学习深度强化学习算法。 将来，将添加更多最先进的算法，并且还将保留现有代码。 要求 python <= 3.6 张量板 体育馆> = 0.10 火炬> = 0.4 请注意，tensorflow不支持python3.7 安装 pip install -r requirements.txt 如果失败： 安装健身房 pip install gym 安装pytorch please go to official webisite to install it: https://pytorch.org/ Recommend use Anaconda Virtual Environment to manage your packages 安装tensorboardX pip install tensorboardX pip install tensorflow==1.12 测试 cd Char10\ TD3/ python TD3
【TD3：学习与人工智能一起运行】TD3: Learning To Run With AI
最新发布
wq6qeg88的博客
08-21 892
然后，我们的代理政策将继续变得更糟，因为它正在更新有很多错误的州。Up，2018 年）。[2] Lillicrap， TP， Hunt， J. J.， Pritzel， A.， Heess， N.， Erez， T.， Tassa， Y.， Silver， D.， and Wierstra， D. 具有深度强化学习的持续控制。[9] Wu， Y.， Mansimov， E.， Grosse， R. B.， Liao， S.， and Ba， J. 使用克罗内克因子近似进行深度强化学习的可扩展信任区域方法。
如何使用Python构建强化学习环境？
AI天才研究院
08-15 1365
强化学习（Reinforcement Learning，简称RL）作为人工智能和机器学习的重要分支，近年来在各个领域都取得了显著的成果。从围棋到机器人控制，从自动驾驶到推荐系统，强化学习的应用范围正在不断扩大。然而，要想成功应用强化学习算法，首先需要构建一个合适的环境，这个环境能够准确模拟实际问题，并为智能体提供学习和决策的平台。自定义环境通常需要实现与OpenAI Gym兼容的接口，以便与现有的强化学习算法和框架集成。状态空间和动作空间的定义奖励函数的设计环境动态的实现特定问题的约束和规则。
极简深度强化学习实现-DDPG-TD3-SAC
hehedadaq的博客
10-21 6621
极简深度强化学习实现-DDPG-TD3-SAC 文章目录极简深度强化学习实现-DDPG-TD3-SACgithub地址based on实现目的和学习建议：下一步打算 github地址 https://github.com/kaixindelele/DRL-tensorflow based on My DRL library with tensorflow1.14 core codes based ...
Popular-RL-Algorithms:软参与者关键（SAC），双延迟DDPG（TD3），参与者关键（ACA2C），近端策略优化（PPO），QT-Opt，PointNet的PyTorch实施。
05-13
流行的无模型强化学习算法 PyTorch和Tensorflow 2.0在Openai体育馆环境和自行实现的Reacher环境中均实现了最新的无模型强化学习算法。 算法包括软参与者关键（SAC），深度确定性策略梯度（DDPG），双延迟DDPG（TD3），参与者关键（AC / A2C），近端策略优化（PPO），QT-Opt（包括交叉熵（ CE）方法） ， PointNet ，运输商，循环策略梯度，软决策树等。 请注意，此存储库更多是我在研究和实施期间实施和测试的个人算法集合，而不是正式的开放源代码库/软件包以供使用。 但是，我认为与他人分享它可能会有所帮助，并且我希望对实现进行有益的讨论。 但是我没有花太多时间在清理或构建代码上。 您可能会注意到，每种算法可能都有几种实现方式，在此我特意展示所有这些方式，供您参考和比较。 此外，此存储库仅包含PyTorch实施。 对于RL算法的官方库，
PyRL:PyRL-Pytorch中的强化学习框架（政策梯度，DQN，DDPG，TD3，PPO，SAC等）
05-03
PyRL-Pytorch中的强化学习框架 PyRL是深度强化学习研究的框架。 在PyTorch中实现了以下算法： （在制品） （WIP） （在制品） 该项目仍在积极开发中。 特征 模块化架构 在PyTorch中实现 可读代码 安装 git clone https://github.com/chaovven/pyrl.git pip3 install -r requirements.txt 我强烈建议使用conda环境进行实验。 其中一些示例使用MuJoCo物理模拟器。 有关设置MuJoCo的说明，请参见。 进行实验 示例1： TD3 python3 main.py --alg=td3 with env=InvertedPendulum-v2 默认参数存储在config/default.yaml ，其中所有实验都共享这些参数。 TD3的参数存储在文件config/algs
model-free-algorithms:TF1.x中的TD3，SAC，IQN，Rainbow，PPO，Ape-X等
05-16
地位。 存档（代码按原样提供，预计不会进行更新） 笔记。 请参阅我的仓库以了解TF2.x中的强化学习算法 实现的算法 算法在实现。 TD3 [] SAC [] IQN [ ] 彩虹[ ] Apex [] 嘈杂的网[ ] PER [] MultiStep ] PPO [] A2C [] GAE [] NAE [] 整体架构 该存储库旨在表示一个漂亮的Tensorboard图，这对于调试非常有用。 典型的图形如下所示： 笔记 分布式算法是使用Ray （灵活，高性能的分布式执行框架）实现的。 由于缺少Mujoco许可证，所有用于连续控制的算法首先在LunarLanderContinuous-v2上进行测试，然后在OpenAI的Gym的BipedalWalker-v2环境中进行测试并解决。 Rainbow，IQN已在CartPole-v0上经过测试，并且可以稳
DeepReinforcementLearning：深度RL实施。 在pytorch中实现的DQN，SAC，DDPG，TD3，PPO和VPG。 经过测试的环境：LunarLander-v2和Pendulum-v0
02-13
使用Pytorch实现的深度RL算法 算法列表： 关于深入探讨 实验结果： 算法 离散环境：LunarLander-v2 连续环境：Pendulum-v0 DQN -- VPG -- DDPG -- TD3 -- SAC -- PPO -- 用法： 只需直接运行文件/算法。 在我学习算法时，它们之间没有通用的结构。 不同的算法来自不同的来源。 资源： 未来的项目： 如果有时间，我将为使用RL的电梯添加一个简单的程序。 更好的图形
强化学习调参经验大集成：TD3、PPO+GAE、SAC、离散动作噪声探索、以及Off-policy 、On-policy 算法常见超参数
丨汀、的博客
07-15 5925
强化学习调参经验大集成：TD3、PPO+GAE、SAC、离散动作噪声探索、以及Off-policy 、On-policy 算法常见超参数
sac算法解析
weixin_42197488的博客
08-01 2026
================= Soft Actor-Critic … contents:: Table of Contents Background (Previously: Background for TD3_) … _Background for TD3: …/algorithms/td3.html#background Soft Actor Critic (SAC) is an algorithm that optimizes a stochastic policy in an off-pol
强化学习之TD3（pytorch实现）
小星AI
10-06 5060
强化学习最好的几个算法之一TD3
RL论文阅读20 - MF类算法总结(VPG, TROP, PPO, DDPG, TD3, SAC)
铁锹的填坑记录
10-19 2094
PG类算法总结 1. On-Policy类算法 1.1 VPG：Vanilla Policy Gradient on policy 算法 可用于动作空连续或者离散动作空间 这个就是最初的PG版本。我们的目的是最大化有限的return。J代表的是无折扣的有限return。 下面的公式推导见从PG到A3C ![\nabla_{\theta} J(\pi_{\theta}) = \underE{\tau \sim \pi_{\theta}}{ \sum_{t=0}^{T} \nabla_{\theta
深度强化学习-TD3算法
athrunsunny的博客
09-05 3452
其中actor和target部分的网络参数会延迟更新，也就是说critic1和critic2参数在不断更新，训练好critic之后才能知道actor做出理想的动作。Critic网络更新的频率要比Actor网络更新的频率要大（类似GAN的思想，先训练好Critic才能更好的对actor指指点点）。1、运用两个Critic网络。TD3算法适合于高维连续动作空间，是DDPG算法的优化版本，为了优化DDPG在训练过程中Q值估计过高的问题。更新Critic网络时候加入随机噪声，以达到对Critic网络波动的稳定性。
基于TD3的SAC
06-02
以下是基于TD3的SAC算法的简单实现，使用Python和TensorFlow框架： ```python import tensorflow as tf import numpy as np class TD3_SAC: def __init__(self, state_dim, action_dim, max_action): self.state_dim = state_dim self.action_dim = action_dim self.max_action = max_action # Actor network self.actor = self.build_actor_network() self.actor_target = self.build_actor_network() self.actor_target.set_weights(self.actor.get_weights()) # Critic networks self.critic_1 = self.build_critic_network() self.critic_2 = self.build_critic_network() self.critic_1_target = self.build_critic_network() self.critic_2_target = self.build_critic_network() self.critic_1_target.set_weights(self.critic_1.get_weights()) self.critic_2_target.set_weights(self.critic_2.get_weights()) # Replay buffer self.buffer = ReplayBuffer() # Hyperparameters self.gamma = 0.99 self.tau = 0.005 self.alpha = 0.2 self.policy_noise = 0.2 * self.max_action self.noise_clip = 0.5 * self.max_action self.policy_freq = 2 self.batch_size = 256 # Optimizers self.actor_optimizer = tf.keras.optimizers.Adam(learning_rate=3e-4) self.critic_optimizer_1 = tf.keras.optimizers.Adam(learning_rate=3e-4) self.critic_optimizer_2 = tf.keras.optimizers.Adam(learning_rate=3e-4) def build_actor_network(self): inputs = tf.keras.layers.Input(shape=(self.state_dim,)) x = tf.keras.layers.Dense(256, activation='relu')(inputs) x = tf.keras.layers.Dense(256, activation='relu')(x) outputs = tf.keras.layers.Dense(self.action_dim, activation='tanh')(x) outputs = outputs * self.max_action return tf.keras.Model(inputs=inputs, outputs=outputs) def build_critic_network(self): state_inputs = tf.keras.layers.Input(shape=(self.state_dim,)) action_inputs = tf.keras.layers.Input(shape=(self.action_dim,)) x = tf.keras.layers.Concatenate()([state_inputs, action_inputs]) x = tf.keras.layers.Dense(256, activation='relu')(x) x = tf.keras.layers.Dense(256, activation='relu')(x) outputs = tf.keras.layers.Dense(1)(x) return tf.keras.Model(inputs=[state_inputs, action_inputs], outputs=outputs) def select_action(self, state): state = np.expand_dims(state, axis=0) action = self.actor(state).numpy()[0] return action def train(self): if len(self.buffer) < self.batch_size: return state_batch, action_batch, reward_batch, next_state_batch, done_batch = self.buffer.sample(self.batch_size) # Target actions next_action_batch = self.actor_target(next_state_batch).numpy() noise = np.random.normal(0, self.policy_noise, size=next_action_batch.shape) noise = np.clip(noise, -self.noise_clip, self.noise_clip) next_action_batch = next_action_batch + noise next_action_batch = np.clip(next_action_batch, -self.max_action, self.max_action) # Target Q values q1_target = self.critic_1_target([next_state_batch, next_action_batch]).numpy() q2_target = self.critic_2_target([next_state_batch, next_action_batch]).numpy() q_target = np.minimum(q1_target, q2_target) q_target = reward_batch + (1 - done_batch) * self.gamma * q_target # Update critics with tf.GradientTape(persistent=True) as tape: q1 = self.critic_1([state_batch, action_batch]) q2 = self.critic_2([state_batch, action_batch]) critic_loss_1 = tf.reduce_mean(tf.square(q1 - q_target)) critic_loss_2 = tf.reduce_mean(tf.square(q2 - q_target)) grad_1 = tape.gradient(critic_loss_1, self.critic_1.trainable_variables) grad_2 = tape.gradient(critic_loss_2, self.critic_2.trainable_variables) self.critic_optimizer_1.apply_gradients(zip(grad_1, self.critic_1.trainable_variables)) self.critic_optimizer_2.apply_gradients(zip(grad_2, self.critic_2.trainable_variables)) # Update actor with tf.GradientTape() as tape: policy_action = self.actor(state_batch) actor_loss = -tf.reduce_mean(self.critic_1([state_batch, policy_action])) actor_loss += self.alpha * tf.reduce_mean(tf.math.log(self.actor(state_batch) + 1e-6)) grad = tape.gradient(actor_loss, self.actor.trainable_variables) self.actor_optimizer.apply_gradients(zip(grad, self.actor.trainable_variables)) # Update target networks self.actor_target.set_weights(self.tau * np.array(self.actor.get_weights()) + (1 - self.tau) * np.array(self.actor_target.get_weights())) self.critic_1_target.set_weights(self.tau * np.array(self.critic_1.get_weights()) + (1 - self.tau) * np.array(self.critic_1_target.get_weights())) self.critic_2_target.set_weights(self.tau * np.array(self.critic_2.get_weights()) + (1 - self.tau) * np.array(self.critic_2_target.get_weights())) def save_model(self, path): self.actor.save_weights(path + 'actor') self.actor_target.save_weights(path + 'actor_target') self.critic_1.save_weights(path + 'critic_1') self.critic_2.save_weights(path + 'critic_2') self.critic_1_target.save_weights(path + 'critic_1_target') self.critic_2_target.save_weights(path + 'critic_2_target') def load_model(self, path): self.actor.load_weights(path + 'actor') self.actor_target.load_weights(path + 'actor_target') self.critic_1.load_weights(path + 'critic_1') self.critic_2.load_weights(path + 'critic_2') self.critic_1_target.load_weights(path + 'critic_1_target') self.critic_2_target.load_weights(path + 'critic_2_target') ``` 在这个代码中，我们定义了一个名为`TD3_SAC`的类，它包括了一个actor网络，两个critic网络（分别对应Q1和Q2），以及它们各自的target网络。我们还定义了一个replay buffer，用于存储样本。 在训练过程中，我们首先从replay buffer中采样一批样本，并计算目标Q值和目标动作。然后，我们使用这些样本更新critic网络的参数。接下来，我们使用actor网络和当前状态计算出一个动作，并用critic网络计算出该动作的Q值。我们使用这个Q值更新actor网络的参数。最后，我们使用soft更新方法更新target网络的参数。 在实践中，您可能需要根据您的具体问题调整超参数，以获得更好的性能。除此之外，您还可以使用其他技巧，如延迟更新、target policy smoothing等，以进一步改进算法的性能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值