Die Weltmodelle für Roboterlernen: Ein praktisches Leitfaden

Von Jerry Huang am 22. April 2026

Dies ist ein praktischer Leitfaden zum Ausbilden Ihres ersten Weltmodells für eine Roboterarbeit. Wir gehen durch die gesamte Pipeline: ein Modell auszuwählen, Daten vorzubereiten, zu trainieren, die Qualität der Vorstellungskraft zu bewerten und das ausgebildete Modell für die Planung oder die Verbesserung von Politik zu verwenden. Alle Codebeispiele verwenden Dreamer v3 als primäres Beispiel, mit Notizen zu TD-MPC2 und IRIS-Alternativen, wo sie sich unterscheiden.

Voraussetzungen

Hardware

GPU: NVIDIA RTX 3090, RTX 4090, oder A100. Dreamer v3 und TD-MPC2 trainieren auf einer einzigen Verbraucher-GPU. VRAM-Anforderung: Mindest 12 GB für staatlich-basierte Aufgaben, 24 GB empfohlen für vision-basierte Aufgaben mit 64x64 Bildern. Für 256x256 Bilder benötigen Sie 24 GB+ VRAM.
CPU/RAM: 8+ Kerne, 32GB+ RAM. Das Datenladen ist für große Datensätze mit Bildbeobachtungen CPU-gebunden. NVMe SSD-Speicher ist dringend empfohlen - HDD-basierte Datenladen wird Engpässe in der Ausbildung bringen.
Roboter (optional für erste Experimente): Sie können mit Simulationsumgebungen (DMControl, Meta-World, Robosuite) beginnen, die keine physische Hardware erfordern. Wenn Sie für echte Roboter-Experimente bereit sind, funktioniert jeder Arm mit Position-/Geschwindigkeitssteuerung und mindestens einer Kamera.

Software

Python 3.10+
JAX mit CUDA (für Dreamer v3) oder PyTorch 2.0+ (für TD-MPC2, IRIS)
Gymnasium (ehemals OpenAI Gym) für Simulationsumgebungen
Gewichte und Bias (optional, aber für die Experimentverfolgung empfohlen)

Daten

Sie benötigen Flugbahndaten: Sequenzen von (Beobachtung, Aktion, Belohnung, getan) Tuplen, die von Ihrem Roboter oder Simulationsumfeld aufgezeichnet wurden. Für erste Experimente verwenden Sie einen vorhandenen Datensatz oder sammeln Sie Daten aus einer Simulationsumgebung. Für echte Roboter-Weltmodelle benötigen Sie 50-500 Episoden, je nach Aufgabenkomplexität. Siehe [unsere Weltmodellübersicht]T0) für detaillierte Datenanforderungen.

Schritt 1: Wählen Sie Ihr Weltruf

Verwenden Sie diesen Entscheidungsträucher, um den richtigen Ausgangspunkt für Ihr Projekt zu wählen:

Welches Weltmodell?

F1: Ist Ihr Aktionsraum kontinuierlich?

Ja -> Gehen Sie zu Q2
Keine (diskretionäre Aktionen) -> Überlegen Sie IRIS (native diskreter Support) oder Dreamer v3 (unterstützt auch diskreter)

FRAG 2: Müssen Sie die Belohnung/Ziel zum Zeitpunkt der Bereitstellung ändern?

Ja -> Nutzen TD-MPC2 (Online-Planung mit flexibler Belohnung)
Nein -> Gehen Sie nach Q3

F3: Brauchen Sie die schnellstmögliche Trainingstheorie?

Ja -> Verwenden TD-MPC2 (2-12 Stunden Training auf einer einzelnen GPU)
Nein -> Gehen Sie zur Q4

F4: Braucht Ihre Aufgabe eine Planung von 15+ Schritten vor sich?

Ja -> Verwenden Sie Dreamer v3 (langer Vorstellungshorizont mit RSSM)
Entweder Dreamer v3 oder TD-MPC2 funktioniert. Dreamer v3 ist die sichere Standardform.

Für den Rest dieses Leitfaden verwenden wir Dreamer v3 als primäres Beispiel, da es das am weitesten verbreitete ist. Wir beachten TD-MPC2 und IRIS-Alternativen, wo sie sich unterscheiden.

Schritt 2: Bereiten Sie Ihre Daten vor

Folgeformat

