Das Gradiententheorem der Politik erklärt: Eine praktische Einführung

Warum sollten wir Gradientenmethoden verwenden?

Ein entscheidender Vorteil der Gradientenmethoden ist, dass sie mit komplexen Handlungsräumen umgehen können, in denen traditionelle wertorientierte Ansätze Schwierigkeiten haben.

Umgang mit hochdimensionalen Aktionsräumen

Wertbasierte Methoden, wie das Q-Learning, arbeiten mit der Schätzung der Wertfunktion für alle möglichen Aktionen. Das wird schwierig, wenn der Aktionsraum der Umwelt entweder kontinuierlich oder diskret, aber groß ist. 

Policy-Gradienten-Methoden parametrisieren die Politik und schätzen den Gradienten der kumulativen Belohnungen in Bezug auf diePolitikparameter. Sie nutzen diesen Gradienten, um die Strategie direkt zu optimieren, indem sie ihre Parameter aktualisieren. Daher können sie effizient mit hochdimensionalen oder kontinuierlichen Aktionsräumen umgehen. Policy-Gradienten sind auch die Grundlage für Reinforcement Learning using Human Feedback (RLHF) Methoden. 

Durch die Parametrisierung der Politik und die Anpassung ihrer Parameter auf Basis von Gradienten können Politikgradienten effizient mit kontinuierlichen und hochdimensionalen Aktionen umgehen. Dieser direkte Ansatz ermöglicht eine bessere Verallgemeinerung und flexiblere Erkundung, was ihn für Aufgaben wie die Steuerung von Robotern und andere komplexe Umgebungen geeignet macht.

Stochastische Strategien lernen

Gegeben eine Reihe von Beobachtungen: 

• Eine deterministische Richtlinie legt fest, welche Aktion der Agent ausführt. 
• Eine stochastische Strategie enthält eine Reihe von Aktionen und die Wahrscheinlichkeit, dass der Agent jede Aktion wählt. 

Wenn du eine stochastische Politik verfolgst, kann dieselbe Beobachtung dazu führen, dass du in verschiedenen Iterationen unterschiedliche Aktionen wählst. Dies fördert die Erkundung des Aktionsraums und verhindert, dass die Politik in lokalen Optima stecken bleibt. Aus diesem Grund sind stochastische Strategien in Umgebungen nützlich, in denen die Erkundung von entscheidender Bedeutung ist, um den Weg zu finden, der zur maximalen Rendite führt. 

Bei richtlinienbasierten Methoden werden die Ergebnisse der Richtlinien in eine Wahrscheinlichkeitsverteilung umgewandelt, wobei jeder möglichen Aktion eine Wahrscheinlichkeit zugeordnet wird. Der Agent wählt eine Aktion, indem er eine Stichprobe aus dieser Verteilung nimmt, wodurch es möglich ist, eine stochastische Politik umzusetzen. Policy-Gradient-Methoden kombinieren also Exploration mit Exploitation, was in Umgebungen mit komplexen Belohnungsstrukturen nützlich ist. 

Herleitung des Theorems des politischen Gradienten

Bevor du dich mit der Herleitung beschäftigst, ist es wichtig, die mathematische Notation und die Schlüsselkonzepte, die im gesamten Beweis verwendet werden, festzulegen.

Mathematische Notation und Präliminarien

Wie in einem früheren Abschnitt erwähnt, besagt das Policy-Gradient-Theorem, dass die Ableitung der erwarteten Rendite die Erwartung des Produkts aus der Rendite und der Ableitung des Logarithmus der Policy ist. 

Bevor wir das Theorem des politischen Gradienten ableiten, führen wir die Notation ein:

• E[X] bezieht sich auf den probabilistischen Erwartungswert einer Zufallsvariablen X.
• Mathematisch gesehen wird die Strategie als Wahrscheinlichkeitsmatrix ausgedrückt, die die Wahrscheinlichkeit angibt, mit der verschiedene Aktionen auf der Grundlage verschiedener Beobachtungen gewählt werden. Eine Politik wird in der Regel als parametrisierte Funktion modelliert, wobei die Parameter wie folgt dargestellt werden θ.
• _πθ bezieht sich auf eine Politik, die durch θparametrisiert ist. In der Praxis sind diese Parameter die Gewichte des neuronalen Netzes, das die Politik modelliert. 
• Die Flugbahn, τbezieht sich auf eine Abfolge von Zuständen, die in der Regel von einem zufälligen Anfangszustand bis zum aktuellen Zeitschritt oder dem Endzustand reicht.
• ∇_θf bezieht sich auf die Steigung einer Funktion f in Bezug auf einen oder mehrere Parameter θ.
• J(π_θ) bezieht sich auf die erwartete Rendite, die der Agent mit der Politik _πθ erzielt. Dies ist auch die Zielfunktion für den Gradientenanstieg. 
• Die Umwelt gibt in jedem Zeitschritt eine Belohnung, die von der Aktion des Agenten abhängt. Die Rendite bezieht sich auf die kumulierten Belohnungen vom Ausgangszustand bis zum aktuellen Zeitschritt. 
• R(τ) bezieht sich auf die Rendite, die über die Trajektorie τ.

