Genesis einrichten: Ein praktischer Leitfaden für physische KI

Zusammenfassung (TL;DR)

• Genesis in 5 Minuten installieren mit pip install genesis-world oder Docker für GPU-Beschleunigung.
• Starre, gelenkige und weiche Körper simulieren mit YAML/JSON-Konfigurationen – für Basiseinstellungen ist kein Code nötig.
• 10.000+ parallele Umgebungen für RL-Training mit Ray oder MPI generieren.
• URDF/MJCF-Roboter mit einem Befehl importieren und Sensoren (LiDAR, Kameras) über die Python-API anschließen.
• Richtlinien im großen Stil mit Stable Baselines3 oder RLlib trainieren – Daten für die Analyse in CSV/JSON exportieren.

1. Installation und erste Szene

Genesis installieren

Wählen Sie die Methode basierend auf Ihrer Hardware und Ihrem Workflow:

Option 1: Pip-Installation (Empfohlen für die meisten Nutzer)

pip install "genesis-world>=2.4.0" --upgrade

Installation überprüfen:

python -c "import genesis; print(genesis.__version__)"

Erwartete Ausgabe:

2.4.0

Option 2: Docker (GPU-Beschleunigt)

docker pull genesisworld/genesis:latest
docker run --gpus all -it genesisworld/genesis:latest python -c "import genesis; print('GPU erkannt:', genesis.is_gpu_available())"

Erwartete Ausgabe:

GPU erkannt: True

Option 3: Aus dem Quellcode (Für Entwicklung)

git clone https://github.com/genesis-sim/genesis.git
cd genesis
pip install -e ".[dev]"  # Installiert Entwicklungsabhängigkeiten (Testen, Linting)

Erste Szene erstellen

Genesis nutzt YAML/JSON-Konfigurationen für Umgebungen. Beginnen Sie mit einer einfachen 2D-Welt:

1. Erstellen Sie simple_world.yaml:

   name: "Einfache 2D-Welt"
   description: "Eine grundlegende Umgebung mit 1 Agenten und statischen Hindernissen."
   physics:
     engine: "pybullet"  # Unterstützt "pybullet", "mujoco" oder "custom"
     gravity: [0.0, 0.0, -9.81]
   agents:
     - name: "agent_0"
       type: "circle"
       radius: 0.5
       color: [0.0, 0.5, 1.0]  # RGB
       initial_position: [0.0, 0.0]
   obstacles:
     - type: "rectangle"
       width: 2.0
       height: 0.2
       position: [0.0, -1.0]
       color: [0.5, 0.0, 0.0]
   

   Copy

2. Simulation starten:

   python -m genesis run --config simple_world.yaml --headless False
   

   Copy

   Erwartete Ausgabe: Ein Fenster öffnet sich mit einem 2D-Renderer, der Ihren Agenten und das Hindernis anzeigt.

Wichtige Stolpersteine

• Fehler: ModuleNotFoundError: No module named 'pybullet' → Installieren Sie PyBullet:

  pip install pybullet
  

  Copy
• Fehler: CUDA nicht verfügbar → Stellen Sie sicher, dass Sie den Docker-GPU-Befehl verwenden oder die CUDA-Treiber installiert sind Genesis-Dokumentation.

2. Simulation starrer, gelenkiger und weicher Körper

Physik starrer Körper

Passen Sie simple_world.yaml an, um einen Roboter mit starrem Körper hinzuzufügen:

agents:
  - name: "robot_arm"
    type: "urdf"
    urdf_file: "pfad/zum/robot.urdf"
    initial_position: [1.0, 0.0]
    joints:
      - name: "joint_1"
        type: "revolute"
        lower_limit: -1.57
        upper_limit: 1.57

Gelenkige Körper (URDF/MJCF)

1. Laden Sie ein Beispiel-URDF herunter (z. B. von ROS Industrial):

   wget https://raw.githubusercontent.com/ros-industrial/franka_description/master/urdf/franka_panda.urdf -O panda.urdf
   

   Copy

2. Aktualisieren Sie simple_world.yaml:

   physics:
     engine: "mujoco"  # Besser für gelenkige Körper
   agents:
     - name: "panda"
       type: "urdf"
       urdf_file: "panda.urdf"
       initial_position: [0.0, 0.0, 0.5]
   

   Copy

3. Starten Sie mit:

   python -m genesis run --config simple_world.yaml
   

   Copy

Dynamik weicher Körper (Neu in v2.4.0)

Aktivieren Sie die Physik weicher Körper in der Konfiguration:

physics:
  engine: "pybullet"
  soft_body:
    enabled: True
    stiffness: 0.5
    damping: 0.1
agents:
  - name: "soft_robot"
    type: "mesh"
    mesh_file: "soft_robot.obj"
    material:
      type: "soft"
      friction: 0.3

3. Parallele Umgebungen für Datengenerierung

Genesis eignet sich hervorragend für hochdurchsatzfähige Simulationen zur Datenerfassung für RL. Nutzen Sie Ray für verteilte Umgebungen:

Schritt 1: Ray installieren

pip install "ray[default]"

Schritt 2: Parallele Welten konfigurieren

Erstellen Sie parallel_worlds.yaml:

num_environments: 1000  # Skalieren Sie auf 10.000+
base_config: "simple_world.yaml"  # Nutzen Sie Ihre bestehende Konfiguration
randomization:
  agent_position: True
  obstacle_count: [0, 5]  # Zufällige Hindernisse pro Umgebung

Schritt 3: Verteilte Simulation starten

python -m genesis parallel --config parallel_worlds.yaml --backend ray --num_cpus 8

Erwartete Ausgabe:

[Genesis] 1000 Umgebungen auf 8 CPUs gestartet.
[Genesis] Datenexport aktiviert: /tmp/genesis_data/

Daten für RL exportieren

Genesis speichert Daten automatisch in /tmp/genesis_data/ (konfigurierbar). Laden Sie sie in Python:

import pandas as pd
df = pd.read_csv("/tmp/genesis_data/agent_trajectories.csv")
print(df.head())

4. Importieren von URDF/MJCF-Robotern

URDF-Beispiel

1. Legen Sie Ihre .urdf-Datei in einem robots/-Verzeichnis ab.
2. Aktualisieren Sie simple_world.yaml:

   agents:
     - name: "my_robot"
       type: "urdf"
       urdf_file: "robots/my_robot.urdf"
       initial_position: [0.0, 0.0, 0.1]
       sensors:
         - type: "lidar"
           range: 5.0
           resolution: 0.1
   

   Copy

MJCF-Beispiel

1. Konvertieren Sie MJCF in URDF mit den Tools von MuJoCo.
2. Nutzen Sie dasselbe Feld urdf_file in der Konfiguration.

URDF validieren

python -m genesis validate --urdf robots/my_robot.urdf

Erwartete Ausgabe:

[Genesis] URDF erfolgreich validiert.
[Genesis] Gelenke: 6 (drehbar: 4, prismatisch: 2)

5. Sensoren und Rendering

Sensoren zu Agenten hinzufügen

Erweitern Sie simple_world.yaml:

agents:
  - name: "sensor_agent"
    type: "circle"
    sensors:
      - type: "camera"
        resolution: [64, 64]
        fov: 90
        position: [0.0, 0.0, 0.2]
      - type: "lidar"
        range: 3.0
        num_beams: 360

Sensordaten rendern

Starten Sie mit Visualisierung:

python -m genesis run --config simple_world.yaml --render_sensors True

Erwartete Ausgabe: Ein Fenster mit Echtzeit-Sensorüberlagerungen (Kamera-Bilder, LiDAR-Scans).

Renderings speichern

python -m genesis run --config simple_world.yaml --output_dir ./renders --save_frames True

Ausgabe: Bilder werden in ./renders/ als frame_001.png, frame_002.png usw. gespeichert.

6. Richtlinien im großen Stil trainieren

Integration mit Stable Baselines3

1. Installieren Sie RL-Abhängigkeiten:

   pip install stable-baselines3[extra]
   

   Copy

2. Erstellen Sie eine benutzerdefinierte Genesis-Umgebungsabstraktion (genesis_env.py):

   from genesis import GenesisEnv
   from stable_baselines3.common.env_checker import check_env
   
   class GenesisWrapper(GenesisEnv):
       def __init__(self, config_path="simple_world.yaml"):
           super().__init__(config_path)
           self.observation_space = self._get_obs_space()
           self.action_space = self._get_action_space()
   
       def _get_obs_space(self):
           # Definieren Sie basierend auf Ihren Sensoren (z. B. Kamera + LiDAR)
           return gym.spaces.Box(low=-1, high=1, shape=(64*64*3 + 360,))
   
       def _get_action_space(self):
           # Passen Sie an die Freiheitsgrade Ihres Roboters an
           return gym.spaces.Box(low=-1, high=1, shape=(6,))
   
   env = GenesisWrapper()
   check_env(env)  # Validieren Sie die Umgebung
   

   Copy

3. Trainieren Sie eine PPO-Richtlinie:

   from stable_baselines3 import PPO
   
   model = PPO("MlpPolicy", env, verbose=1)
   model.learn(total_timesteps=10000)
   model.save("ppo_genesis")
   

   Copy

Verteilte RL mit RLlib

pip install ray[rllib]

Trainieren Sie mit RLlib:

from rllib_genesis import GenesisEnv
from ray.rllib.algorithms.ppo import PPOConfig

config = PPOConfig()
config.env_config["config_path"] = "simple_world.yaml"
config.env_config["num_environments"] = 10
config.num_workers = 4

trainer = config.build()
for i in range(10):
    result = trainer.train()
    print(f"Iteration {i}, Belohnung: {result['episode_reward_mean']}")

7. Genesis im Vergleich zu Isaac Lab und MuJoCo

Wann Genesis wählen?

• Sie benötigen hochdurchsatzfähige Multi-Agenten-Simulationen (z. B. Schwarmrobotik, Verkehrsmodellierung).
• Sie arbeiten mit dynamischen, prozedural generierten Welten.
• Sie bevorzugen Python-basierte Workflows mit YAML-Konfigurationen.

Wann Isaac Lab wählen?

• Sie benötigen hochwertiges 3D-Rendering (z. B. Robotik-Perzeption).
• Ihr Team nutzt Omniverse oder NVIDIA-Hardware.

Wann MuJoCo wählen?

• Sie konzentrieren sich auf Einzelagenten-RL mit hochpräziser Physik.
• Sie benötigen minimale Einrichtung für Prototypen.

Was kommt als Nächstes?

1. Experimentieren Sie mit parallelen Welten: Testen Sie die Skalierung auf 1.000 Umgebungen und exportieren Sie Daten für RL.
2. Integrieren Sie Ihren Roboter: Ersetzen Sie simple_world.yaml durch Ihr URDF/MJCF und testen Sie die Sensordatenfusion.
3. Cloud-Deployment: Nutzen Sie die AWS/GCP-Vorlagen von Genesis, um Simulationen im großen Stil durchzuführen.

Für individuelle Lösungen für physische KI – von der Simulation bis zum Deployment – hilft der Physical AI Readiness Audit von Hyperion Consulting Teams dabei, eingebettete Systeme schneller umzusetzen.