TL;DR
- Installieren Sie MuJoCo 3.2.0 über
pip install mujocound überprüfen Sie mitpython -c "import mujoco; print(mujoco.__version__)"→3.2.0. - Modellieren Sie Roboter in MJCF (XML) mit den Tags
<world>,<body>,<joint>und<actuator>. Beispiel: minimales humanoides XML. - Passen Sie die Physik mit den Tags
<contact>(Reibung, Steifigkeit) und<solver>(Iterationen, Toleranz) an. Standard-Reibung:mu=0.5,mu2=0.0. - Führen Sie GPU-parallele Simulationen mit MJX durch (erfordert CUDA). Beispiel:
python -m mujoco.mjx_simulate --gpu. - Laden Sie Gymnasium-Umgebungen über
gymnasium.make("Humanoid-v4")und trainieren Sie mit Stable Baselines3. - Sim-to-real-Transfer: Nutzen Sie Systemidentifikation (z. B.
scipy.optimizefür Parameteranpassung) und protokollieren Sie Daten mitmjData-Strukturen.
1. Installation und MJCF-Grundlagen
Die Python-Bindings von MuJoCo (mujoco) sind der schnellste Einstieg. MJCF (MuJoCo XML Format) ist die Kernmodellierungssprache – denken Sie daran als eine physikbewusste CAD-Datei.
Installation von MuJoCo 3.2.0
# Linux (Ubuntu/Debian)
sudo apt-get install -y libgl1-mesa-dev libxinerama-dev libxcursor-dev
pip install mujoco==3.2.0 # Version festlegen
# Installation überprüfen
python -c "import mujoco; print(f'MuJoCo {mujoco.__version__} erfolgreich installiert')"
Erwartete Ausgabe:
MuJoCo 3.2.0 erfolgreich installiert
MJCF: Das XML-Gerüst
MuJoCo-Modelle werden in XML-Dateien (.xml) definiert. Hier ein minimales Beispiel für ein 2D-Pendel:
<mujoco model="pendulum">
<worldbody>
<light name="light" pos="0 0 3"/>
<camera name="camera" pos="0 0 1.5" xyaxes="1 0 0 0 1 0"/>
<body name="pendulum" pos="0 0 0">
<joint name="hinge" type="hinge" axis="0 0 1"/>
<geom name="bob" type="sphere" size="0.1" rgba="0.8 0.6 0.4 1"/>
</body>
<actuator name="motor">
<motor joint="hinge"/>
</actuator>
</worldbody>
</mujoco>
Wichtige Tags:
<worldbody>: Behälter für alle physikalischen Objekte.<body>: Starre Körper (z. B. Roboter-Glieder).<joint>: Definiert Freiheitsgrade (hinge,slide,ball).<geom>: Kollisionsgeometrie (box,sphere,mesh).<actuator>: Motoren, Kräfte oder Drehmomente.
Achtung: Vergessen Sie nicht, Tags zu schließen (z. B. <body> ohne </body>), sonst stürzt der Simulator ab. Nutzen Sie einen Validator wie XMLLint.
2. Roboter-Modellierung: Körper, Gelenke und Aktuatoren
Lassen Sie uns einen 7-Freiheitsgrad-Roboterarm mit MJCF erstellen. Konzentrieren Sie sich auf:
- Körper: Glieder mit Masse/Trägheit.
- Gelenke: Verbinden von Körpern mit Beschränkungen.
- Aktuatoren: Anlegen von Kräften/Drehmomenten.
Beispiel: 7-Freiheitsgrad-Arm in MJCF
<mujoco model="arm7dof">
<asset>
<mesh file="arm.mesh" scale="0.1"/>
</asset>
<worldbody>
<!-- Basis -->
<body name="base" pos="0 0 0.5">
<freejoint/>
<geom type="box" size="0.2 0.2 0.1" rgba="0.5 0.5 0.5 1"/>
</body>
<!-- Arm-Glieder (Gelenke dazwischen) -->
<body name="link1" pos="0 0 0.3">
<joint name="joint1" type="hinge" axis="0 1 0" damping="0.1"/>
<geom type="box" size="0.1 0.1 0.3" rgba="0.8 0.6 0.4 1"/>
</body>
<!-- Wiederholen für Glieder 2-7... -->
<!-- Aktuatoren (einer pro Gelenk) -->
<actuator name="motor1">
<motor joint="joint1" gear="100"/>
</actuator>
</worldbody>
</mujoco>
Kritische Einstellungen:
damping: Reduziert Gelenkschwingungen (Standard:0.0).gear: Simuliert Übersetzungsverhältnisse (z. B.gear="100"= 100:1 Untersetzung).size: Geometrieabmessungen (müssen mit der CAD übereinstimmen, falls<mesh>verwendet wird).
Achtung: MuJoCo verwendet SI-Einheiten (Meter, Kilogramm, Sekunden). Ein size="0.1"-Würfel ist 10 cm breit.
3. Kontakte, Reibung und Solver-Einstellungen
Die Genauigkeit der MuJoCo-Physik hängt von der Kontaktmodellierung und der Solver-Optimierung ab.
Kontakteigenschaften
Passen Sie die <contact>-Tags an, um Reibung, Elastizität und Steifigkeit zu steuern:
<contact>
<geom1>body1</geom1>
<geom2>body2</geom2>
<friction>0.3 0.01 0.001</friction> <!-- mu, mu2, mu3 -->
<restitution>0.5</restitution> <!-- Elastizität (0-1) -->
<solref>0.01 1.0</solref> <!-- Solver-Referenz (Penetration, Steifigkeit) -->
</contact>
Standardwerte:
- Reibung:
mu=0.5,mu2=0.0(statisch/dynamisch). - Elastizität:
0.0(kein Abprallen).
Solver-Optimierung
Passen Sie den Solver für Stabilität an:
<solver>
<iterations>100</iterations> <!-- Standard: 100 -->
<tolerance>1e-8</tolerance> <!-- Standard: 1e-8 -->
<constraint>LRP</constraint> <!-- "LRP" oder "NCP" -->
</solver>
Wann anpassen?:
- Hohe Iterationen (200+): Für komplexe Kontakte (z. B. geschickte Hände).
- Geringere Toleranz (1e-6): Schneller, aber weniger genau.
Achtung: Falls Ihre Simulation explodiert, erhöhen Sie solref oder verringern Sie iterations. Bei Steifigkeit senken Sie restitution.
4. MJX für GPU-parallele Simulation
MJX (MuJoCo eXtended) ermöglicht GPU-beschleunigte parallele Simulation, entscheidend für das Reinforcement Learning (RL)-Training.
Installation von MJX
pip install mujoco==3.2.0 mjx # MJX ist in mujoco>=3.2.0 enthalten
CUDA-Unterstützung überprüfen:
python -c "import mjx; print(mjx.cuda.is_available())" # Sollte True zurückgeben
Pendel-Simulation auf der GPU ausführen
import mjx
import numpy as np
# Modell laden
model = mjx.make("pendulum.xml")
sim = mjx.Sim(model)
# 100 Schritte simulieren
for _ in range(100):
sim.step()
Erwartete Ausgabe: Das Pendel schwingt glatt (visualisiert über sim.render()).
Achtung: MJX erfordert CUDA 11.8+. Prüfen Sie die Kompatibilität mit:
nvcc --version
5. RL mit Gymnasium-Umgebungen durchführen
MuJoCo treibt die Gymnasium-Robotikbenchmarks an (z. B. Humanoid-v4). So trainieren Sie einen RL-Agenten.
Gymnasium mit MuJoCo installieren
pip install gymnasium[mujoco] # Enthält MuJoCo 3.2.0
Umgebung laden und Agenten trainieren
import gymnasium as gym
from stable_baselines3 import PPO
# Umgebung initialisieren
env = gym.make("Humanoid-v4", render_mode="human")
obs, _ = env.reset()
# Mit PPO trainieren
model = PPO("MlpPolicy", env, verbose=1)
model.learn(total_timesteps=10000)
# Testen
obs, _ = env.reset()
for _ in range(1000):
action, _ = model.predict(obs)
obs, _, terminated, truncated, _ = env.step(action)
if terminated or truncated:
obs, _ = env.reset()
Wichtige Umgebungen:
Humanoid-v4: 3D-Humanoid-Lokomotion.Ant-v4: Vierbeiniges Laufen.Reacher-v4: 2D-Arm-Erreichen.
Achtung: Die MuJoCo-Umgebungen von Gymnasium nutzen standardmäßig die GPU. Bei CUDA-Fehlern setzen Sie:
env = gym.make("Humanoid-v4", render_mode=None, use_gpu=False)
6. Sim-to-real-Herausforderungen und Systemidentifikation
Die MuJoCo-Physik ist nicht perfekt. Schließen Sie die Lücke zwischen Simulation und Realität mit:
- Systemidentifikation: Passen Sie MuJoCo-Parameter an die reale Hardware an.
- Domain-Randomisierung: Trainieren Sie mit variierten MuJoCo-Parametern.
Beispiel für Systemidentifikation
Nutzen Sie scipy.optimize, um die Masse/Trägheit von MuJoCo an reale Daten anzupassen:
import mujoco
import numpy as np
from scipy.optimize import minimize
# Modell und Daten laden
model = mujoco.MjModel.from_xml_path("robot.xml")
data = mujoco.MjData(model)
# Kostenfunktion definieren (z. B. Fehler zwischen Simulations- und realem Drehmoment)
def cost_function(params):
# Modellparameter aktualisieren (z. B. Masse)
model.body_mass[0] = params[0]
# Simulieren und Fehler berechnen
error = simulate_and_compare(data)
return error
# Optimieren
result = minimize(cost_function, x0=[1.0], method="L-BFGS-B")
print(f"Optimale Masse: {result.x[0]} kg")
Domain-Randomisierung
Randomisieren Sie MuJoCo-Parameter während des Trainings:
def randomize_model(model):
# Reibung randomisieren
model.contact.mu = np.random.uniform(0.3, 0.7)
model.contact.mu2 = np.random.uniform(0.0, 0.1)
# Masse randomisieren
model.body_mass = model.body_mass * np.random.uniform(0.9, 1.1)
return model
Achtung: Der Sim-to-real-Transfer scheitert oft an unmodellierten Dynamiken (z. B. Kabelreibung). Beginnen Sie mit identischen Massen/Trägheitsmomenten und randomisieren Sie schrittweise.
7. Visualisierung und Protokollierung
Der integrierte MuJoCo-Viewer ist leichtgewichtig, aber effektiv.
Viewer starten
import mujoco
import mujoco.viewer
model = mujoco.MjModel.from_xml_path("arm7dof.xml")
data = mujoco.MjData(model)
# Viewer erstellen
with mujoco.viewer.launch_passive(model, data) as viewer:
while viewer.is_running():
step = not viewer.cam_move
mujoco.mj_step(model, data)
Steuerung:
- Linksklick + ziehen: Kamera drehen.
- Rechtsklick + ziehen: Verschieben.
- Scrollrad: Zoomen.
Daten für die Analyse protokollieren
Speichern Sie Simulationsdaten in einer .mat-Datei:
import scipy.io
# Simulieren und protokollieren
data = mujoco.MjData(model)
for _ in range(1000):
mujoco.mj_step(model, data)
# Gelenkpositionen speichern
joint_positions = data.qpos.copy()
# In MATLAB-Datei speichern
scipy.io.savemat("simulation_data.mat", {"qpos": joint_positions})
Achtung: Der Viewer blockiert die Python-Ausführung. Nutzen Sie launch_passive für Hintergrund-Rendering.
Was kommt als Nächstes?
- Eigenen Roboter bauen: Beginnen Sie mit einem 7-Freiheitsgrad-Arm (Abschnitt 2) und exportieren Sie dessen MJCF in ein CAD-Tool wie Blender.
- RL-Agenten trainieren: Nutzen Sie Stable Baselines3 (Abschnitt 5), um Ihrem Roboter eine Fähigkeit (z. B. Greifen) beizubringen.
- Auf Hardware deployen: Nutzen Sie Systemidentifikation (Abschnitt 6), um MuJoCo für Ihren echten Roboter anzupassen.
Für Physical AI-Infrastruktur – von der Simulator-Kalibrierung bis zum Edge-Deployment – können die Tools und das Know-how von Hyperion Consulting Ihre Pipeline beschleunigen. Kontaktieren Sie uns