Ableitungsschritte

Wir zeigen, wie man das Gradiententheorem aus ersten Prinzipien ableitet und beweist, indem wir mit der Erweiterung der Zielfunktion beginnen und den Trick der logarithmischen Ableitung anwenden. 

Die Zielfunktion (Gleichung 1)

Die Zielfunktion bei der Policy-Gradient-Methode ist die Rendite 

J, die sich durch das Verfolgen der Flugbahn auf der Grundlage der Politik π , ausgedrückt durch die Parameter θ, ergeben. Diese Zielfunktion wird wie folgt angegeben: 

In der obigen Gleichung: 

• Die linke Seite (LHS) ist die erwartete Rendite, die durch das Befolgen der Politik erzielt wird π_θ.
• Die rechte Seite (RHS) ist die Erwartung (über die Flugbahn τ die durch das Befolgen der Politik π_θ in jedem Schritt) der Erträge R(τ) die über die Trajektorie τ.

Das Differential der Zielfunktion (Gleichung 2)

Differenzieren (in Bezug auf θ) beider Seiten der obigen Gleichung ergibt:

Die Steigung der Erwartung (Gleichung 3)

Der Erwartungswert (auf der rechten Seite) kann als Integral über das Produkt von ausgedrückt werden: 

• Die Wahrscheinlichkeit, einer Flugbahn zu folgen τ
• Die Renditen, die über die Trajektorie τ

Die rechte Seite von Gleichung 2 wird also wie folgt umformuliert: 

Die Steigung eines Integrals ist gleich dem Integral der Steigung. Im obigen Ausdruck können wir also den Gradienten ∇_θ unter das Vorzeichen des Integrals stellen. Die RHS wird also: 

Gleichung 2 kann also wie folgt umgeschrieben werden:

Die Wahrscheinlichkeit der Flugbahn (Gleichung 4)

Wir werfen nun einen genaueren Blick auf P(τ|θ), die Wahrscheinlichkeit, dass der Agent bei gegebenen Politikparametern θ (und damit bei der Politik _πθ) der Trajektorie τ folgt. Eine Flugbahn besteht aus einer Reihe von Schritten. So: 

• Die Wahrscheinlichkeit, eine Flugbahn zu erhalten τ ist das Produkt aus:
• Die Wahrscheinlichkeit, alle Einzelschritte zu befolgen. 

• In dem Zeitschritt tgeht der Agent vom Zustand s in den Zustand s_t+1 indem er die Aktion a_t. Die Wahrscheinlichkeit, dass dies geschieht, ist das Produkt aus:
• Die Wahrscheinlichkeit, dass die Politik eine Aktion vorhersagt a_t im Zustand s_t
• Die Wahrscheinlichkeit, in den Zustand zu gelangen s_t+1 bei einer Aktion a_t und Zustand s_t

Ausgehend von einem Anfangszustand s₀die Wahrscheinlichkeit, dass der Agent der Trajektorie τ basierend auf der Politik π_θ ist gegeben als:

Um die Sache zu vereinfachen, wollen wir das Produkt in der rechten Spalte als Summe ausdrücken. Wir nehmen also den Logarithmus auf beiden Seiten der obigen Gleichung:

Die Ableitung der Log-Wahrscheinlichkeit (Gleichung 5) 

Wir nehmen nun die Ableitung (nach θ) der logarithmischen Wahrscheinlichkeit in der obigen Gleichung.

Auf der rechten Seite der obigen Gleichung: 

• Der erste Term log ρ₀(s₀) ist konstant in Bezug auf θ. Die Ableitung ist also 0. 
• Der erste Term innerhalb der Summation P(s_t+1|s_t, a_t) ist auch unabhängig von θ und seine Ableitung nach θ ist ebenfalls 0.

Wenn wir die oben genannten Nullterme aus der Gleichung entfernen, bleibt (Gleichung 5) übrig: 

Erinnere dich an Gleichung 2, dass: 

Gleichung 5 wertet den Logarithmus des ersten Teils der rechten Seite von Gleichung 2 aus. Wir müssen die Ableitung eines Terms mit seinem Logarithmus in Beziehung setzen. Dazu verwenden wir die Kettenregel und den Trick mit der logarithmischen Ableitung. 