Dreamer v3 erwartet Daten als Verzeichnis von NPZ-Dateien, eine pro Episode. Jede NPZ-Datei enthält NumPy-Arrays mit folgenden Tasten:

Import numpy als np # Beispiel: Speichern Sie eine Episode mit 200 Zeitschritten Episode = { # Visuelle Beobachtungen: (T, H, W, C), uint8, 0-255 'Bild': np.random.randint(0, 255, (200, 64, 64, 3), dtype=np.uint8), # Eigene Empfindungszustand: (T, state_dim), float32 # z.B., 7 gemeinsame Positionen + 7 gemeinsame Geschwindigkeiten + 1 Greifer-Stand = 15 'Stand': np.random.randn(200, 15).

Beobachtungsstruktur

Schlüsselentscheidungen für die Beobachtungsvertretung:

Bildlösung: Beginnen Sie mit 64x64. Dies reicht für die meisten Aufgaben der Manipulation auf dem Tisch und treibt 4x schneller als 128x128. Erhöhen Sie die Auflösung nur, wenn Sie feststellen, dass das Modell nicht die Aufgabenbezogenen visuellen Details (z. B. kleine Objekte, feine Orientierungen) bei 64x64 unterscheiden kann.
** Anzahl der Kameras:** Beginnen Sie mit einer (überkopf- oder handgelenkmontiert). Mehrfachkamera-Setups verbessern die Leistung, verdoppeln jedoch die Datengröße und die Trainingszeit pro zusätzliche Kamera.
Proprioception: Immer die gemeinsame Positionen, die gemeinsame Geschwindigkeiten und den Griffzustand enthalten. Diese liefern genaue Zustandsinformationen, die laute visuelle Beobachtungen ergänzen. Normalisieren Sie jede Dimension auf ungefähr null Mittel- und Einheitsvarianten.
History: Das RSSM von Dreamer v3 verarbeitet die Geschichte intern über den wiederkehrenden Zustand. Sie müssen keine Frames stapeln oder Beobachtungsgeschichte bereitstellen - nur die Beobachtung des aktuellen Zeitschrittes.

Normalisierung der Maßnahmen

Dies ist eine häufige Quelle von Ausbildungsfehlern.

Import numpy als np def normalisieren_aktionen(aktionen, action_low, action_high): """Normalisieren Sie Aktionen in [-1, 1] Bereich.""" Mittelock = (action_high + action_low) / 2.0 halb_range = (action_high - action_low) / 2.0 Return (actions - midpoint) / halb_range def normalisieren_aktionen(Normalisierte_aktionen, action_low, action_high): """Konvertieren [ 1] Aktionen zurück in den ursprünglichen Bereich.""" Mittelock = (action_high + action_low) / 2.0 halb_range = (action_high - action_low) / 2.0 Return (actions - midpoint) / halb_range def normalisieren _actions: \\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0

Dreamer v3 klippt Aktionen auf [-1, 1] intern. Wenn Ihre Rohaktionen bereits in diesem Bereich sind, ist keine Normalisierung erforderlich. TD-MPC2 erwartet auch [-1, 1] normalisierte Aktionen. IRIS diskretisiert Aktionen in Behälter, so dass die Normalisierung durch das Bining-System behandelt wird.

Umwandlung von LeRobot Format

Wenn Ihre Daten in [HuggingFace LeRobot Format](T1] liegen, verwenden Sie dieses Konvertierungsschrift:

Von lerobot.common.datasets.lerobot_datasets import LeRobotDataset von PIL import Import Bildimport numpy als np import os Dataset = LeRobotDataset("dein Benutzername/dein Dataset") os.makedirs("Dreamer_episodes", existieren_ok=True) #Gruppe nach Episode_indices = Dataset.hf_dataset.unique"episode_index") für ep_idx in episode_indices: ep_data = dataset.hf_dataset.filter lambda episode: x"episode\_index"\\idx) d.d.d.d.Dimimpressionen = d.d.impressionen = ep\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r

Schritt 3: Zug

Installation von Dreamer v3

# Installieren Sie JAX mit CUDA Support Pip Installation --upgrade "jax[cuda12]" Jaxlib # Clone Dreamer v3 git clone T13 cd dreamerv3 pip Installation -e . # Verifizieren Sie, ob die GPU verfügbar ist Python -c "import jax; print(jax.devices()) " # Sollte angezeigt werden: [CudaDevice(id=0)]

