Policy gradient

1. 1

   En klasse af reinforcement learning-algoritmer, der estimerer gradienten af den forventede belønning med hensyn til policy-parametrene og opdaterer parametrene i gradientens retning.

   • Policy gradient-metoder er særligt effektive i miljøer med kontinuerte handlingsrum, hvor traditionelle Q-læringsmetoder har svært ved at finde den optimale handling. — Sutton & Barto, Reinforcement Learning: An Introduction, 2018
   • REINFORCE-algoritmen er en af de simpleste policy gradient-metoder og bruger Monte Carlo-estimater af afkastet. — Williams, Simple Statistical Gradient-Following Algorithms for Connectionist Reinforcement Learning, 1992
2. 2

   En specifik algoritme inden for denne klasse, typisk REINFORCE, der opdaterer policyen baseret på en hel episode.

   • I denne implementering anvendes en policy gradient-algoritme med en baseline for at reducere variansen. — OpenAI Spinning Up, 2018

Policy gradient-metoder bruges typisk i kontinuerlige handlingsrum og stokastiske omgivelser, såsom robotstyring, spil og naturlig sprogbehandling. De er særligt nyttige, når handlinger er højdimensionelle eller kontinuerte, og når policyen skal være stokastisk.

∇J(θ) = E_{τ~πθ}[∑_{t=0}^{T} ∇log πθ(a_t|s_t) · G_t]

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

class PolicyNet(nn.Module):
    def __init__(self, n_obs, n_actions):
        super().__init__()
        self.fc = nn.Sequential(nn.Linear(n_obs, 128), nn.ReLU(), nn.Linear(128, n_actions), nn.Softmax(dim=-1))
    def forward(self, x):
        return self.fc(x)

def reinforce(env, policy, optimizer, episodes=1000, gamma=0.99):
    for episode in range(episodes):
        obs = env.reset()
        log_probs, rewards = [], []
        done = False
        while not done:
            obs_t = torch.FloatTensor(obs).unsqueeze(0)
            probs = policy(obs_t)
            m = torch.distributions.Categorical(probs)
            action = m.sample()
            log_prob = m.log_prob(action)
            obs, reward, done, _ = env.step(action.item())
            log_probs.append(log_prob)
            rewards.append(reward)
        returns = []
        G = 0
        for r in reversed(rewards):
            G = r + gamma * G
            returns.insert(0, G)
        returns = torch.tensor(returns)
        loss = -sum(log_prob * G for log_prob, G in zip(log_probs, returns))
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

Simpel REINFORCE-implementering i PyTorch, der opdaterer policyen efter hver episode.

Sammensat af 'policy' (handlingsstrategi) og 'gradient' (hældning). Betegnelsen opstod i 1990'erne i forbindelse med REINFORCE-algoritmen.

• Reinforcement Learning: An Introduction (Sutton & Barto, 2018)
• Simple Statistical Gradient-Following Algorithms for Connectionist Reinforcement Learning (Williams, 1992)