Zum Inhalt

Unit 0 — Setup & Erster Start

Kursstartseite

Zeit

Lesen: ~20 min · Training: ~15 min GPU / ~1 Std CPU

Installiere den Godot-Editor (Standard-Version) und die Python-Toolchain. Starte deine erste Trainingssitzung mit dem mitgelieferten Foundations-Racer und bestätige, dass der Godot ↔ Python Socket funktioniert.

Erster Erfolg (eine Sitzung)

  1. Godot — der Racer bewegt sich auf seiner Strecke (Szene abspielen, während Python trainiert)
  2. Python — Terminal zeigt Rollout-Tabellen; ep_rew_mean erscheint
  3. TensorBoard (optional) — tensorboard --logdir=logs/foundations_racer zeigt eine Kurve
  4. Neuronale Grundlagen — du wirst sichtbare Neuronen bauen, bevor die RL-Schleife beginnt

Drei Wege, deine KI zu beobachten (jede Einheit)

Godot-Verhalten · TensorBoard-Kurven · was du in AIController änderst

Wenig Zeit?

Folge dem Erster-Abend-Skript (~2½–3 Std.), um Unit 0 abzuschließen und Neuronale Grundlagen 1 in einer Sitzung zu beginnen.

1 · Geteilte Architektur (split architecture)

Zwei Laufzeitumgebungen kommunizieren über einen lokalen Socket — Godot sendet Beobachtungen (observations) und empfängt Aktionen (actions); Python führt die Trainingsschleife aus.

Godot Spielprozess Szene · Physik · Belohnungen NcnnSync-Node (GDScript-Addon) Python Trainingsprozess godot-rl-Wrapper SB3 — PPO- / DQN-Training Beobachtung + Belohnung Aktionen lokaler Socket · Port 11008 nach dem Training: NcnnSync führt das konvertierte Gehirn nativ aus — kein Python zur Laufzeit (siehe §5)
Komponente Rolle Laufzeit
Godot Physik, Beobachtungen, Belohnungen Godot 4 Standard, GDScript
Addon (GDScript) NcnnSync-Node, native ncnn-Bridge godot-native-rl (gepinntes Release, per Skript installiert)
Python PPO-Training (SB3) Conda, Python 3.10

Die Standard-Godot-Version genügt

Alles auf der Godot-Seite ist GDScript — kein C#, kein .NET SDK, kein Build-Schritt. Lade die Standard-Version (4.5+) von godotengine.org herunter; die Details stehen im Setup.

2 · Conda-Umgebung

Zum ersten Mal hier?

Vollständige Installationsanweisungen — Miniconda, godot_env und das Godot-Addon — findest du unter Setup. Schließe diese Seite zuerst ab und komme dann hierher zurück.

Kurze Erinnerung für jedes neue Terminal:

conda activate godot_env

3 · Godot-Projekt & Addon

Unit 0 und die Einheiten der Neuronalen Grundlagen trainieren im eigenen Godot-Projekt des Kurs-Repos. Das godot-native-rl-Addon liegt nicht im Repo — seine nativen Bibliotheken wiegen mehr als alles andere darin — installiere deshalb zuerst das gepinnte Release:

scripts/fetch-native-runner.sh            # aus dem Wurzelverzeichnis des Kurs-Repos
scripts/fetch-native-runner.sh --check    # zeigt gepinnt vs. installiert

Danach:

  1. Godot → Import → navigiere zu godot-rl-course/examples/neural_foundations/game/project.godot
  2. Lass den ersten Import durchlaufen — es wird nichts kompiliert, das geht schnell
  3. Projekt → Projekteinstellungen → Plugins → Godot Native RL aktivieren
  4. Überprüfen: Node hinzufügen → suche nach NcnnSync. Erscheint er, ist das Addon geladen.

Warum Schritt 3, wenn die Nodes auch ohne ihn funktionieren?

Die Node-Klassen registrieren sich von allein. Das Aktivieren des Plugins ergänzt das, was später zählt: Es packt deine ncnn-Modelldateien in exportierte Builds. Ohne das startet ein exportiertes Spiel und scheitert dann mit „cannot read model files" — weit weg von hier, ohne Hinweis zurück auf dieses Häkchen. Ein Klick jetzt.

Examples-Repo für spätere Einheiten

Die Einheiten ab RL Essentials nutzen derzeit noch Umgebungen aus dem separaten Repo godot_rl_agents_examples (der Legacy-Stack — die Migration wird in den Issues des Kurs-Repos verfolgt). Klone es neben das Kurs-Repo, wenn du diese Einheiten erreichst:

cd ..   # aus godot-rl-course heraus
git clone https://github.com/edbeeching/godot_rl_agents_examples.git

4 · Erster Trainingslauf

Im Editor

Terminal 1 — Python-Trainer starten (aus dem Stammverzeichnis des Kurs-Repos):

conda activate godot_env
python scripts/train_foundations_racer.py --timesteps 2048

Warte auf "waiting for remote GODOT connection" in der Log-Ausgabe.

Terminal 2 optional: tensorboard --logdir=logs/foundations_racer

Godot — öffne unit_03_racer/racer_train.tscn, drücke F6 (Szene abspielen). Der Racer sollte sich verbinden und Steps ausführen; SB3 gibt Rollout-Tabellen in Terminal 1 aus. Die standardmäßigen 2048 Timesteps sind ein Smoke-Test (wenige Minuten) — er beweist, dass Socket, Trainer und Szene zusammenspielen. Für sichtbares Lernen starte erneut mit --timesteps 50000.

