REINFORCE算法

1. 算法原理

这是一种策略学习算法。
策略学习的关键点是使用策略梯度定理，求取优化目标$J(\mathbf{\theta })$最大值。
$$J(\mathbf{\theta })={\mathbb{E}}_S\left[V_{\pi }(S)\right]$$

这就需要用到策略梯度定理，对于目标函数更新$\theta$做梯度上升。
而在实际应用中，通常使用近似策略梯度，使用蒙特卡洛抽样计算得到的随机梯度来代替原目标函数梯度。
随机梯度表达式为:
$$\mathbf{g}(s,a;\mathbf{\theta })\triangleq Q_{\pi }(s,a)\cdot {\nabla }_{\mathbf{\theta }}\ln \pi (a\mid s;\mathbf{\theta })$$

随后，依照随机梯度做梯度上升更新$\mathbf{\theta }$，也就是$\mathbf{\theta }\leftarrow \mathbf{\theta }+\beta \ast \mathbf{g}(s,a;\mathbf{\theta })$
然而在实际情况下随机梯度中的$Q_{\pi }(s,a)$一项并不能被获取，由此就引申出了两种估计方法，分别是REINFORCE与Actor-Critic。
REINFORCE算法用实际观测的回报$u_t$近似估计动作价值函数$Q_{\pi }(s,a)$，即将随机梯度更换为
$$\tilde{\mathbf{g}}\left(s_t,a_t;\mathbf{\theta }\right)=u_t\cdot {\nabla }_{\mathbf{\theta }}\ln \pi \left(a_t\mid s_t;\mathbf{\theta }\right)$$

2. 算法伪代码

翻译：当前策略网络控制agent玩完一遍全流程，获得所有的三元组$s_i,a_i,r_i$，随后计算回报值$u_t$，然后计算梯度${\nabla }_{\mathbf{\theta }}\ln \pi \left(a_t\mid s_t;{\mathbf{\theta }}_{now}\right)$，按照梯度上升更新$\mathbf{\theta }$，${\mathbf{\theta }}_{\text{new }}\leftarrow {\mathbf{\theta }}_{\text{now }}+\beta \cdot {\sum }_{t=1}^n{\gamma }^{t-1}\cdot \underset{\text{即随机梯度 }\tilde{\mathbf{g}}\left(s_t,a_t;{\mathbf{\theta }}_{\text{now }}\right)}{\underbrace{u_t\cdot {\nabla }_{\mathbf{\theta }}\ln \pi \left(a_t\mid s_t;{\mathbf{\theta }}_{\text{now }}\right)}}$。

3. 算法关键代码

class REINFORCE:
    def __init__(self, state_dim, hidden_dim, action_dim, learning_rate, gamma, device):
        self.policy_net = PolicyNet(state_dim, hidden_dim,action_dim).to(device)
        self.optimizer = torch.optim.Adam(self.policy_net.parameters(),lr=learning_rate)  # 使用Adam优化器
        self.gamma = gamma  # 折扣因子
        self.device = device
 
    def take_action(self, state):  # 根据动作概率分布随机采样
        state = torch.tensor([state], dtype=torch.float).to(self.device)
        probs = self.policy_net(state)
        action_dist = torch.distributions.Categorical(probs)
        action = action_dist.sample()
        return action.item()
 
    def update(self, transition_dict):
        reward_list = transition_dict['rewards']
        state_list = transition_dict['states']
        action_list = transition_dict['actions']
 
        G = 0
        self.optimizer.zero_grad()
        for i in reversed(range(len(reward_list))):  # 从最后一步算起,越靠后需要乘的gamma次数越高
            reward = reward_list[i]
            state = torch.tensor([state_list[i]],dtype=torch.float).to(self.device)
            action = torch.tensor([action_list[i]]).view(-1, 1).to(self.device)
            log_prob = torch.log(self.policy_net(state).gather(1, action))  # ln(π(at|st;θ))
            G = self.gamma * G + reward
            loss = -log_prob * G  # 每一步的损失函数，随机梯度g(at|st;θ)
            loss.backward()  # 反向传播计算梯度
        self.optimizer.step()  # 计算完所有的随机梯度与ut乘积和后，梯度下降（前面加负号了）

4. 算法特点

同策略（on-policy）算法，目标策略与行为策略相同，不能够使用经验回放。