Konfiguration

Erstellen Sie eine Konfigurationsdatei für Ihre benutzerdefinierte Roboter-Aufgabe. Dreamer v3 verwendet YAML-Konfigurationen mit vernünftigen Standardfunktionen, die Sie überschreiben:

# config/robot_manipulation.yaml # Datendaten_dir: /path/to/dreamer_episodes/ replay_size: 1e6 # Replay Buffergröße in Übergangsschargen_size: 16 # Batchgröße für Trainingsschargen_Länge: 50 # Nachlänge für Training # Weltmodell rssm: deter: 4096 # Deterministische Staateinheit (GRU versteckt) Stock: 32 # Anzahl der Kategorischen Variablen Klassen: 32 # Klassen pro Kategorische Variableinheit: 1024 # MLP versteckte Verteilungseinheiten Encoder: mlp_keys: 'State' # Welche Beobachtungsschlüssel verwenden MLP-Encoder cnn_keys: 'Image' # Welche Beobachtungsschlüssel verwenden jede cnn_keys: 48_Deepthrough: #Connect: All-Level: All-Level: All-Level: All-Level: All-Level: All-Level:

Start-Schulungen

# Zug von Offline-Daten Python dreamerv3/main.py \ --configs Standardfunktionen \ --config config/robot_manipulation.yaml \ --logdir ./logdir/robot_v1 \ --steps 1000000 # Monitor mit TensorBoard --logdir ./logdir/robot_v1

TD-MPC2 Alternative:

# Installieren Sie Pip installieren Sie tdmpc2 # Zug auf Ihre Daten (HDF5-Format) python train.py \ task=custom \ data_dir=/path/to/hdf5_episodes/ \ model_size=19 \ steps=500000 \ batch_size=256

Was man beim Training beachten sollte

Überwachen Sie diese Metriken in TensorBoard oder W&B:

** Bildrekonstruktionsverlust (Decoder_image):** sollte stetig sinken. Wenn es hoch ist, ist die Encoder/Decoder-Kapazität unzureichend - erhöhen Sie die cnn_tiefe.
KL-Divergenz (kl_loss): Sollte zu einem moderaten Wert (typischerweise 1-10 Nats) konvergieren. Wenn es nahe an Null fällt, ignoriert das Modell das stochastische Latent - erhöhen Sie die KL-Freibits oder verringern Sie die KL-Skala. Wenn es sehr hoch ist (>50), kämpft das Dynamikmodell, um das Nachhinein zu prognostizieren - die Aufgabe kann mehr Trainingsschritte benötigen.
Loss der Belohnung (Decoder_Reward): Sollte abnehmen, insbesondere bei Aufgaben mit geringen Belohnungen, bei denen das Modell lernen muss, welche Zustände endgültig/erfolgreich sind.
** Schauspielerverlust und Kritikerverlust:** Diese sollten im Laufe der Zeit sinken. Wenn der Schauspielerverlust unregelmäßig ist, können die Einführung der Phantasie unzuverlässig sein - überprüfen Sie zuerst die Weltmodellverluste.
** Vorstellbare Rendite:** Die durchschnittliche Rendite der durch die Einführung des Akteurs im Weltmodell erdenkten Flugbahnen. Sollte sich mit der Verbesserung der Politik erhöhen.

Schritt 4: Beurteilen

Die Qualität der Einführung der Vorstellungskraft

Der direkte Weg, um Ihr Weltmodell zu bewerten, besteht darin, imaginierte Einführungszwecke zu visualisieren und mit der Realität zu vergleichen.

Importnumpy als np von Dreamerv3 Import Agent # Load trained agent agent = Agent.load.jpk.'./logdir/robot_v1/checkpoint.pkl') # Load a held-out test episode episode = np.load('test_episodes/episode_050.npz') real_images = episode['image'] # (T, 64, 64, 3) real_actions = episode'action'] # (T, action_dim) # Encode first observation = {'image': real_images[0:1], 'stateagesages': episode[state'][0:1] latent agent._model.tode) #imaged in imagination_images = t\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

Quantitative Metriken

