一图看懂Policy Gradients深度强化学习算法


前言

基于Policy Gradients(策略梯度法,后文简称PG)的深度强化学习方法,思想上与基于Q-learning的系列算法有本质的不同,下面本博客争取用简洁的语言,清晰的图表对PG深度强化学习算法进行阐述,帮助初学者更好地理解算法。

一、PG深度强化学习算法的产生动机?

想要了解PG深度强化学习算法为什么会产生,需要知道在这之前诞生的Q-learning及其系列算法(如:DQN[参考这里],Double DQN等),Q系列算法在每一步做出行动(action)之后,都要计算收益(reward),而且一般需要计算两次,一次是估计收益,一次是现实收益,两者之间的差距(gap)被视为深度神经网络的loss值,从而用于更新神经网络的参数 θ \theta θ

而现实生活中,很多决策的行动空间是高维甚至连续(无限)的,比如自动驾驶中,汽车下一个决策中方向盘的行动空间,就是一个从[-900°,900°](假设方向盘是两圈半打满)的无限空间中选一个值,如果我们用Q系列算法来进行学习,则需要对每一个行动都计算一次reward,那么对无限行动空间而言,哪怕是把行动空间离散化,针对每个离散行动计算一次reward的计算成本也是当前算力所吃不消的。这是对Q系列算法提出的第一个挑战:无法遍历行动空间中所有行动的reward值。

此外,现实中的决策往往是带有多阶段属性的,说白了就是:“不到最后时刻不知输赢”。以即时策略游戏(如:星际争霸,或者国内流行的王者荣耀)为例,玩家的输赢只有在最后游戏结束时才能知晓,谁也没法在游戏进行过程中笃定哪一方一定能够赢。甚至有可能发生:某个玩家的每一步行动看起来都很傻,但是最后却能够赢得比赛,比如,Dota游戏中,有的玩家虽然死了很多次,己方的塔被拆了也不管,但是却靠着偷塔取胜(虽然这种行为可能是不受欢迎的)。诸如此类的情形就对Q系列算法提出了第二个挑战,Agent每执行一个动作(action)之后的奖励(reward)难以确定,这就导致Q值无法更新。

那么,难道深度强化学习就不能处理诸如上述两类情形的问题了吗?答案当然是否定的,这就衍生出了基于PG的系列深度强化学习算法[1]。下面我将就最原始,最简单的PG深度强化学习算法进行介绍,了解之后就可以进阶更高级的算法了。

二、算法原理