Der Trick mit der Logarithmusableitung

Wir machen einen Umweg und nutzen die Regeln der Infinitesimalrechnung, um ein Ergebnis herzuleiten, mit dem wir die vorherige Gleichung vereinfachen und für Berechnungsmethoden nutzbar machen wollen. 

In der Infinitesimalrechnung kann die Ableitung eines Logarithmus wie folgt ausgedrückt werden: 

Durch Umstellen der obigen Gleichung ergibt sich also die Ableitung von x durch die Ableitung des Logarithmus von x ausgedrückt werden:

Dies wird manchmal auch als Trick mit der logarithmischen Ableitung bezeichnet. 

Die Kettenregel

Nach der Kettenregel gilt für z(y) als eine Funktion von y, wobei y selbst eine Funktion von θ ist, y(θ), die Ableitung von z in Bezug auf θ ist gegeben als:

In diesem Fall, y(θ) steht für P(θ) und z(y) steht für log(y). Thus, 

Die Anwendung der Kettenregel

Aus der Infinitesimalrechnung wissen wir, dass d(log(y)) / dy = 1/y. Verwende dies im ersten Ausdruck der rechten Seite oben. 

verschieben y auf die linke Seite und verwende die Notation:

y steht für P(θ). Die obige Gleichung ist also gleichbedeutend mit: 

Anwendung des Tricks mit der logarithmischen Ableitung

Das obige Ergebnis ergibt den ersten Ausdruck der rechten Seite von Gleichung 2 (siehe unten).  

Mit dem Ergebnis auf der rechten Seite von Gleichung 2 erhalten wir: 

Wir ordnen die Terme unter dem RHS-Integral wie folgt um:

Ableitung des Endergebnisses

Beachte, dass der obige Ausdruck die Integralentwicklung eines Erwartungswertes enthält: ∫P(θ)∇logP(θ) = E[∇logP(θ)]

Die rechte Hand kann also als Erwartung ausgedrückt werden: 

Wir setzen die Ableitung der logarithmischen Wahrscheinlichkeit in den Ausdruck für die erwartete Belohnung ein: 

Setze in die obige Gleichung den Wert von ∇logP(θ) aus Gleichung 5 ein, um zu erhalten:

Dies ist der Ausdruck für den Gradienten der Belohnungsfunktion nach dem Policy-Gradient-Theorem. 

Die Intuition hinter dem politischen Gradienten

Policy-Gradienten-Methoden wandeln den Output der Policy in eine Wahrscheinlichkeitsverteilung um. Der Agent nimmt eine Stichprobe dieser Verteilung, um eine Aktion auszuwählen. Policy-Gradienten-Methoden passen die Policy-Parameter an. Das führt dazu, dass diese Wahrscheinlichkeitsverteilung in jeder Iteration aktualisiert wird. Die aktualisierte Wahrscheinlichkeitsverteilung hat eine höhere Wahrscheinlichkeit, Aktionen zu wählen, die zu höheren Belohnungen führen. 

Der Policy-Gradient-Algorithmus berechnet den Gradienten der erwarteten Rendite in Abhängigkeit von den Policy-Parametern. Indem er die Parameter der Strategie in Richtung dieses Gradienten verschiebt, erhöht der Agent die Wahrscheinlichkeit, dass er Aktionen wählt, die im Training zu höheren Belohnungen führen. 

Das bedeutet, dass Handlungen, die zu besseren Ergebnissen führen, in Zukunft mit größerer Wahrscheinlichkeit gewählt werden, wodurch die Politik schrittweise verbessert wird, um den langfristigen Nutzen zu maximieren.

Implementierung von Richtlinienverläufen in Python

Nachdem wir die grundlegenden Prinzipien von Policy-Gradienten besprochen haben, zeigen wir, wie sie mit PyTorch und Gymnasium umgesetzt werden können. 

Einrichten der Umgebung

Als ersten Schritt müssen wir gymnasium und einige unterstützende Bibliotheken wie NumPy und PyTorch installieren.

Um gymnasium und seine Abhängigkeiten auf einem Server oder einem lokalen Rechner zu installieren, führe aus:

$ pip install gymnasium 

Für die Installation mit einem Notebook wie Google Colab oder DataLab verwendest du: 

!pip install gymnasium

Du importierst diese Pakete innerhalb der Python-Umgebung:

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
import torch.distributions as distributions
import numpy as np
import gymnasium as gym  

Codierung eines einfachen Gradientenagenten

Erstelle eine Instanz der Umgebung mit der Methode .make().

env = gym.make('CartPole-v1')