Nach dem Lauf speichert der Trainer einen Checkpoint und einen ONNX-Export unter examples/neural_foundations/game/unit_03_racer/models/.

Erfolgskriterien

Racer in Godot sichtbar; Rollout-Tabellen mit ep_rew_mean erscheinen; keine Warnungen, keine Socket-Fehler; TensorBoard-Kurve optional, aber empfohlen.

5 · Trainingsmodi für diesen Kurs

Phase Einheiten Standard
Erkunden 0–2 Editor-Szene abspielen — Physik- und Belohnungsfehler sichtbar machen
Skalieren 3–8 Exportiertes Binary + --headless — schnellere Rollouts
Veröffentlichen 9–10 Native ncnn-Inferenz im NcnnSync — kein Python zur Laufzeit

Native Inferenz-Vorschau (optional)

Nach dem Training kann das exportierte ONNX zu ncnn konvertiert und nativ ausgeführt werden: Die Evaluationsszene unit_03_racer/racer_eval.tscn nutzt NcnnSync im Inferenzmodus — der Racer läuft ohne Python. Neuronale Grundlagen 3 führt durch die komplette Export → Verifizieren → Deployen Pipeline. Das funktioniert unter macOS, Windows und Linux; nötig sind die nativen Bibliotheken, die scripts/fetch-native-runner.sh installiert (siehe Setup).

Erster-Abend-Skript (~2½–3 Stunden)

Eine Sitzung: Tooling funktioniert, Akteur lernt, du änderst eine Belohnung. Die Zeiten sind Richtwerte — Installationsschritte variieren je nach Rechner.

Block Zeit Aufgabe Fertig wenn
1 · Installieren 45–75 Min Abschnitt 2 — Miniconda installieren → godot_env erstellen → pip install
Abschnitt 3 — das Kurs-Spielprojekt in Godot öffnen		 import godot_rl gibt ok aus; Spielprojekt öffnet sich und NcnnSync erscheint unter „Node hinzufügen"
2 · Erster Trainingslauf 30–45 Min Abschnitt 4 — Python-Trainer + Godot F6
Zweites Terminal: tensorboard --logdir=logs/foundations_racer		 Racer bewegt sich; Rollout-Tabellen erscheinen; keine Socket-Fehler
3 · Grundlagen 1 beginnen 45–60 Min Öffne Neuronale Grundlagen 1
Abschnitt 1 lesen (was ein Neuron berechnet), dann die Handrechnung in Abschnitt 2 vorhersagen (~15 Min) → Research-Plot oder Godot-Jumper-Szene starten
Während des Erkundens: Abschnitte 3–4 lesen		 Du kannst jeden Beitrag, die gewichtete Summe und den Aktivierungswert benennen

Minimales Befehls-Spickzettel (Block 2)

conda activate godot_env
tensorboard --logdir=logs/foundations_racer &

python scripts/train_foundations_racer.py --timesteps 2048

# Godot: unit_03_racer/racer_train.tscn → F6 (Szene abspielen)

Checkliste zum Abend

  • [ ] Godot — Akteur in Aktion gesehen
  • [ ] Python — Training ohne Verbindungsfehler durchgelaufen
  • [ ] TensorBoard — mindestens einmal geöffnet (localhost:6006)
  • [ ] Code — einen Neuron-Forward-Pass-Test oder ein visuelles Beispiel ausgeführt

Morgen: Grundlagen 1–2 abschließen, dann RL Essentials (BallChase-Belohnung anpassen) und Unit 2 Phase A (SimpleReachGoal).

Nicht weitergekommen?

Die häufigsten Hindernisse am ersten Abend: Godot älter als 4.5, Godot F6 gedrückt bevor der Python-Trainer wartete, oder Firewall blockiert den localhost-Socket. Lies Abschnitt 1 erneut, wenn die geteilte Architektur unklar ist.

Stretch Goals

Das exportierte ONNX inspizieren. Öffne examples/neural_foundations/game/unit_03_racer/models/foundations_racer.onnx in Netron (ziehe die Datei in den Browser-Tab — keine Installation). Identifiziere die Form des Eingabetensors (obs), die Form des Ausgabetensors (out0) und die Aktivierung zwischen den Schichten. Dieser Graph ist die portable Form des Gehirns — die Export → Verifizieren → Deployen Pipeline in Neuronale Grundlagen 3 baut darauf auf.

Die deterministischen Mathe-Tests ausführen. Das Spielprojekt liefert Headless-Tests für die Beobachtungs- und Belohnungsmathematik des Racers mit:

godot --headless --path examples/neural_foundations/game --script res://test/test_racer_math.gd

Es geht nicht um die Tests selbst — sondern darum zu bestätigen, dass dein godot-Kommandozeilen-Setup aus dem Setup funktioniert, worauf jede spätere Einheit aufbaut.

Wie geht es weiter?

Das Tooling funktioniert. In Neuronale Grundlagen 1 baust du ein sichtbares Neuron und verbindest Netze später mit der RL-Schleife.

Dazwischen liegen zwei optionale Auffrischungen: Mathe-Grundlagen 1 behandelt Vektoren und Skalarprodukt, Mathe-Grundlagen 2 Wahrscheinlichkeit und Erwartungswert. Überspringe sie, wenn dir das Rechnen in Neuronale Grundlagen 1 leichtfällt, und komm zurück, sobald die Notation einer späteren Einheit nicht mehr aufgeht.

→ Mathe-Grundlagen 1 · direkt zu Neuronale Grundlagen 1