TL;DR
- Installeer MuJoCo 3.2.0 via
pip install mujocoen verifieer metpython -c "import mujoco; print(mujoco.__version__)"→3.2.0. - Modelleer robots in MJCF (XML) met tags zoals
<world>,<body>,<joint>en<actuator>. Voorbeeld: minimale humanoïde XML. - Pas fysieke eigenschappen aan met
<contact>(wrijving, stijfheid) en<solver>(iteraties, tolerantie). Standaardwrijving:mu=0.5,mu2=0.0. - Voer GPU-parallelle simulaties uit met MJX (vereist CUDA). Voorbeeld:
python -m mujoco.mjx_simulate --gpu. - Laad Gymnasium-omgevingen via
gymnasium.make("Humanoid-v4")en train met Stable Baselines3. - Overdracht van simulatie naar werkelijkheid: Gebruik systeemidentificatie (bijv.
scipy.optimizevoor parameteroptimalisatie) en log gegevens metmjData-structuren.
1. Installatie en MJCF-basisprincipes
De Python-bindings van MuJoCo (mujoco) zijn de snelste manier om te beginnen. MJCF (MuJoCo XML Format) is de kernprogrammeertaal—denk eraan als een fysica-aware CAD-bestand.
Installeer 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 # Bevestig op stabiele versie
# Verifieer installatie
python -c "import mujoco; print(f'MuJoCo {mujoco.__version__} succesvol geïnstalleerd')"
Verwachte uitvoer:
MuJoCo 3.2.0 succesvol geïnstalleerd
MJCF: De XML-basis
MuJoCo-modellen worden gedefinieerd in XML-bestanden (.xml). Hier een eenvoudig voorbeeld voor een 2D-pendulum:
<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>
Belangrijke tags:
<worldbody>: Hoofdcontainer voor alle fysieke objecten.<body>: Stijve lichamen (bijv. robotsegmenten).<joint>: Definieert vrijheidsgraden (hinge,slide,ball).<geom>: Botsingsgeometrieën (box,sphere,mesh).<actuator>: Motoren, krachten of koppels.
Opgelet: Vergeet niet tags te sluiten (bijv. <body> zonder </body>), anders crasht de simulator. Gebruik een validator zoals XMLLint.
2. Een robot modelleren: lichamen, gewrichten en actuatoren
Laten we een 7-vrijheidsgraden robotarm bouwen met MJCF. Focus op:
- Lichamen: Segmenten met massa/inertie.
- Gewrichten: Verbindingen tussen lichamen met beperkingen.
- Actuatoren: Toepassing van krachten/koppels.
Voorbeeld: 7-vrijheidsgraden 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>
<!-- Armsegmenten (gewrichten ertussen) -->
<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>
<!-- Herhaal voor segmenten 2-7... -->
<!-- Actuatoren (één per gewricht) -->
<actuator name="motor1">
<motor joint="joint1" gear="100"/>
</actuator>
</worldbody>
</mujoco>
Kritieke instellingen:
damping: Vermindert trillingen in gewrichten (standaard:0.0).gear: Simuleert tandwielverhoudingen (bijv.gear="100"= reductieverhouding 100:1).size: Afmetingen van de geometrie (moet overeenkomen met CAD als<mesh>wordt gebruikt).
Opgelet: MuJoCo gebruikt SI-eenheden (meters, kilogrammen, seconden). Een size="0.1" box is 10 cm breed.
3. Contacten, wrijving en solver-instellingen
De nauwkeurigheid van de fysica in MuJoCo hangt af van contactmodellering en solver-afstemming.
Contacteigenschappen
Pas <contact>-tags aan om wrijving, terugvering (bounce) en stijfheid te beheersen:
<contact>
<geom1>body1</geom1>
<geom2>body2</geom2>
<friction>0.3 0.01 0.001</friction> <!-- mu, mu2, mu3 -->
<restitution>0.5</restitution> <!-- Terugvering (0-1) -->
<solref>0.01 1.0</solref> <!-- Solverreferentie (penetratie, stijfheid) -->
</contact>
Standaardwaarden:
- Wrijving:
mu=0.5,mu2=0.0(statisch/dynamisch). - Terugvering:
0.0(geen bouncen).
Solver-afstemming
Pas de solver aan voor stabiliteit:
<solver>
<iterations>100</iterations> <!-- Standaard: 100 -->
<tolerance>1e-8</tolerance> <!-- Standaard: 1e-8 -->
<constraint>LRP</constraint> <!-- "LRP" of "NCP" -->
</solver>
Wanneer afstemmen:
- Hoge iteraties (200+): Voor complexe contacten (bijv. dexterous handen).
- Lagere tolerantie (1e-6): Snel, maar minder nauwkeurig.
Opgelet: Als je simulatie explodeert, verhoog dan solref of verminder iterations. Bij stijf gedrag, verlaag restitution.
4. MJX voor GPU-parallelle simulatie
MJX (MuJoCo eXtended) maakt GPU-versnelde parallelle simulatie mogelijk, cruciaal voor reinforcement learning (RL)-training.
Installeer MJX
pip install mujoco==3.2.0 mjx # MJX is gebundeld met mujoco>=3.2.0
Verifieer CUDA-ondersteuning:
python -c "import mjx; print(mjx.cuda.is_available())" # Moet True retourneren
Voer een GPU-gedreven pendulum-simulatie uit
import mjx
import numpy as np
# Laad model
model = mjx.make("pendulum.xml")
sim = mjx.Sim(model)
# Voer 100 stappen uit
for _ in range(100):
sim.step()
Verwachte uitvoer: Het pendulum zwaait soepel (visualiseer via sim.render()).
Opgelet: MJX vereist CUDA 11.8+. Controleer compatibiliteit met:
nvcc --version
5. RL uitvoeren met Gymnasium-omgevingen
MuJoCo is de basis voor Gymnasium’s robotica-benchmarks (bijv. Humanoid-v4). Hier hoe je een RL-agent traint.
Installeer Gymnasium met MuJoCo
pip install gymnasium[mujoco] # Omvat MuJoCo 3.2.0
Laad en train een agent
import gymnasium as gym
from stable_baselines3 import PPO
# Initialiseer omgeving
env = gym.make("Humanoid-v4", render_mode="human")
obs, _ = env.reset()
# Train met PPO
model = PPO("MlpPolicy", env, verbose=1)
model.learn(total_timesteps=10000)
# Test
obs, _ = env.reset()
for _ in range(1000):
action, _ = model.predict(obs)
obs, _, terminated, truncated, _ = env.step(action)
if terminated or truncated:
obs, _ = env.reset()
Belangrijke omgevingen:
Humanoid-v4: 3D-locomotie van humanoïde.Ant-v4: Loopbeweging van viervoeter.Reacher-v4: 2D-arm bereikt doel.
Opgelet: De Gymnasium-omgevingen van MuJoCo gebruiken standaard GPU. Bij CUDA-fouten:
env = gym.make("Humanoid-v4", render_mode=None, use_gpu=False)
6. Simulatie-naar-realiteit: valkuilen en systeemidentificatie
De fysica in MuJoCo is niet perfect. Overbrug de kloof tussen simulatie en realiteit met:
- Systeemidentificatie: Pas MuJoCo-parameters aan om ze te laten overeenstemmen met de werkelijke hardware.
- Domain Randomization: Train op gevarieerde MuJoCo-parameters.
Voorbeeld systeemidentificatie
Gebruik scipy.optimize om de massa/inertie van MuJoCo af te stemmen op werkelijke gegevens:
import mujoco
import numpy as np
from scipy.optimize import minimize
# Laad model en gegevens
model = mujoco.MjModel.from_xml_path("robot.xml")
data = mujoco.MjData(model)
# Definieer kostenfunctie (bijv. fout tussen sim en werkelijk koppel)
def cost_function(params):
# Pas modelparameters aan (bijv. massa)
model.body_mass[0] = params[0]
# Voer simulatie uit en bereken fout
error = simulate_and_compare(data)
return error
# Optimaliseer
result = minimize(cost_function, x0=[1.0], method="L-BFGS-B")
print(f"Optimaal gewicht: {result.x[0]} kg")
Domain Randomization
Randomiseer MuJoCo-parameters tijdens het trainen:
def randomize_model(model):
# Randomiseer wrijving
model.contact.mu = np.random.uniform(0.3, 0.7)
model.contact.mu2 = np.random.uniform(0.0, 0.1)
# Randomiseer massa
model.body_mass = model.body_mass * np.random.uniform(0.9, 1.1)
return model
Opgelet: Overdracht van simulatie naar realiteit mislukt vaak door ongemodelleerde dynamica (bijv. kabelwrijving). Begin met identieke massa/inertie en randomiseer geleidelijk.
7. Visualisatie en loggen
De ingebouwde viewer van MuJoCo is lichtgewicht maar effectief.
Start de viewer
import mujoco
import mujoco.viewer
model = mujoco.MjModel.from_xml_path("arm7dof.xml")
data = mujoco.MjData(model)
# Maak viewer aan
with mujoco.viewer.launch_passive(model, data) as viewer:
while viewer.is_running():
step = not viewer.cam_move
mujoco.mj_step(model, data)
Besturingen:
- Linksklik + slepen: Draai camera.
- Rechtsklik + slepen: Verplaats camera.
- Scroll: Zoom in/uit.
Log gegevens voor analyse
Sla simulatiegegevens op in een .mat-bestand:
import scipy.io
# Simuleer en log
data = mujoco.MjData(model)
for _ in range(1000):
mujoco.mj_step(model, data)
# Sla gewrichtsposities op
joint_positions = data.qpos.copy()
# Sla op in MATLAB-bestand
scipy.io.savemat("simulation_data.mat", {"qpos": joint_positions})
Opgelet: De viewer blokkeert Python-uitvoering. Gebruik launch_passive voor achtergrond-rendering.
Wat nu?
- Bouw een aangepaste robot: Begin met een 7-vrijheidsgraden arm (Afdeling 2) en exporteer het MJCF naar een CAD-tool zoals Blender.
- Train een RL-agent: Gebruik Stable Baselines3 (Afdeling 5) om je robot een vaardigheid bij te brengen (bijv. bereiken).
- Implementeer op hardware: Gebruik systeemidentificatie (Afdeling 6) om MuJoCo af te stemmen op je echte robot.
Voor fysieke AI-infrastructuur—van simulatorafstemming tot edge-deployments—kan Hyperion Consulting uw pipeline versnellen. Neem contact met ons op