Metric	What It Measures	Good Value	Horizon
Reconstruction MSE	Pixel-level prediction accuracy	< 0.01 (normalized)	1-step
SSIM	Structural visual similarity	> 0.85 at step 10, > 0.7 at step 50	Multi-step
Reward prediction accuracy	Can the model predict task success?	> 90% binary classification	Episode-level
State prediction error	Latent state divergence from ground truth	Task-dependent	Multi-step
Policy success rate (in imagination)	Does the learned policy solve the task in the world model?	> 80%	Episode-level
Policy success rate (real robot)	Does the policy actually work?	Task-dependent (gap with imagined rate indicates model error)	Episode-level

Die wichtigste Bewertung ist die Lücke zwischen der vorstellten Erfolgsrate und der realen Erfolgsrate. Wenn die Politik in der Vorstellungskraft 95%, aber nur 40% auf dem wirklichen Roboter erfolgreich ist, hat das Weltmodell erhebliche Ungenauigkeiten, die die Politik ausnutzt. Sammeln Sie mehr Daten in den Fehlerregionen und übertragen.

Schritt 5: Verwendung zur Planung oder zur Verbesserung der Politik

Option A: Die gelernte Politik einführen (Dreamer)

Das Dreamer-Actor-Netzwerk ist eine reaktive Politik: Angesichts des aktuellen latenten Zustands erzeugt es in ~ 1 ms eine Aktion.

# Einsatzschleife (vereinfacht) Agent = Agent.Lade('./logdir/robot_v1/checkpoint.pkl') latent = Nichts, während nicht getan: obs = get_robot_observation() # {'Bild': ..., 'State': ...} # Encode Beobachtung und Aktion von Akteur latent, Action = agent.policy(obs, latent) # Denormalieren und dem Roboter senden Raw_action = denormalieren_actionsaction, Action_low, Action_high) senden_to_robot(raw_action) time.sleep(1.0 / control_frequence) # z.B., 10Hz

Option B: Modell-Vorhersage mit TD-MPC2

TD-MPC2 verwendet das Weltmodell direkt für die Online-Planung über MPPI. Dies ist rechenintensiver, ermöglicht jedoch die Änderung des Ziels bei der Ausführung.

# TD-MPC2 Bereitstellungsschleife (vereinfacht) von tdmpc2 Import TDMPC2 Agent = TDMPC2.load('./Checkpoints/tdmpc2_robot.pt') während nicht durchgeführt: obs = get_robot_observation() # MPPI Planung: Proben 512 Aktionssequenzen, Scores via world model action = agent.act(obs, eval_mode=True) senden_to_robot(denormalize_actions(action, action_low, action_high)) time.sleep(1.0 / control_frequency)

Option C: Weltmodell als Datenvergrößerung

Verwenden Sie das geschulte Weltmodell, um synthetische Episoden für das Training einer Abstrahl-Difusion-Politik oder VLA zu erzeugen. Dies ist der geringste Risiko-Ansatz - das Weltmodell wird offline verwendet, nicht im Kontrollschleife.

""Ein synthetischer Episode mit Hilfe der erlernten Politik + Weltmodell" ("Latenz") = agent.world_model.encode(initial_obs) Bilder, Zustände, Aktionen, Belohnungen = [\], [], [\], \start [] für t in Sample\_steps: #Get off from learned policy action agent.actor_steps: ######################################################################################################################################################

Häufige Fehler

Zu wenig Daten

Die häufigste Fehler. Teams sammeln 20-50 Episoden, trainieren ein Weltmodell, finden es ungenau und schließen, dass Weltmodelle nicht für ihre Aufgabe funktionieren. In Wirklichkeit reichen 20 Episoden nur für die einfachsten Aufgaben aus. Budget 100-200 Episoden Mindest für jede nicht-trivielle Manipulation Aufgabe. Wenn Sie nicht so viele sammeln können, verwenden Sie TD-MPC2 (das aufgrund der Online-Planung besser Daten effizient ist) statt Dreamer.

2. Fehlbeobachtungsmodalität

Das Weltmodell muss Roboterkinematik allein aus Pixel lernen, was viel mehr Daten erfordert als direkt gemeinsame Zustände zu liefern. Umgekehrt, nur mit proprioception, wenn die Aufgabe eine Argumentation über Objektepositionen oder Orientierungen erfordert, die nicht im Roboterzustand erfasst werden - in diesem Fall benötigen Sie Bilder.

3. Unzureichende Folgevielfalt

