Erste Schritte mit Torchrl für ein tiefes Verstärkungslernen

Verstärkungslernen (RL) befasst sich mit komplexen Problemen, von autonomen Fahrzeugen bis hin zu hoch entwickelten Sprachmodellen. RL -Agenten lernen durch Verstärkungslernen aus menschlichem Feedback (RLHF) und adaptieren ihre Antworten auf der Grundlage der menschlichen Eingaben. Während Python -Frameworks wie Keras und Tensorflow hergestellt werden, dominieren Pytorch und Pytorch Lightning neue Projekte.

Torchrl, eine Open-Source-Bibliothek, vereinfacht die RL-Entwicklung mit Pytorch. Dieses Tutorial zeigt das Torchrl -Setup, die Kernkomponenten und das Erstellen eines Basis -RL -Agenten. Wir werden vorgefertigte Algorithmen wie die proximale Richtlinienoptimierung (PPO) sowie die wesentlichen Protokollierungs- und Überwachungstechniken untersuchen.

Einrichten von Torchrl

Dieser Abschnitt führt Sie durch die Installation und Verwendung von Torchrl.

Voraussetzungen

Stellen Sie vor der Installation von Torchrl sicher:

• Pytorch: Fundament von Torchrl.
• Gymnasium: Zum Importieren von RL -Umgebungen. Verwenden Sie Version 0.29.1 (Ab Januar 2025 haben spätere Versionen Kompatibilitätsprobleme mit Torchrl - siehe die entsprechende Seite der Git -Diskussion).
• Pygame: Für die Simulation der spielerischen RL-Umgebungen (z. B. Cartpole).
• TensSarbict: Bietet einen Tensorbehälter für eine effiziente Tensor -Manipulation.

Voraussetzungen installieren:

!pip install torch tensordict gymnasium==0.29.1 pygame

Abrieb

installieren

Torchrl mit PIP einbauen. Eine Conda -Umgebung wird für PCs oder Server empfohlen.

!pip install torchrl

Überprüfung

Testen Sie Ihre Installation, indem Sie torchrl in einer Python -Shell oder einem Notebook importieren. Verwenden Sie check_env_specs(), um die Umgebungskompatibilität zu überprüfen (z. B. Cartpole):

import torchrl
from torchrl.envs import GymEnv
from torchrl.envs.utils import check_env_specs

check_env_specs(GymEnv("CartPole-v1"))

Eine erfolgreiche Installation wird angezeigt:

<code>[torchrl][INFO] check_env_specs succeeded!</code>

Schlüssel -Torchrl -Komponenten

Vor der Erstellung von Agenten untersuchen wir die Kernelemente von Torchrl.

Umgebungen

Torchrl bietet eine konsistente API für verschiedene Umgebungen, die umgebungsspezifische Funktionen in Standardverpackungen umwickeln. Dies vereinfacht die Interaktion:

• Torchrl konvertiert Zustände, Aktionen und Belohnungen in Pytorch -Tensoren.
• Vorverarbeitung/Nachbearbeitung (Normalisierung, Skalierung, Formatierung) ist leicht anzuwenden.

Erstellen Sie eine Gymnasiumumgebung mit GymEnv:

env = GymEnv("CartPole-v1")

transformiert

Verbessert Umgebungen mit Add-Ons (z. B. Schrittzähler) mit TransformedEnv:

from torchrl.envs import GymEnv, StepCounter, TransformedEnv
env = TransformedEnv(GymEnv("CartPole-v1"), StepCounter())

Normalisierung wird mit ObservationNorm:

erreicht

from torchrl.envs import Compose
base_env = GymEnv('CartPole-v1', device=device) 
env = TransformedEnv( 
    base_env, 
    Compose(
        ObservationNorm(in_keys=["observation"]), 
        StepCounter()
    )
)

Mehrere Transformationen werden mit Compose.

kombiniert

Agenten und Richtlinien

Der Agent verwendet eine Richtlinie, um Aktionen basierend auf dem Zustand der Umgebung auszuwählen, um kumulative Belohnungen zu maximieren.

Eine einfache zufällige Richtlinie wird mit RandomPolicy:

erstellt

!pip install torch tensordict gymnasium==0.29.1 pygame

Erstellen Sie Ihren ersten RL -Agenten

Dieser Abschnitt zeigt, dass ein einfaches RL -Agent erstellt wird.

erforderliche Pakete importieren:

!pip install torchrl

Schritt 1: Definieren Sie die Umgebung

Wir werden die Cartpole -Umgebung verwenden:

import torchrl
from torchrl.envs import GymEnv
from torchrl.envs.utils import check_env_specs

check_env_specs(GymEnv("CartPole-v1"))

Hyperparameter definieren:

<code>[torchrl][INFO] check_env_specs succeeded!</code>

Schritt 2: Erstellen Sie die Richtlinie

Definieren Sie eine einfache Richtlinie für neuronale Netzwerke:

env = GymEnv("CartPole-v1")

Schritt 3: trainieren Sie den Agenten

Erstellen Sie einen Datensammler und einen Wiederholungspuffer:

from torchrl.envs import GymEnv, StepCounter, TransformedEnv
env = TransformedEnv(GymEnv("CartPole-v1"), StepCounter())

Schulungsmodule definieren:

from torchrl.envs import Compose
base_env = GymEnv('CartPole-v1', device=device) 
env = TransformedEnv( 
    base_env, 
    Compose(
        ObservationNorm(in_keys=["observation"]), 
        StepCounter()
    )
)

Implementieren Sie die Trainingsschleife (für die Kürze vereinfacht):

import torchrl
import torch
from tensordict import TensorDict
from torchrl.data.tensor_specs import Bounded

action_spec = Bounded(-torch.ones(1), torch.ones(1))
actor = torchrl.envs.utils.RandomPolicy(action_spec=action_spec)
td = actor(TensorDict({}, batch_size=[]))
print(td.get("action"))

Schritt 4: Bewerten Sie den Agenten

Evaluierung und Protokollierung in die Trainingsschleife (vereinfacht):

import time
import matplotlib.pyplot as plt
from torchrl.envs import GymEnv, StepCounter, TransformedEnv
from tensordict.nn import TensorDictModule as TensorDict, TensorDictSequential as Seq
from torchrl.modules import EGreedyModule, MLP, QValueModule
from torchrl.objectives import DQNLoss, SoftUpdate
from torchrl.collectors import SyncDataCollector
from torchrl.data import LazyTensorStorage, ReplayBuffer
from torch.optim import Adam
from torchrl._utils import logger as torchrl_logger

Trainingszeit und Diagrammergebnisse:

env = TransformedEnv(GymEnv("CartPole-v1"), StepCounter())
torch.manual_seed(0)
env.set_seed(0)

(Die vollständige DQN -Implementierung ist im referenzierten Datalab -Arbeitsbuch verfügbar.)

Erforschung vorgefertigter Algorithmen

Torchrl bietet vorgefertigte Algorithmen (DQN, DDPG, SAC, PPO usw.). Dieser Abschnitt zeigt die Verwendung von PPO.

erforderliche Module importieren:

INIT_RAND_STEPS = 5000
FRAMES_PER_BATCH = 100
OPTIM_STEPS = 10
EPS_0 = 0.5
BUFFER_LEN = 100_000
ALPHA = 0.05
TARGET_UPDATE_EPS = 0.95
REPLAY_BUFFER_SAMPLE = 128
LOG_EVERY = 1000
MLP_SIZE = 64

Hyperparameter definieren:

value_mlp = MLP(out_features=env.action_spec.shape[-1], num_cells=[MLP_SIZE, MLP_SIZE])
value_net = TensorDict(value_mlp, in_keys=["observation"], out_keys=["action_value"])
policy = Seq(value_net, QValueModule(spec=env.action_spec))

exploration_module = EGreedyModule(
    env.action_spec, annealing_num_steps=BUFFER_LEN, eps_init=EPS_0
)
policy_explore = Seq(policy, exploration_module)

(Die verbleibende PPO -Implementierung, einschließlich Netzwerkdefinitionen, Datenerfassung, Verlustfunktion, Optimierung und Trainingsschleife, folgt einer ähnlichen Struktur wie die ursprüngliche Antwort, wird hier jedoch für die Kürze weggelassen. Siehe die ursprüngliche Antwort für den vollständigen Code.)

Visualisieren und Debuggen

den Trainingschritt mit Tensorboard überwachen:

collector = SyncDataCollector(
    env,
    policy_explore,
    frames_per_batch=FRAMES_PER_BATCH,
    total_frames=-1,
    init_random_frames=INIT_RAND_STEPS,
)
rb = ReplayBuffer(storage=LazyTensorStorage(BUFFER_LEN))

visualisieren Sie mit: tensorboard --logdir="training_logs"

Debugging beinhaltet die Überprüfung der Umgebungspezifikationen:

loss = DQNLoss(value_network=policy, action_space=env.action_spec, delay_value=True)
optim = Adam(loss.parameters(), lr=ALPHA)
updater = SoftUpdate(loss, eps=TARGET_UPDATE_EPS)

Stichprobenbeobachtungen und -aktionen:

total_count = 0
total_episodes = 0
t0 = time.time()
success_steps = []
for i, data in enumerate(collector):
    rb.extend(data)
    # ... (training steps, similar to the original response) ...

visualisieren Sie die Agentenleistung, indem Sie ein Video rendern (erfordert torchvision und av):

    # ... (training steps) ...
    if total_count > 0 and total_count % LOG_EVERY == 0:
        torchrl_logger.info(f"Successful steps: {max_length}, episodes: {total_episodes}")
    if max_length > 475:
        print("TRAINING COMPLETE")
        break

Best Practices

• Beginnen Sie mit einfachen Umgebungen (wie Cartpole).
• Experimentieren Sie mit Hyperparametern (Gittersuche, zufällige Suche, automatisierte Tools).
• Nutzen Sie vorgefertigte Algorithmen, wann immer möglich.

Schlussfolgerung

Dieses Tutorial lieferte eine umfassende Einführung in Torchrl, in dem seine Fähigkeiten anhand von DQN- und PPO -Beispielen vorgestellt wurden. Experimentieren Sie mit verschiedenen Umgebungen und Algorithmen, um Ihre RL -Fähigkeiten weiter zu verbessern. Die Referenzressourcen bieten zusätzliche Lernmöglichkeiten.

Das obige ist der detaillierte Inhalt vonErste Schritte mit Torchrl für ein tiefes Verstärkungslernen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!