算法原理
上图所示的就是最简单的PG强化学习算法原理了,最关键的部分其实就是神经网络更新梯度: α ∇ θ log ⁡ π θ ( s t , a t ) v t \alpha {\nabla _\theta }\log {\pi _\theta }\left( { {s_t},{a_t}} \right){v_t} αθlogπθ(st,at

SAC(Soft Actor-Critic)算法是一种基于深度强化学习算法,它可以用于连续动作空间的强化学习问题。SAC算法是由Tuomas Haarnoja等人于2018年提出的,其主要思想是在强化学习的过程中引入熵的概念,使得智能体的策略更加多样化和探索性。 SAC算法的基本原理是通过学习一个策略网络,使得智能体可以在环境中获得最大的奖励。SAC算法的策略网络由两个部分组成:一个是Actor网络,用于生成动作;另一个是Critic网络,用于估计当前状态的价值。 SAC算法的损失函数包括三个部分:策略损失、Q值损失和熵损失。策略损失用于优化Actor网络,Q值损失用于优化Critic网络,熵损失用于增加策略的探索性。 SAC算法的伪代码如下: 1. 初始化Actor网络和Critic网络的参数; 2. 初始化目标网络的参数; 3. 初始化策略优化器和Critic优化器的参数; 4. 重复执行以下步骤: a. 从环境中采样一批数据; b. 计算动作的熵; c. 计算Q值和策略损失; d. 计算熵损失; e. 更新Actor网络和Critic网络的参数; f. 更新目标网络的参数; 5. 直到达到停止条件。 SAC算法的代码实现可以使用Python和TensorFlow等工具完成。以下是SAC算法的Python代码示例: ``` import tensorflow as tf import numpy as np class SAC: def __init__(self, obs_dim, act_dim, hidden_size, alpha, gamma, tau): self.obs_dim = obs_dim self.act_dim = act_dim self.hidden_size = hidden_size self.alpha = alpha self.gamma = gamma self.tau = tau # 创建Actor网络 self.actor = self._create_actor_network() self.target_actor = self._create_actor_network() self.target_actor.set_weights(self.actor.get_weights()) # 创建Critic网络 self.critic1 = self._create_critic_network() self.critic2 = self._create_critic_network() self.target_critic1 = self._create_critic_network() self.target_critic2 = self._create_critic_network() self.target_critic1.set_weights(self.critic1.get_weights()) self.target_critic2.set_weights(self.critic2.get_weights()) # 创建优化器 self.actor_optimizer = tf.keras.optimizers.Adam(self.alpha) self.critic_optimizer1 = tf.keras.optimizers.Adam(self.alpha) self.critic_optimizer2 = tf.keras.optimizers.Adam(self.alpha) # 创建Actor网络 def _create_actor_network(self): inputs = tf.keras.layers.Input(shape=(self.obs_dim,)) x = tf.keras.layers.Dense(self.hidden_size, activation='relu')(inputs) x = tf.keras.layers.Dense(self.hidden_size, activation='relu')(x) outputs = tf.keras.layers.Dense(self.act_dim, activation='tanh')(x) model = tf.keras.Model(inputs=inputs, outputs=outputs) return model # 创建Critic网络 def _create_critic_network(self): inputs = tf.keras.layers.Input(shape=(self.obs_dim + self.act_dim,)) x = tf.keras.layers.Dense(self.hidden_size, activation='relu')(inputs) x = tf.keras.layers.Dense(self.hidden_size, activation='relu')(x) outputs = tf.keras.layers.Dense(1)(x) model = tf.keras.Model(inputs=inputs, outputs=outputs) return model # 选择动作 def select_action(self, obs): action = self.actor(obs)[0] return action.numpy() # 更新网络参数 def update(self, obs, action, reward, next_obs, done): with tf.GradientTape(persistent=True) as tape: # 计算动作的熵 action_prob = self.actor(obs) log_prob = tf.math.log(action_prob + 1e-10) entropy = -tf.reduce_sum(action_prob * log_prob, axis=-1) # 计算Q值损失 target_action_prob = self.target_actor(next_obs) target_q1 = self.target_critic1(tf.concat([next_obs, target_action_prob], axis=-1)) target_q2 = self.target_critic2(tf.concat([next_obs, target_action_prob], axis=-1)) target_q = tf.minimum(target_q1, target_q2) target_q = reward + self.gamma * (1 - done) * target_q q1 = self.critic1(tf.concat([obs, action], axis=-1)) q2 = self.critic2(tf.concat([obs, action], axis=-1)) critic_loss1 = tf.reduce_mean((target_q - q1) ** 2) critic_loss2 = tf.reduce_mean((target_q - q2) ** 2) # 计算策略损失 action_prob = self.actor(obs) q1 = self.critic1(tf.concat([obs, action_prob], axis=-1)) q2 = self.critic2(tf.concat([obs, action_prob], axis=-1)) q = tf.minimum(q1, q2) policy_loss = tf.reduce_mean(entropy * self.alpha - q) # 计算熵损失 entropy_loss = tf.reduce_mean(-entropy) # 更新Actor网络 actor_grads = tape.gradient(policy_loss, self.actor.trainable_variables) self.actor_optimizer.apply_gradients(zip(actor_grads, self.actor.trainable_variables)) # 更新Critic网络 critic_grads1 = tape.gradient(critic_loss1, self.critic1.trainable_variables) self.critic_optimizer1.apply_gradients(zip(critic_grads1, self.critic1.trainable_variables)) critic_grads2 = tape.gradient(critic_loss2, self.critic2.trainable_variables) self.critic_optimizer2.apply_gradients(zip(critic_grads2, self.critic2.trainable_variables)) # 更新目标网络 self._update_target_network(self.target_actor, self.actor, self.tau) self._update_target_network(self.target_critic1, self.critic1, self.tau) self._update_target_network(self.target_critic2, self.critic2, self.tau) return critic_loss1.numpy(), critic_loss2.numpy(), policy_loss.numpy(), entropy_loss.numpy() # 更新目标网络参数 def _update_target_network(self, target_network, network, tau): target_weights = target_network.get_weights() network_weights = network.get_weights() for i in range(len(target_weights)): target_weights[i] = tau * network_weights[i] + (1 - tau) * target_weights[i] target_network.set_weights(target_weights) ``` 以上就是SAC算法的原理及Python代码实现。需要注意的是,SAC算法的实现需要根据具体的问题进行调整和修改。
评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值