Wie bei anderen Methoden des maschinellen Lernens verwenden wir ein neuronales Netzwerk, um den Policy Gradient Agent zu implementieren. 

CartPole-v1 ist eine einfache Umgebung, also entwerfen wir ein einfaches Netzwerk mit einer versteckten Schicht und 64 Neuronen. Die Dimension der Eingabeschicht entspricht den Dimensionen des Beobachtungsraums. Die Dimension der Ausgabeschicht entspricht der Größe des Aktionsraums in der Umgebung. Das Politiknetzwerk bildet also beobachtete Zustände auf Aktionen ab. Bei einer Beobachtung als Eingabe gibt das Netzwerk die vorhergesagte Aktion gemäß der Strategie aus. 

Der folgende Code implementiert das Policy-Netzwerk: 

class PolicyNetwork(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim, dropout):
        super().__init__()

        self.layer1 = nn.Linear(input_dim, hidden_dim)
        self.layer2 = nn.Linear(hidden_dim, output_dim)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x):
        x = self.layer1(x)
        x = self.dropout(x)
        x = F.relu(x)
        x = self.layer2(x)
        return x

Ausbildung des Agenten

Die Umwelt gibt in jedem Zeitschritt eine Belohnung, die vom Zustand und der Aktion des Agenten abhängt. Der Policy-Gradient-Ansatz besteht darin, einen Gradientenabstieg auf den kumulierten Belohnungen (Rendite) durchzuführen. Das Ziel ist es, die Gesamtrendite zu maximieren. 

Um die Rendite einer Episode zu berechnen, akkumulierst du (mit einem Abzinsungsfaktor) die Belohnungen aus allen Zeitschritten in dieser Episode. Außerdem ist es hilfreich, die Erträge zu normalisieren, um eine reibungslose und stabile Ausbildung zu gewährleisten. Der folgende Code zeigt, wie man das macht:

def calculate_stepwise_returns(rewards, discount_factor):
    returns = []
    R = 0

    for r in reversed(rewards):
        R = r + R * discount_factor
        returns.insert(0, R)
    returns = torch.tensor(returns)
    normalized_returns = (returns - returns.mean()) / returns.std()
    return normalized_returns

In jeder Iteration des Vorwärtsdurchlaufs führen wir die folgenden Schritte durch: 

• Führe den Agenten auf der Grundlage der aktuellen Richtlinie mit der Funktion .step() aus. Die Strategie sagt die Wahrscheinlichkeit voraus, dass die gewählte Aktion in jedem Zeitschritt ausgeführt wird.
• Erhalte die Belohnung von der Umwelt auf der Grundlage der Aktion des Agenten.
• Akkumuliere schrittweise Belohnungen und die logarithmischen Wahrscheinlichkeiten der Aktionen, bis der Agent einen Endzustand erreicht.

Der folgende Code implementiert den Vorwärtspass:

def forward_pass(env, policy, discount_factor):
    log_prob_actions = []
    rewards = []
    done = False
    episode_return = 0

    policy.train()
    observation, info = env.reset()

    while not done:
        observation = torch.FloatTensor(observation).unsqueeze(0)
        action_pred = policy(observation)
        action_prob = F.softmax(action_pred, dim = -1)
        dist = distributions.Categorical(action_prob)
        action = dist.sample()
        log_prob_action = dist.log_prob(action)

        observation, reward, terminated, truncated, info = env.step(action.item())
        done = terminated or truncated

        log_prob_actions.append(log_prob_action)
        rewards.append(reward)
        episode_return += reward

    log_prob_actions = torch.cat(log_prob_actions)
    stepwise_returns = calculate_stepwise_returns(rewards, discount_factor)

    return episode_return, stepwise_returns, log_prob_actions

Verwendung von Backpropagation und Gradient Ascent zur Aktualisierung der Strategie

Beim traditionellen maschinellen Lernen:

• Der Verlust bezieht sich auf die Differenz zwischen der prognostizierten und der tatsächlichen Leistung. 
• Wir minimieren den Verlust mithilfe des Gradientenabstiegs.

In RL:

• Der Verlust steht stellvertretend für die Menge, auf die der Gradientenabstieg (oder -aufstieg) angewendet werden soll. 
• Wir maximieren den Ertrag (kumulative Belohnungen) mithilfe des Gradientenanstiegs.
• Der erwartete Rückgabewert wird als Ersatz für den Verlust beim Gradientenabstieg verwendet. Der erwartete Rückgabewert ist das Produkt aus:
• Die erwarteten Erträge aus jedem Schritt mit 
• Die Wahrscheinlichkeit, in jedem Schritt die gesampelte Aktion zu wählen. 
• Bei der Anwendung der Backpropagation verwenden wir den negativen Wert des Verlustes. 

