Abhishek Nair
← Back to Portfolio
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:

  1. Robotersimulation zugänglich macht ohne teure Hardware oder komplexe 3D-Physik-Engines
  2. Klassische und gelernte Ansätze vergleicht auf denselben Navigationsproblemen
  3. 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:

  1. Eingeschränkter Aktionsraum: Nur-Vorwärts-Bewegung [0, 1] für lineare Geschwindigkeit—entspricht dem Go-to-Goal-Controller-Verhalten

  2. Fortschrittsbasierte Belohnung: Einfaches 10.0 × max(0, progress) statt inverser Entfernung—klares Signal, das das Schließen der Lücke belohnt

  3. Exzessive Rotationsstrafe: -5.0 × (w - 0.8) wenn Winkelgeschwindigkeit 0.8 überschreitet—stoppt das Dreh-Verhalten

  4. 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

Back to Portfolio