Einführung: Aus Belohnungen Lernen
Reinforcement Learning (RL) ist ein grundlegend anderes Lernparadigma als Supervised und Unsupervised Learning. Statt aus gelabelten Daten zu lernen, interagiert ein Agent mit einer Umgebung, führt Aktionen aus und erhält Belohnungen. Das Ziel ist es, eine Policy (Strategie) zu lernen, die die kumulative Belohnung über die Zeit maximiert.
Vom Schachspiel (AlphaZero) über Robotik (Objektmanipulation), algorithmisches Trading bis hin zum autonomen Fahren – Reinforcement Learning bildet die Grundlage einiger der beeindruckendsten KI-Anwendungen. In diesem Artikel erkunden wir die grundlegenden Konzepte, vom klassischen Q-Learning bis zu modernen Deep-RL-Algorithmen wie DQN und PPO.
Was Sie Lernen Werden
- Markov Decision Process (MDP): Zustand, Aktion, Belohnung, Übergang
- Q-Learning: Die Aktions-Zustands-Wertetabelle
- Deep Q-Network (DQN): Q mit neuronalen Netzen approximieren
- Policy Gradient: Die Policy direkt optimieren
- Proximal Policy Optimization (PPO): Stabilität und Leistung
- Exploration vs Exploitation: Entdeckung und Nutzung ausbalancieren
- Praktische Implementierung mit Gymnasium (OpenAI)
Markov Decision Process (MDP)
Das formale Framework des RL ist der Markov Decision Process, definiert durch vier Komponenten:
- Zustände (S): Die möglichen Situationen, in denen sich der Agent befinden kann (z.B. Position auf einem Gitter, Frame eines Spiels)
- Aktionen (A): Die verfügbaren Züge in jedem Zustand (z.B. oben, unten, links, rechts)
- Belohnungen (R): Das numerische Feedback nach jeder Aktion (z.B. +1 für Gewinnen, -1 für Verlieren)
- Übergänge (P): Die Wahrscheinlichkeit, in einen Folgezustand zu gelangen, gegeben eine Aktion. Die Markov-Eigenschaft besagt, dass die Zukunft nur vom aktuellen Zustand abhängt, nicht von der Historie
Der Agent sucht eine optimale Policy, die die diskontierte Summe der zukünftigen Belohnungen maximiert. Der Discount Factor Gamma (zwischen 0 und 1) balanciert sofortige vs. zukünftige Belohnungen: Gamma nahe 0 macht den Agenten kurzsichtig, nahe 1 vorausschauend.
Q-Learning: Aktions-Zustands-Werte
Q-Learning ist ein Off-Policy-Algorithmus, der die Funktion Q(s, a) lernt: den erwarteten Wert der kumulativen Belohnung bei Wahl der Aktion a im Zustand s und anschließendem Befolgen der optimalen Policy. Die Aktualisierungsregel lautet:
Q(s, a) = Q(s, a) + alpha * [R + gamma * max_a'(Q(s', a')) - Q(s, a)]
import numpy as np
import gymnasium as gym
class QLearningAgent:
def __init__(self, n_states, n_actions, lr=0.1, gamma=0.99, epsilon=1.0):
self.q_table = np.zeros((n_states, n_actions))
self.lr = lr
self.gamma = gamma
self.epsilon = epsilon
self.epsilon_min = 0.01
self.epsilon_decay = 0.995
def choose_action(self, state):
"""Epsilon-Greedy: Erkundet mit Wahrscheinlichkeit epsilon, nutzt sonst aus"""
if np.random.random() < self.epsilon:
return np.random.randint(self.q_table.shape[1])
return np.argmax(self.q_table[state])
def learn(self, state, action, reward, next_state, done):
"""Q-Table aktualisieren"""
target = reward
if not done:
target += self.gamma * np.max(self.q_table[next_state])
self.q_table[state, action] += self.lr * (target - self.q_table[state, action])
self.epsilon = max(self.epsilon_min, self.epsilon * self.epsilon_decay)
# Training auf FrozenLake
env = gym.make('FrozenLake-v1', is_slippery=False)
agent = QLearningAgent(n_states=16, n_actions=4)
for episode in range(5000):
state, _ = env.reset()
total_reward = 0
done = False
while not done:
action = agent.choose_action(state)
next_state, reward, terminated, truncated, _ = env.step(action)
done = terminated or truncated
agent.learn(state, action, reward, next_state, done)
state = next_state
total_reward += reward
if episode % 1000 == 0:
print(f"Episode {episode}, Belohnung: {total_reward}, "
f"Epsilon: {agent.epsilon:.3f}")
Exploration vs Exploitation
Das fundamentale Dilemma des RL: Der Agent muss explorieren (neue Aktionen ausprobieren, um bessere Belohnungen zu entdecken) und ausnutzen (das aktuelle Wissen nutzen, um die Belohnung zu maximieren). Die Epsilon-Greedy-Strategie balanciert beide Aspekte: Mit Wahrscheinlichkeit epsilon wählt er eine zufällige Aktion, ansonsten die beste bekannte Aktion. Epsilon wird während des Trainings schrittweise reduziert.
Deep Q-Network (DQN)
Q-Learning mit Tabellen funktioniert nur für kleine, diskrete Zustandsräume. Für komplexe Umgebungen (Bilder, kontinuierliche Zustände) ersetzt die Deep Q-Network (DQN) die Q-Table durch ein neuronales Netzwerk, das die Q-Funktion approximiert. Zwei Schlüsselinnovationen stabilisieren das Training:
- Experience Replay: Übergänge werden in einem Puffer gespeichert und zufällig für das Training gesampelt, wodurch die zeitliche Korrelation zwischen aufeinanderfolgenden Samples aufgebrochen wird
- Target Network: Eine separate Kopie des Netzwerks, periodisch aktualisiert, berechnet die Ziel-Q-Werte und stabilisiert das Lernen
import torch
import torch.nn as nn
from collections import deque
import random
class DQN(nn.Module):
def __init__(self, state_dim, action_dim):
super().__init__()
self.net = nn.Sequential(
nn.Linear(state_dim, 128),
nn.ReLU(),
nn.Linear(128, 128),
nn.ReLU(),
nn.Linear(128, action_dim)
)
def forward(self, x):
return self.net(x)
class DQNAgent:
def __init__(self, state_dim, action_dim, lr=1e-3, gamma=0.99):
self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
self.q_net = DQN(state_dim, action_dim).to(self.device)
self.target_net = DQN(state_dim, action_dim).to(self.device)
self.target_net.load_state_dict(self.q_net.state_dict())
self.optimizer = torch.optim.Adam(self.q_net.parameters(), lr=lr)
self.memory = deque(maxlen=100000)
self.gamma = gamma
self.batch_size = 64
def store(self, state, action, reward, next_state, done):
self.memory.append((state, action, reward, next_state, done))
def learn(self):
if len(self.memory) < self.batch_size:
return
batch = random.sample(self.memory, self.batch_size)
states, actions, rewards, next_states, dones = zip(*batch)
states = torch.FloatTensor(states).to(self.device)
actions = torch.LongTensor(actions).to(self.device)
rewards = torch.FloatTensor(rewards).to(self.device)
next_states = torch.FloatTensor(next_states).to(self.device)
dones = torch.FloatTensor(dones).to(self.device)
q_values = self.q_net(states).gather(1, actions.unsqueeze(1))
with torch.no_grad():
next_q = self.target_net(next_states).max(1)[0]
targets = rewards + (1 - dones) * self.gamma * next_q
loss = nn.functional.mse_loss(q_values.squeeze(), targets)
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
def update_target(self):
self.target_net.load_state_dict(self.q_net.state_dict())
Policy Gradient und Actor-Critic
Policy Gradient-Methoden optimieren direkt die Policy, ohne den Umweg über die Q-Funktion. Das Policy-Gradient-Theorem besagt, dass der Gradient der erwarteten Belohnung bezüglich der Policy-Parameter proportional zur belohnungsgewichteten Log-Wahrscheinlichkeit der Aktionen ist.
Actor-Critic
Die Actor-Critic-Architektur kombiniert beide Ansätze: Der Actor (Policy Network) wählt die Aktionen, der Critic (Value Network) schätzt, wie gut der aktuelle Zustand ist. Der Critic reduziert die Varianz der Actor-Updates und macht das Training stabiler.
PPO: Der Industriestandard
Proximal Policy Optimization (PPO), entwickelt von OpenAI, ist der in der Praxis am häufigsten verwendete RL-Algorithmus. Seine Schlüsselinnovation ist das geclippte Ziel: Es begrenzt, wie weit sich die neue Policy bei jeder Aktualisierung von der alten entfernen kann, und verhindert zu drastische Änderungen, die das Training destabilisieren würden.
PPO liegt vielen Erfolgen zugrunde: InstructGPT und RLHF (LLM-Alignment), OpenAI Five (Dota 2), Training robotischer Agenten und vieles mehr.
Nächste Schritte in der Serie
- Im nächsten Artikel werden wir Fortgeschrittenes Transfer Learning mit BERT, GPT und Hugging Face erkunden
- Wir werden Fine-Tuning, Prompt Engineering und RAG (Retrieval-Augmented Generation) sehen
- Wir vergleichen Open-Source-Modelle: Llama, Mistral, Falcon