Der folgende Code berechnet den Verlust:

def calculate_loss(stepwise_returns, log_prob_actions):
    loss = -(stepwise_returns * log_prob_actions).sum()
    return loss

Ähnlich wie bei den üblichen Algorithmen für maschinelles Lernen führst du zur Aktualisierung der Strategie eine Backpropagation in Bezug auf die Verlustfunktion durch. Die folgende Methode update_policy() ruft die Methode calculate_loss() auf. Dann wird dieser Verlust durch Backpropagation verarbeitet, um die Parameter, d.h. die Modellgewichte des Policy-Netzwerks, zu aktualisieren. 

def update_policy(stepwise_returns, log_prob_actions, optimizer):
    stepwise_returns = stepwise_returns.detach()
    loss = calculate_loss(stepwise_returns, log_prob_actions)
    
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    return loss.item()

Die Ausbildungsschleife 

Wir verwenden die zuvor definierten Funktionen, um die Richtlinie zu trainieren. Bevor wir mit dem Training beginnen, brauchen wir: 

• Eine untrainierte Richtlinie, die als randomisierte Instanz der Klasse PolicyNetwork initialisiert wird. 
• Ein Optimierer, der den Adam-Algorithmus verwendet. 
• Hyperparameter für den Diskontfaktor, die Lernrate, die Dropout-Rate, die Belohnungsschwelle und die maximale Anzahl von Trainingsepochen. 

Wir durchlaufen die Trainingsschleife so lange, bis der durchschnittliche Ertrag die Belohnungsschwelle überschreitet. In jeder Iteration führen wir die folgenden Schritte aus: 

• Führe den Vorwärtspass für jede Episode einmal durch. Erfasse die logarithmische Wahrscheinlichkeit von Aktionen, die schrittweisen Renditen und die Gesamtrendite aus dieser Episode. Sammle die episodischen Erträge in einem Array. 
• Berechne den Verlust anhand der logarithmischen Wahrscheinlichkeiten und der schrittweisen Erträge. Führe die Backpropagation auf den Verlust aus. Nutze den Optimierer, um die Richtlinienparameter zu aktualisieren. 
• Überprüfe, ob die durchschnittliche Rendite über N_TRIALS die Belohnungsschwelle überschreitet .

Der folgende Code setzt diese Schritte um:

def main(): 
    MAX_EPOCHS = 500
    DISCOUNT_FACTOR = 0.99
    N_TRIALS = 25
    REWARD_THRESHOLD = 475
    PRINT_INTERVAL = 10
    INPUT_DIM = env.observation_space.shape[0]
    HIDDEN_DIM = 128
    OUTPUT_DIM = env.action_space.n
    DROPOUT = 0.5

    episode_returns = []

    policy = PolicyNetwork(INPUT_DIM, HIDDEN_DIM, OUTPUT_DIM, DROPOUT)

    LEARNING_RATE = 0.01
    optimizer = optim.Adam(policy.parameters(), lr = LEARNING_RATE)

    for episode in range(1, MAX_EPOCHS+1):
        episode_return, stepwise_returns, log_prob_actions = forward_pass(env, policy, DISCOUNT_FACTOR)
        _ = update_policy(stepwise_returns, log_prob_actions, optimizer)

        episode_returns.append(episode_return)
        mean_episode_return = np.mean(episode_returns[-N_TRIALS:])

        if episode % PRINT_INTERVAL == 0:
            print(f'| Episode: {episode:3} | Mean Rewards: {mean_episode_return:5.1f} |')

        if mean_episode_return >= REWARD_THRESHOLD:
            print(f'Reached reward threshold in {episode} episodes')
            break

Führe das Trainingsprogramm aus, indem du die Funktion main() aufrufst:

main()

Diese DataLab-Arbeitsmappe enthältdie obige Implementierung des Policy-Gradienten-Algorithmus. Du kannst ihn direkt ausführen oder ihn als Ausgangspunkt für die Modifizierung des Algorithmus verwenden.

Vorteile und Herausforderungen von Gradientenmethoden

Policy-Gradient-Methoden bieten mehrere Vorteile, wie z. B.:

