Lär Er AI med Python · Lektion

Policygradientmetoder: REINFORCE

Satsen om policygradienter, REINFORCE-algoritmen, subtraktion av baslinje, variansreduktion.

Lektion 1 av 413 steg

Policygradientmetoder: REINFORCE är en gratis lektion i Lär Er AI med Python på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Lär Er AI med Python, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Lär Er AI med Python innehåller totalt 4 lektioner.

Värdebaserad kontra policybaserad RL

Vissa RL-metoder lär sig värdet av handlingar och agerar sedan girigt. Metoder med policy gradient lär sig i stället policyn direkt: en funktion som ger sannolikheter för handlingar. Detta hanterar kontinuerliga handlingar och stokastiska policyer på ett naturligt sätt.

Policyn pi(a|s)

En parameteriserad policy pi(a|s, theta) mappar ett tillstånd till en sannolikhetsfördelning över handlingar, med parametrarna theta (ett neuralt nätverk). Träningen justerar theta så att handlingar som ger större belöning föredras.

class Policy(nn.Module):
    def __init__(self, obs_dim, n_actions):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(obs_dim, 128), nn.ReLU(),
            nn.Linear(128, n_actions)
        )
    def forward(self, s):
        return torch.softmax(self.net(s), dim=-1)

Sampla handlingar

Eftersom policyn är en fördelning samplar Ni en handling i stället för att välja den största. Sampling ger utforskning och gör policyn stokastisk.

probs = policy(state)
dist = torch.distributions.Categorical(probs)
action = dist.sample()
log_prob = dist.log_prob(action)

Samla in en bana

En episod (trajectory) är sekvensen av tillstånd, handlingar och belöningar från början till slut. Ni samlar in en fullständig bana genom att agera i miljön tills den avslutas.

states, actions, rewards, log_probs = [], [], [], []
state, _ = env.reset()
done = False
while not done:
    probs = policy(torch.tensor(state).float())
    dist = torch.distributions.Categorical(probs)
    a = dist.sample()
    state, r, term, trunc, _ = env.step(a.item())
    rewards.append(r); log_probs.append(dist.log_prob(a))
    done = term or trunc

Den diskonterade avkastningen G_t

Avkastningen G_t är den totala framtida belöningen från tidpunkt t, diskonterad med gamma så att belöningar närmare i tiden väger tyngre. Den visar hur bra handlingarna från steg t och framåt faktiskt utföll.

def returns(rewards, gamma=0.99):
    G, out = 0, []
    for r in reversed(rewards):
        G = r + gamma * G
        out.insert(0, G)
    return torch.tensor(out)

REINFORCE-målfunktionen

REINFORCE utför gradientstigning på den förväntade avkastningen. Intuitivt innebär det att sannolikheten ökas för handlingar som ledde till hög avkastning, medan den minskas för handlingar som ledde till låg avkastning. Varje handling viktas med dess G_t.

Policygradienten

Förlustfunktionen är -sum(log_prob * G_t). Minustecknet omvandlar gradientstigning till gradientnedstigning, så att optimeraren maximerar avkastningen. Handlingar med hög avkastning får sin log-sannolikhet höjd.

G = returns(rewards)
loss = -torch.sum(torch.stack(log_probs) * G)

Uppdatering av policyn

Gör backpropagation och utför ett optimeringssteg som vanligt. En uppdatering använder en hel trajectory, som sedan kasseras (REINFORCE är on-policy: endast data från den aktuella policyn används).

optimizer.zero_grad()
loss.backward()
optimizer.step()

Problemet med hög varians

Vanilla REINFORCE är notoriskt instabilt och har hög varians: avkastningen varierar kraftigt mellan episoder, så gradientskattningarna blir brusiga och inlärningen långsam och ryckig.

Baseline för variansreduktion

Om en baseline (till exempel den genomsnittliga avkastningen) subtraheras från G_t minskar variansen utan att göra gradienten snedvriden. Handlingar belönas för att vara bättre än förväntat, inte bara för att ha positiv avkastning.

baseline = G.mean()
advantage = G - baseline
loss = -torch.sum(torch.stack(log_probs) * advantage)

Varför REINFORCE är viktigt

REINFORCE är grunden för alla policygradientmetoder. Dess svagheter, hög varians och ineffektiv användning av sampel, motiverar actor-critic- och PPO-metoderna som ni får se härnäst.

Snabbtest

Testa era kunskaper om policygradienter.

Besvara frågan i den interaktiva lektionen

Repetition: REINFORCE

Ni har lärt er att parametrera en policy pi(a|s,theta), samla in trajectories, beräkna den diskonterade avkastningen G_t och utföra gradientstigning med förlustfunktionen -sum(log_prob * G_t). Ni har sett REINFORCE:s höga varians och hur en baseline minskar den.

Gratis att börja

Lär dig Python med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 53
Lektioner: 225

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Policygradientmetoder: REINFORCE” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lär Er AI med Python, inklusive ”Policygradientmetoder: REINFORCE”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Lär Er AI med Python innehåller totalt 4 lektioner.

Vad lär jag mig i ”Policygradientmetoder: REINFORCE”?

Satsen om policygradienter, REINFORCE-algoritmen, subtraktion av baslinje, variansreduktion. Ni övar på Lär Er AI med Python med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Lär Er AI med Python?

Du behöver inga förkunskaper. Utbildningen i Lär Er AI med Python på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Policygradientmetoder: REINFORCE”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Lär Er AI med Python-lektionen?

Ja. Varje Lär Er AI med Python-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Lär Er AI med Python