policy gradient-algoritme

1. 1

   En klasse af reinforcement learning-algoritmer, der optimerer en parametriseret politik ved at følge gradienten af den forventede belønning. Dette inkluderer REINFORCE, PPO, TRPO, A2C/A3C og andre.

   • Proximal Policy Optimization (PPO) er en policy gradient-algoritme, der begrænser politikopdateringen for at sikre stabile trin. — Schulman et al., 2017
   • Policy gradient-algoritmer er særligt effektive i miljøer med kontinuerlige handlingsrum, fordi de direkte kan modellere sandsynlighedsfordelinger over handlinger. — Sutton & Barto, 2018
2. 2

   Specifikt den gradientestimator, der beregnes som gennemsnittet over episoder af summen af log-sandsynligheder for de valgte handlinger ganget med den observerede afkastning (REINFORCE). Denne estimator er upartisk men har høj varians.

   • REINFORCE-algoritmen bruger den simpleste policy gradient-estimator: ∇θ J(θ) ≈ 1/N Σ_{i=1}^N Σ_{t=0}^{T_i} ∇θ log πθ(a_{i,t}|s_{i,t}) · G_{i,t}. — Williams, 1992

Policy gradient-algoritmer bruges især i kontinuerlige handlingsrum og stokastiske politikker, hvor værdiebaserede metoder er vanskelige. De anvendes ofte i robotstyring, spil (fx AlphaGo) og dialogsystemer. Populære varianter inkluderer REINFORCE, PPO og A3C.

∇θ J(θ) = Eπθ [ ∇θ log πθ(a|s) · Qπθ(s,a) ]

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

class PolicyNetwork(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, obs):
        return self.fc(obs)

def reinforce(policy, env, optimizer, gamma=0.99):
    obs, _ = env.reset()
    log_probs, rewards = [], []
    done = False
    while not done:
        obs_t = torch.tensor(obs, dtype=torch.float32)
        probs = policy(obs_t.unsqueeze(0))
        dist = torch.distributions.Categorical(probs)
        action = dist.sample()
        log_prob = dist.log_prob(action)
        obs, reward, done, _, _ = env.step(action.item())
        log_probs.append(log_prob)
        rewards.append(reward)
    G = 0
    returns = []
    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()

Enkel REINFORCE-implementering i PyTorch. Politikken er et neuralt netværk, der outputter sandsynligheder for hver handling. Gradienten beregnes som log-sandsynlighed ganget med afkastet.

Policy henviser til den handlingsstrategi (politik) agenten følger; gradient henviser til den matematiske gradient, der angiver retningen for den største stigning; algoritme betyder en trinvis fremgangsmåde. Termen opstod i 1990'erne med REINFORCE-algoritmen (Williams, 1992).

• Simple Statistical Gradient-Following Algorithms for Connectionist Reinforcement Learning (Williams, 1992)
• Reinforcement Learning: An Introduction (Sutton & Barto, 2018)
• Proximal Policy Optimization Algorithms (Schulman et al., 2017)