• Umgang mit kontinuierlichen Aktionsräumen: Wertbasierte Methoden (wie Q-Learning) sind bei kontinuierlichen Aktionsräumen ineffizient, da sie Werte über den gesamten Aktionsraum schätzen müssen. Policy-Gradienten-Methoden können die Politik direkt anhand des Gradienten der erwarteten Erträge optimieren. Dieser Ansatz funktioniert gut bei kontinuierlichen Aktionsverteilungen. Daher sind Policy-Gradienten-Methoden für Aufgaben wie die Robotersteuerung geeignet, die auf kontinuierlichen Aktionsräumen basieren.
• Stochastische Politik: Policy-Gradient-Methoden können stochastische Strategien erlernen, die eine Wahrscheinlichkeit für die Auswahl jeder möglichen Aktion angeben. So kann der Agent eine Vielzahl von Aktionen ausprobieren und das Risiko, in lokalen Optima stecken zu bleiben, wird verringert. Sie hilft in komplexen Umgebungen, in denen der Agent den Aktionsraum erkunden muss, um die optimale Strategie zu finden. Die stochastische Natur hilft dabei, ein Gleichgewicht zwischen Exploration (das Ausprobieren neuer Aktionen) und Exploitation (das Auswählen der besten bekannten Aktionen) herzustellen, was in Umgebungen mit Unsicherheit oder spärlichen Belohnungen entscheidend ist.
• Direkte Richtlinienoptimierung: Politikgradienten optimieren die Politik direkt, anstatt Wertfunktionen zu verwenden. In kontinuierlichen oder hochdimensionalen Aktionsräumen kann die Annäherung von Werten für jede Aktion rechenintensiv werden. Daher sind richtlinienbasierte Methoden in solchen Umgebungen gut geeignet. 

Trotz ihrer vielen Vorteile haben politische Gradientenmethoden auch ihre Tücken:

• Hohe Varianz in den Gradientenschätzungen: Policy-Gradient-Methoden wählen Aktionen durch Stichproben aus einer Wahrscheinlichkeitsverteilung aus. Sie nehmen also eine Stichprobe, um die erwartete Rendite zu schätzen. Da der Stichprobenprozess von Natur aus zufällig ist, können die geschätzten Renditen in den nachfolgenden Iterationen eine hohe Varianz aufweisen. Dies kann es dem Agenten erschweren, effizient zu lernen, da die Aktualisierungen der Richtlinien zwischen den Iterationen stark schwanken können. 
• Instabilität während der Ausbildung:
• Policy-Gradienten-Methoden sind empfindlich gegenüber Hyperparametern wie dem. Wenn die Lernrate zu hoch ist, können die Aktualisierungen der Politikparameter zu groß sein, so dass das Training die optimalen Parameter verfehlt. Andererseits kann die Konvergenz langsam sein, wenn die Lernrate zu klein ist. 
• Politische Gradientenmethoden müssen ein Gleichgewicht zwischen Erkundung und Ausbeutung herstellen. Wenn der Agent nicht genug erkundet, kann es sein, dass er nicht in die Nähe der optimalen Strategie gelangt. Umgekehrt konvergiert er nicht auf die optimale Strategie, wenn er zu viel erforscht, sondern oszilliert im Aktionsraum herum. 
• Beispielhafte Ineffizienz: Policy-Gradient-Methoden schätzen die Rendite, indem sie jede Policy bis zur Beendigung durchlaufen und die Belohnungen aus jedem Schritt akkumulieren. Daher brauchen sie viele Interaktionen mit der Umgebung, um eine große Anzahl von Musterflugbahnen zu erstellen. Das ist ineffizient und teuer für Umgebungen mit großen Zustands- oder Aktionsräumen. 

Lösungen für Stabilität

Da Instabilität ein relativ häufiges Problem bei Policy-Gradienten-Methoden ist, haben die Entwickler verschiedene Lösungen zur Stabilisierung des Trainingsprozesses entwickelt. Im Folgenden stellen wir gemeinsame Lösungen für die Stabilisierung der Ausbildung mithilfe von Gradienten vor: 

Grundlinienfunktionen verwenden

Aufgrund ineffizienter Stichproben können die Gradienten der während der Trainingsiterationen geschätzten Renditen eine hohe Varianz aufweisen, was das Training instabil und langsam macht. Ein gängiger Ansatz zur Verringerung der Varianz ist die Verwendung von Basisfunktionen, wie z.B. die Advantage Actor-Critic (A2C) Methode. Die Idee ist, anstelle der geschätzten Rendite für die Zielfunktion einen Proxy (die Vorteilsfunktion) zu verwenden. 

Der Vorteil wird als Differenz zwischen der tatsächlichen Rendite aus der gesampelten Flugbahn und der erwarteten Rendite angesichts des Ausgangszustands berechnet. Bei diesem Ansatz wird die Wertfunktion als Erwartungswert von Zuständen und Zustands-Aktionspaaren verwendet. Indem der Verlust als Differenz zwischen der tatsächlichen Rendite und der erwarteten Rendite dargestellt wird, statt nur als Rendite, reduziert A2C die Varianz in der Verlustfunktion und damit auch in den Gradienten, wodurch das Training stabiler wird. 

