Persönliches ProjektDecember 2024Berlin, Germany

2D-Robotersimulation & Reinforcement Learning Plattform

Eine vollständige Robotersimulationsumgebung für Differential-Antrieb-Roboternavigation, Lokalisierung und Reinforcement Learning mit IR-SIM (2D-Simulation). Dieses Projekt verbindet klassische Robotik-Steuerungsalgorithmen mit modernem Deep Reinforcement Learning und bietet eine praxisorientierte Lernplattform zum Verständnis beider Ansätze. Das System umfasst Go-to-Goal-Controller, Potential-Field-Navigation, Odometrie-Simulation und vollständige RL-Trainingspipeline mit PPO-, SAC- und TD3-Algorithmen—Erreichen einer 100%igen Navigationserfolgsrate nach Implementierung forschungsbasierter Reward-Funktions-Designs.

Die Herausforderung

Robotik wird oft isoliert gelehrt—entweder lernt man klassische Steuerungstheorie mit Differentialgleichungen und Zustandsraummodellen, oder man taucht in Reinforcement Learning mit abstrakten Umgebungen wie CartPole ein. Aber echte Robotik lebt an der Schnittstelle beider Welten.

Ich wollte etwas bauen, das:

Robotersimulation zugänglich macht ohne teure Hardware oder komplexe 3D-Physik-Engines
Klassische und gelernte Ansätze vergleicht auf denselben Navigationsproblemen
Die Reise dokumentiert des Trainings eines RL-Agenten, der tatsächlich funktioniert—einschließlich aller Fehlschläge auf dem Weg

Architekturübersicht

Die Plattform ist in drei Hauptebenen organisiert:

1. Simulations-Layer (IR-SIM)

IR-SIM (2D Intelligent Robot Simulator) bietet das Physik-Backbone:

Differential-Antrieb-Kinematik: Genaues Zweirad-Roboter-Bewegungsmodell mit realistischen Geschwindigkeitsbeschränkungen
Welt-Konfiguration: YAML-basierte Weltdateien, die Hindernisse, Grenzen und Roboter-Eigenschaften definieren
Hindernistypen: Sowohl kreisförmige als auch rechteckige Hindernisse mit ordnungsgemäßer Kollisionserkennung
Visualisierung: Echtzeit-Matplotlib-Rendering von Roboter-Trajektorien und Sensorwerten

2. Klassische Controller

Vor dem Einstieg in RL implementierte ich zwei klassische Navigationsansätze:

Go-to-Goal-Controller:

Proportional-Steuerung für Kursausrichtung
Hindernisvermeidung mit 60° vorwärtsgerichtetem Erkennungskegel
Geschwindigkeitsmodulation basierend auf Hindernisnähe

Potential-Field-Controller:

Attraktives Potential zum Ziel
Abstoßendes Potential von Hindernissen
Gradientenabstieg auf kombiniertem Potentialfeld

Diese Controller dienen als Baselines und helfen zu validieren, dass die Simulationsumgebung korrekt funktioniert.

3. Reinforcement Learning Pipeline

Das RL-System umhüllt IR-SIM mit einer Gymnasium-kompatiblen Umgebung:

Beobachtungsraum (7 Werte):

dx_norm, dy_norm: Normalisierte Richtung zum Ziel
dtheta: Kursfehler zum Ziel
v, w: Aktuelle lineare und Winkelgeschwindigkeit
dist_to_obstacle: Minimale Entfernung zum nächsten Hindernis
distance_to_goal: Euklidische Entfernung zum Ziel

Aktionsraum:

Lineare Geschwindigkeit: [0.0, 1.0] (nur vorwärts-Beschränkung)
Winkelgeschwindigkeit: [-1.0, 1.0] (links/rechts drehen)

Trainingsalgorithmen:

PPO (Proximal Policy Optimization) — primär
SAC (Soft Actor-Critic)
TD3 (Twin Delayed DDPG)

Die Reise: Von 0% zu 100% Erfolgsrate

Das Training des RL-Agenten war nicht einfach. Hier ist die ehrliche Geschichte:

Erste Versuche: 20% Erfolgsrate

Meine erste Version verwendete eine komplexe Reward-Funktion mit vielen konkurrierenden Signalen:

Entfernungsbasierte Belohnungen (Invers der Entfernung zum Ziel)
Zeitstrafen
Bewegungsboni
Mehrere Hindernisnähe-Stufen
Kursausrichtungs-Belohnungen

Der Agent lernte... im Kreis zu drehen. Mit 500.000 Timesteps Training erreichte er nur 20% Erfolgsrate, und selbst diese Erfolge sahen nach Glück aus, nicht nach Können.

Root-Cause-Analyse

Tiefe Diagnose offenbarte mehrere kritische Probleme:

Problem 1: Aktionsraum-Mismatch Der Aktionsraum erlaubte [-1.5, 1.5] Geschwindigkeiten, aber die Roboter-Konfiguration unterstützte nur [-1, 1]. Der Agent lernte ungültige Aktionen, die abgeschnitten wurden—verschwendetes Training auf unmögliche Verhaltensweisen.

Problem 2: Kollisionserkennungs-Bug Die Verwendung von hasattr() statt getattr() für IR-SIM-Form-Objekte verursachte stille Fehler. Die Hinderniserkennung gab Standardwerte statt tatsächlicher Entfernungen zurück. Der Agent war buchstäblich blind für Hindernisse.

Problem 3: Reward-Signal-Verwirrung Zu viele konkurrierende Reward-Signale verwirrten den Lernprozess. Der Agent konnte nicht herausfinden, welches Verhalten belohnt wurde.

Die Forschungsbasierte Lösung

Nach umfangreicher Literaturrecherche zu RL-Navigation implementierte ich:

Eingeschränkter Aktionsraum: Nur-Vorwärts-Bewegung [0, 1] für lineare Geschwindigkeit—entspricht dem Go-to-Goal-Controller-Verhalten
Fortschrittsbasierte Belohnung: Einfaches 10.0 × max(0, progress) statt inverser Entfernung—klares Signal, das das Schließen der Lücke belohnt
Exzessive Rotationsstrafe: -5.0 × (w - 0.8) wenn Winkelgeschwindigkeit 0.8 überschreitet—stoppt das Dreh-Verhalten
Vereinfachtes Signal: Entfernt alle konkurrierenden Boni und Strafen, fokussiert auf das Hauptziel

Endergebnis: 100% Erfolgsrate 🎉

Erfolgsrate: 5/5 (100%)
Durchschnittliche Belohnung: 378.35 ± 8.67
Durchschnittliche Episodenlänge: 202.4 ± 24.2 Schritte
Durchschnittlicher Fortschritt: 9.21 ± 0.60 Meter pro Episode

Technologie-Stack

Simulation & Robotik

IR-SIM: 2D-Robotersimulation mit Differential-Antrieb-Kinematik
NumPy: Numerisches Computing für Transformationen und Physik
Matplotlib: Echtzeit-Visualisierung und Trajektorien-Plotting

Reinforcement Learning

Gymnasium: Standard-RL-Umgebungs-Interface
Stable-Baselines3: PPO-, SAC-, TD3-Implementierungen
PyTorch: Neurales Netzwerk-Backend mit MPS/CUDA-Unterstützung
TensorBoard: Trainings-Visualisierung und Metriken

Entwicklung

Python 3.11+: Modernes Python mit Type Hints
YAML: Konfigurationsdateien für Welten und Roboter
Pytest: Test-Framework für Controller

Projektstruktur

robot_sim/
├── configs/                    # Welt-Konfigurationsdateien
│   ├── simple_world.yaml       # Basis-Test-Welt
│   ├── rl_world.yaml           # RL-Trainings-Welt
│   └── rl_world_complex.yaml   # Komplexe Hindernis-Welt
├── scripts/                    # Python-Skripte
│   ├── 01_test_simulation.py   # Basis-Simulations-Test
│   ├── 02_go_to_goal.py        # Go-to-Goal-Demo
│   ├── 03_potential_field.py    # Potential-Field-Demo
│   ├── 04_odometry.py          # Odometrie-Visualisierung
│   ├── 05_rl_environment.py    # Gymnasium-Wrapper
│   ├── 06_train_rl.py          # RL-Trainings-Skript
│   ├── 07_evaluate_rl.py       # Modell-Evaluierung
│   └── ...                     # Diagnose-Tools
├── models/                     # Trainierte Modelle (PPO/SAC/TD3)
└── logs/                       # TensorBoard-Logs & Visualisierungen

Wichtige Erkenntnisse

1. Starte mit Klassischen Controllern

Vor dem RL-Training klassische Lösungen implementieren. Sie validieren deine Simulation, bieten Baselines, und ihr Verhalten informiert RL-Design (z.B. nur-vorwärts-Beschränkung).

2. Systematisch Debuggen

Wenn RL fehlschlägt, widerstehe dem Drang, Hyperparameter zufällig zu optimieren. Stattdessen:

Verifiziere Umgebungsphysik
Prüfe Beobachtungswerte während Episoden
Stelle sicher, dass Kollisionserkennung funktioniert
Validiere, dass Reward-Signale Sinn ergeben

3. Einfachere Belohnungen sind Besser

Komplexe Reward-Funktionen mit vielen Termen verwirren den Agenten. Fortschrittsbasierte Belohnungen mit klaren, konsistenten Signalen übertreffen ausgeklügelte Multi-Objektiv-Formulierungen.

4. Aktionsraum-Design ist Wichtig

Einschränken des Aktionsraums, um gewünschtes Verhalten zu entsprechen, verhindert, dass der Agent kontraproduktive Strategien lernt. Wenn dein Roboter nicht rückwärts fahren sollte, erlaube keine negative lineare Geschwindigkeit.

5. Alles Dokumentieren

Der wertvollste Output ist nicht das finale Modell—es ist die Reise. Die Diagnose-Skripte und Änderungsprotokolle halfen mir zu verstehen, was schiefging und warum die Fixes funktionierten.

Projekt ausführen

Schnellstart

# Klonen und Setup
git clone https://github.com/padawanabhi/robot_sim.git
cd robot_sim
python3 -m venv venv && source venv/bin/activate
pip install -r requirements.txt

# Simulation testen
python scripts/01_test_simulation.py

# RL-Agent trainieren
python scripts/06_train_rl.py --algorithm ppo --timesteps 500000

# Trainiertes Modell evaluieren
python scripts/07_evaluate_rl.py --algorithm ppo --episodes 5

Training überwachen

tensorboard --logdir logs/tensorboard
# Öffne http://localhost:6006

Zukünftige Verbesserungen

SLAM-Integration: Hinzufügen von Mapping-Fähigkeiten mit Occupancy-Grids
Multi-Roboter-Szenarien: Training von Agenten für Koordination und Kollisionsvermeidung
Sim-to-Real-Transfer: Deployment gelernte Policies auf physische Roboter
Curriculum Learning: Allmähliche Erhöhung der Hindernisdichte während des Trainings
3D-Erweiterung: Migration von Konzepten zu Gazebo/Isaac Sim für 3D-Navigation

Ressourcen

GitHub-Repository: padawanabhi/robot_sim
IR-SIM-Dokumentation: ir-sim.readthedocs.io
Stable-Baselines3: stable-baselines3.readthedocs.io

Back to Portfolio

Follow Me