Ein Datensatz, bei dem jede Episode mit dem Objekt in der gleichen Position beginnt, lehrt das Weltmodell eine schmale Fläche des Zustandsraums. Bewisserweise zu randomisieren, die ersten Bedingungen während der Datenerhebung: Objektpositionen, Orientierungen, Startkonfiguration des Roboters und Umweltbedingungen (Beleuchtung, Hintergrund).

4. Ungleichmäßige Steuerfrequenz

Das Weltmodell lernt Dynamik bei der Zeitlösung der Daten. Wenn man bei 30 Hz trainiert, produziert jede Aktion eine kleine Zustandsänderung. Wenn man dann bei 10 Hz eintritt, sollte jede Aktion eine 3x größere Zustandsänderung erzeugen - aber das Modell hat das nie gesehen. Wenn Sie die Frequenz ändern müssen, sammeln Sie Daten an der Zielfrequenz wieder.

5. Das Belohnungssignal ignoriert

Für Aufgaben mit geringen Belohnungen (Erfolg/Niederlage am Ende der Folge) braucht der Belohnungsprädiktor genug positive Beispiele, um zu lernen. Entweder (a) sammeln Sie erfolgreichere Demonstrationen, (b) fügen Sie eine zwischenspezifische Belohnungsschaltung hinzu oder (c) verwenden Sie das Weltmodell nur für Dynamik (Datenvergrößerung) anstatt für die Politikoptimierung.

6. Zu lange ohne Beurteilung

Die Verluste bei der weltweiten Ausbildungsmodellbildung können weiter sinken, während die tatsächliche politische Leistung stagniert oder abnimmt (überpassung zum Wiederholungspuffer). Beurteilen Sie auf dem echten Roboter (oder ausgehaltenen Simulationsepisoden) alle 100K-Schritte des Trainings.

Wo können Sie Schulungsdaten erhalten

RCSV-Datendienste

RCSV produziert Datenmengen, die für die weltweite Modellbildung optimiert sind. Episoden werden bei einer festen 50Hz mit hardware-zeitmarkierten Synchronisierung, Multi-View RGB, kalibrierter proprioception und strukturierter Variation unter den Anfangsbedingungen aufgezeichnet. Die Datensätze werden in einem Dreamer-kompatiblen NPZ-Format, TD-MPC2 HDF5-Format oder LeRobot Parquet-Format nach Ihren Vorlieben geliefert.

Für Weltmodellprojekte speziell bieten wir ein "Dynamik-Diversität" Sammelprotokoll an, das die Reichweite des Staates maximiert: Episoden umfassen sowohl erfolgreiche als auch erfolglose Aufgabenvollendungen, unterschiedliche Ansatzstrategien, Störungserholung und Randfall-Szenarien. Dies erzeugt Weltmodelle mit einer breiteren Reichweite als nur erfolgreiche Datensätze. Die Pilotkampagnen beginnen bei 2.500 Dollar für 200 Episoden. [Kontaktieren Sie uns] T3) für ein benutzerdefiniertes Angebot.

Öffnen von Datensätzen

Dataset	Episodes	Robots	Observations	Weltmodell Suitability
DROID	76K	Franka Panda	Multi-view RGB, proprio, language	Excellent -- large, diverse, multi-task
Bridge V2	60K	WidowX	Single RGB, proprio, language	Good -- diverse tasks, single viewpoint
Open X-Embodiment	1M+	22 robot types	Varies by sub-dataset	Good for pre-training foundation world models
RoboTurk	2.1K	Sawyer	RGB, proprio	Fair -- smaller scale, good for initial testing
RCSV Public Datasets	Varies	UR5e, Franka, ALOHA	Multi-view RGB, proprio, F/T	Good -- pre-formatted for Dreamer/TD-MPC2

Für das Vor-Training eines Allgemeinzweck-Weltmodells, beginnen Sie mit Open X-Embodiment oder DROID, dann feinen Sie auf Daten von Ihrem spezifischen Roboter und Aufgabe. Für Task-spezifische Weltmodelle ohne Vor-Training, DROID oder Bridge V2 gefiltert auf Manipulation Aufgaben ähnlich Ihrem bietet einen guten Ausgangspunkt. RCSV [öffentliche Datensätze] T4) sind bereits für den direkten Einsatz mit Dreamer v3 und TD-MPC2 formatiert.

Häufig gestellte Fragen