Entropie-Regulierung verwenden

In bestimmten Umgebungen, z. B. solchen mit spärlichen Belohnungen (nur sehr wenige Zustände geben eine Belohnung), nimmt die Politik schnell einen deterministischen Ansatz an. Außerdem verfolgt er einen gierigen Ansatz und nutzt die Wege, die er bereits erkundet hat. Dies verhindert eine weitere Erkundung und führt oft zur Konvergenz zu lokalen Optima und suboptimalen Strategien. 

Die Lösung besteht darin, die Erkundung zu fördern und die Politik zu bestrafen, wenn sie zu deterministisch wird. Dazu wird die Zielfunktion um einen entropiebasierten Term erweitert. Die Entropie misst den Grad der Zufälligkeit in der Richtlinie. Je größer die Entropie ist, desto zufälliger sind die vom Agenten gewählten Aktionen. Dieser entropiebasierte Term ist das Produkt aus dem Entropiekoeffizienten und der Entropie der aktuellen Politik. 

Wenn du die Entropie in die Zielfunktion einbeziehst, kannst du ein Gleichgewicht zwischen Ausbeutung und Erkundung herstellen. 

Erweiterungen des Politikgradienten

Unter den verschiedenen Erweiterungen der Policy-Gradienten-Methoden ist der REINFORCE-Algorithmus eine der grundlegendsten. Es bietet eine unkomplizierte Umsetzung des Gradiententheorems und ist die Grundlage für fortgeschrittenere Techniken.

REINFORCE-Algorithmus

Der REINFORCE-Algorithmus, auch bekannt als Monte Carlo Reinforce, ist eine der grundlegenden Implementierungen des Policy-Gradient-Theorems. Es verwendet Monte-Carlo-Methoden, um Renditen und Politikgradienten zu schätzen. Beim REINFORCE-Algorithmus nimmt der Agent alle Aktionen (vom Anfangs- bis zum Endzustand) direkt aus der Umwelt auf. Dies steht im Gegensatz zu anderen Methoden wie TD-Learning und Dynamische Programmierung, die ihre Aktionen auf der Grundlage von Wertfunktionsschätzungen bootstrappen. 

Im Folgenden stellen wir die grundlegenden Schritte des REINFORCE-Algorithmus vor:

• Initialisiere die Richtlinie mit zufälligen Parametern
• Wiederhole mehrere Trainingsepisoden. Für jede Episode: 
• Erstelle jeden Schritt der gesamten Episode wie folgt: 
• Übergib den Status an die Policy-Funktion. 
• Die Politikfunktion erzeugt Wahrscheinlichkeiten für jede mögliche Aktion.
• Ziehe zufällig eine Aktion aus dieser Wahrscheinlichkeitsverteilung.
• Schätze für jeden Zustand in der Episode die Renditen (abgezinste kumulative Belohnungen) bis zum nächsten Schritt.
• Schätze den Gradienten der Zielfunktion (gemäß dem Gradiententheorem), ausgedrückt als Produkt aus den schrittweisen Erträgen und den Aktionswahrscheinlichkeiten für jeden Schritt. 
• Aktualisiere die Parameter der Politik durch Anwendung der Gradienten

Für jede Richtlinie kannst du eine einzelne Flugbahn abfragen, um den Gradienten zu schätzen (wie oben gezeigt), oder den Gradienten über mehrere Flugbahnen, die unter derselben Richtlinie abgefragt wurden, mitteln. 

Akteurskritische Methoden

Akteurskritische Methoden kombinieren Politikgradientenmethoden (wie REINFORCE) mit Wertfunktionen.

• Die Funktionsweise des Akteurs ist ähnlich wie bei den politischen Gradientenmethoden. Der Akteur setzt die Richtlinie um und wählt in jedem Schritt Aktionen auf der Grundlage der Richtlinie aus. Sie aktualisiert die Strategie, indem sie dem Gradienten der erwarteten Rendite folgt. 
• Der Kritiker implementiert die Wertfunktion, die als Grundlinie verwendet wird (wie im vorherigen Abschnitt beschrieben). Das hilft, die Ausbildung effizienter und stabiler zu machen. 

Politische Gradientenmethoden wie REINFORCE schätzen die Gradienten entlang jeder Trajektorie anhand der Rohdaten. Da ein Stichprobenverfahren diese Bahnen zieht, kann es zu großen Abweichungen bei den Renditen und Gradienten führen. Die Verwendung einer Vorteilsfunktion anstelle der Roherträge löst dieses Problem. Die Vorteilsfunktion ist die Differenz zwischen der tatsächlichen und der erwarteten Rendite (d. h. die Wertfunktion). Akteurskritische Methoden sind eine Klasse von Algorithmen. Wenn der Kritiker mithilfe der Vorteilsfunktion implementiert wird (der häufigste Ansatz), wird er auch Advantage actor-critic (A2C) genannt. 

Proximal Policy Optimization (PPO)

In komplexen Umgebungen reichen akteurskritische Methoden wie A2C allein nicht aus, um die Varianz der Erträge und Gradienten zu kontrollieren. In solchen Fällen hilft es, den Betrag, um den sich die Richtlinie in jeder Iteration ändern kann, künstlich zu begrenzen. Dadurch wird die aktualisierte Strategie (nach dem Gradientenanstieg) gezwungen, in der Nachbarschaft der alten Strategie zu liegen. 

Methoden wie Proximal Policy Optimization nehmen zwei Änderungen an den Policy-Gradienten vor:

• Verwende eine Vorteilsfunktion. In der Regel wird bei dieser Vorteilsfunktion die Wertfunktion als Grundlage verwendet. Darin sind sie den A2C-Methoden ähnlich. 
• Schränke den Betrag ein, um den sich die Richtlinienparameter in jeder Iteration ändern können. Dies geschieht mithilfe einer beschnittenen Ersatzzielfunktion. Der Algorithmus legt einen Bereich fest, in dem das Verhältnis der neuen Richtlinie zur alten Richtlinie liegen muss. Wenn das Verhältnis (nach der Gradientenaktualisierung) diese vorgegebenen Werte überschreitet, wird es so beschnitten, dass es innerhalb des Bereichs liegt. 

Damit verbessert PPO die Vanilla-Policy-Gradient-Methoden deutlich, was die Stabilität in komplexen Umgebungen erhöht. Die beschnittene Zielfunktion verhindert, dass große Abweichungen in den Renditen und Gradienten die Aktualisierung der Politik destabilisieren. Um ein Gleichgewicht zwischen Erkundung und Ausbeutung zu erreichen, ist es auch möglich, PPO so zu modifizieren, dass es eine Entropie-Regulierung verwendet. Dazu wird ein Entropie-Term (ein Skalierungsparameter multipliziert mit der Entropie der Strategie) zur Zielfunktion hinzugefügt. 

Jüngste Fortschritte

Policy-Gradienten gehören zu den frühesten Methoden, die zur Lösung von RL-Problemen eingesetzt werden. Nach dem Aufkommen der schnellen Grafikprozessoren wurden verschiedene neue Ansätze vorgeschlagen, um moderne ML-Techniken auf politische Gradienten anzuwenden. 

Gradient-Boosted Reinforcement Learning 

In den letzten Jahren wurden Fortschritte bei der Anwendung von Methoden wie Gradient Boosting auf RL-Algorithmen erzielt. Gradient Boosting kombiniert die Vorhersagen mehrerer schwacher Modelle, um ein einziges starkes Modell zu erstellen. Dies wird als Gradient-Boosted Reinforcement Learning (GBRL) bezeichnet. GBRL ist ein Python-Paket, das ähnlich wie XGBoost diese Techniken für RL-Algorithmen implementiert.

Transfer Reinforcement Learning 

Transferlernen (TL) ist eine Technik, bei der das von einem Modell erworbene Wissen angewendet wird, um die Leistung eines anderen Modells zu verbessern. Transfer-Lernen ist hilfreich, denn ML-Modelle von Grund auf zu trainieren ist teuer. TL-Ansätze wurden mit Policy-Gradienten verwendet, um die Leistung von RL-Modellen zu verbessern. Dieser Ansatz wird Transfer Reinforcement Learning (TRL) genannt. 

Fazit

Politische Gradienten gehören zu den grundlegendsten Ansätzen zur Lösung von RL-Problemen.

 In diesem Artikel haben wir die ersten Prinzipien von Policy-Gradienten vorgestellt und gezeigt, wie man das Policy-Gradienten-Theorem ableitet. Wir haben auch gezeigt, wie man einen einfachen gradientenbasierten Algorithmus mit PyTorch in einer Gymnasium-Umgebung implementiert. Abschließend haben wir praktische Herausforderungen und gängige Erweiterungen des grundlegenden Policy-Gradienten-Algorithmus diskutiert.

Wenn du dein Verständnis von Reinforcement Learning und Deep Learning mit PyTorch vertiefen willst, schau dir diese Kurse an:

• Lernpfad Verstärkungslernen - Lerne die Grundlagen des Verstärkungslernens, von wertbasierten Methoden bis hin zu Techniken zur Optimierung von Strategien.
• Einführung in Deep Learning mit PyTorch - Sammle praktische Erfahrungen mit PyTorch und baue Deep-Learning-Modelle von Grund auf.