Wie viele Daten brauche ich, um ein Weltmodell für meinen Roboter zu trainieren?

Für eine einzige Manipulations-Aufgabe mit Dreamer v3 oder TD-MPC2 benötigen Sie mindestens 50-200 Episoden (10K-50K Übergangsverhältnisse). Für robuste Einsatzleistung mit Objektpositionsauswiedergang, Budget 300-500 Episoden. IRIS benötigt aufgrund der VQ-VAE Tokenizer-Overhead-Ausbildung 2-3x mehr. Qualität und Vielfalt sind mehr wichtig als Rohvolumen - 200 verschiedene Episoden übertreffen 1000 nahezu identische.

Kann ich ein Weltmodell auf einer einzigen Konsumentengruppe trainieren?

Ja. Dreamer v3 und TD-MPC2 trainieren beide auf einem einzigen RTX 3090 oder RTX 4090. Trainingstunden reichen je nach Datensatz und Modellkonfiguration von 2 bis 24 Stunden. IRIS ist rechenintensiver (12 bis 48 Stunden auf einer einzigen GPU). Sie benötigen keine A100s oder Multi-GPU-Setups, es sei denn, Sie trainieren UniSim-Skala-Pixel-Raum-Weltmodelle.

Was ist der Unterschied zwischen einem Weltmodell und einem Simulator wie MuJoCo oder Isaac Sim?

Ein Physik-Simulator implementiert handgefertigte Gleichungen der Bewegung (starre Körperdynamik, Kontaktmodelle, Reibungskugeln). Ein Weltmodell lernt Dynamik aus Daten. Der Simulator ist für starre Körper genau, kämpft aber mit deformierbaren Objekten, Kabeln, Flüssigkeiten und Sensorlärm. Das Weltmodell erfasst die Dynamik, die in seinen Trainingsdaten vorhanden ist, einschließlich Phänomene, die analytisch schwer zu simulieren sind.

Soll ich ein Weltmodell oder eine Verbreitungspolitik verwenden?

Sie sind nicht gegenseitig ausschließend. Ein Weltmodell lernt die Umweltdynamik für Planung und Datenverstärkung. Eine Diffusionspolitik ist eine Kontrollpolitik, die Aktionen aus Beobachtungen erzeugt. Sie können ein Weltmodell verwenden, um synthetische Trainingsdaten für eine Diffusionspolitik zu generieren, oder ein Weltmodell verwenden, um Kandidatenbahnlinien zu bewerten und auszuwählen, die durch eine Diffusionspolitik vorgeschlagen werden. Wenn Sie eine auswählen müssen, verwenden Sie eine [Distribution Policy]T5) für direkte Imitationslern aus Demonstrationen und ein Weltmodell, wenn Sie Online-RL, Planung oder die Fähigkeit zur Änderung von Zielen zur Bereitstellung benötigen.

Woher weiß ich, ob mein Weltmodell genau genug ist?

Bewertet auf ausgehaltenen real-world-trajectories. Verschlüsselung der ersten Beobachtung, rollen Sie das Weltmodell mit den aufgezeichneten Aktionen aus und vergleichen Sie vorhergesagte Beobachtungen mit den tatsächlichen aufgezeichneten Beobachtungen. Schlüsselmetriken: Rekonstruktion MSE, SSIM für die visuelle Qualität, Präzision der Belohnung und Fehler der Zustand-Vorhersage am Horizont 10/20/50. Wenn sich die vorstellten Einführungspläne innerhalb der typischen Episodelänge Ihrer Aufgabe sichtbar von der Realität abweichen, benötigt das Modell mehr Daten oder architektonische Änderungen.

Kann ich ein vorgeübtes Weltmodell auf die Daten meines Robots anpassen?

Ja, und dies ist zunehmend der empfohlene Ansatz. Für Dreamer v3 und TD-MPC2 können Sie an einem Kontrollpunkt initialisieren, der auf Simulationsdaten ausgebildet ist (z. B. von MuJoCo oder Isaac Sim) und auf echte Roboterdaten einstellen. Dies erfordert typischerweise 50-100 echte Episoden, um das Dynamikmodell an die reale Physik anzupassen, verglichen mit 200-500 Episoden, wenn Sie von Grund auf trainieren. Stiftungs-Weltmodelle wie Genie sind explizit für dieses Vor-Train-then-Fine-Tune-Paradigma konzipiert.