Hoe u Genesis Installeert: Een Praktische Gids voor Fysieke AI

TL;DR

• Installeer Genesis in 5 minuten met pip install genesis-world of gebruik Docker voor GPU-beschleuniging.
• Simuleer stijve, gearticuleerde en zachte lichamen met YAML/JSON-configuraties—geen codering vereist voor basisopstellingen.
• Genereer 10.000+ parallelle omgevingen voor RL-training met Ray of MPI.
• Importeer URDF/MJCF-robots met één commando en voeg sensoren (LiDAR, camera’s) toe via de Python API.
• Train beleidsmodellen op grote schaal met Stable Baselines3 of RLlib—exporteer gegevens naar CSV/JSON voor analyse.

1. Installatie en Eerste Scene

Genesis Installeren

Kies uw installatiemethode op basis van uw hardware en workflow:

Optie 1: Pip Install (Aanbevolen voor de Meeste Gebruikers)

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

Controleer de installatie:

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

Verwachte Uitvoer:

2.4.0

Optie 2: Docker (GPU-Beschleunigd)

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

Verwachte Uitvoer:

GPU detected: True

Optie 3: Van Bron (Voor Ontwikkeling)

git clone https://github.com/genesis-sim/genesis.git
cd genesis
pip install -e ".[dev]"  # Installeert ontwikkelafhankelijkheden (testen, linting)

Maak uw Eerste Scene

Genesis gebruikt YAML/JSON-configuraties voor omgevingen. Begin met een eenvoudige 2D-wereld:

1. Maak simple_world.yaml aan:

   name: "Eenvoudige 2D Wereld"
   description: "Een basisomgeving met 1 agent en statische obstakels."
   physics:
     engine: "pybullet"  # Ondersteunt "pybullet", "mujoco" of "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. Voer de simulatie uit:

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

   Copy

   Verwachte Uitvoer: Een venster opent met een 2D-renderer die uw agent en obstakel toont.

Belangrijke Opmerkingen

• Fout: ModuleNotFoundError: No module named 'pybullet' → Installeer PyBullet:

  pip install pybullet
  

  Copy
• Fout: CUDA niet beschikbaar → Zorg ervoor dat u het Docker GPU-commando gebruikt of dat u CUDA-drivers heeft geïnstalleerd Genesis Documentatie.

2. Simulatie van Stijve, Gearticuleerde en Zachte Lichamen

Fysica van Stijve Lichamen

Pas simple_world.yaml aan om een robot met stijve lichamen toe te voegen:

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

Gearticuleerde Lichamen (URDF/MJCF)

1. Download een voorbeeld URDF (bijv. van ROS Industrial):

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

   Copy

2. Pas simple_world.yaml aan:

   physics:
     engine: "mujoco"  # Beter voor gearticuleerde lichamen
   agents:
     - name: "panda"
       type: "urdf"
       urdf_file: "panda.urdf"
       initial_position: [0.0, 0.0, 0.5]
   

   Copy

3. Voer uit met:

   python -m genesis run --config simple_world.yaml
   

   Copy

Dynamica van Zachte Lichamen (Nieuw in v2.4.0)

Schakel zachte lichaamsfysica in via de configuratie:

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. Parallelle Omgevingen voor Gegevensgeneratie

Genesis is uitstekend voor hoogscalable simulatie voor het verzamelen van RL-gegevens. Gebruik Ray voor gedistribueerde omgevingen:

Stap 1: Installeer Ray

pip install "ray[default]"

Stap 2: Configureer Parallelle Werelden

Maak parallel_worlds.yaml aan:

num_environments: 1000  # Schaal op tot 10.000+
base_config: "simple_world.yaml"  # Gebruik uw bestaande configuratie
randomization:
  agent_position: True
  obstacle_count: [0, 5]  # Willekeurige obstakels per omgeving

Stap 3: Start Gedistribueerde Simulatie

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

Verwachte Uitvoer:

[Genesis] 1000 omgevingen gelanceerd over 8 CPU's.
[Genesis] Gegevensexport ingeschakeld: /tmp/genesis_data/

Exporteer Gegevens voor RL

Genesis slaat gegevens automatisch op in /tmp/genesis_data/ (aanpasbaar). Laad deze in Python:

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

4. Importeren van URDF/MJCF Robots

URDF Voorbeeld

1. Plaats uw .urdf-bestand in een robots/-map.
2. Pas simple_world.yaml aan:

   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 Voorbeeld

1. Converteer MJCF naar URDF met behulp van MuJoCo-tools.
2. Gebruik hetzelfde urdf_file-veld in de configuratie.

Valideer URDF

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

Verwachte Uitvoer:

[Genesis] URDF succesvol gevalideerd.
[Genesis] Gewrichten: 6 (revolut: 4, prismatisch: 2)

5. Sensoren en Rendering

Voeg Sensoren Toe aan Agents

Breid simple_world.yaml uit:

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

Render Sensorgegevens

Voer uit met visualisatie:

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

Verwachte Uitvoer: Een venster met real-time sensor overlays (camera-afbeeldingen, LiDAR-scans).

Bewaar Renderingen

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

Uitvoer: Frames worden opgeslagen in ./renders/ als frame_001.png, frame_002.png, etc.

6. Beleidstraining op Grote Schaal

Integratie met Stable Baselines3

1. Installeer RL-afhankelijkheden:

   pip install stable-baselines3[extra]
   

   Copy

2. Maak een aangepaste Genesis-omgevingswrapper (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):
           # Definieer op basis van uw sensoren (bijv. camera + LiDAR)
           return gym.spaces.Box(low=-1, high=1, shape=(64*64*3 + 360,))
   
       def _get_action_space(self):
           # Pas aan op basis van uw robot's vrijheidsgraden
           return gym.spaces.Box(low=-1, high=1, shape=(6,))
   
   env = GenesisWrapper()
   check_env(env)  # Valideer de omgeving
   

   Copy

3. Train een PPO-beleid:

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

   Copy

Gedistribueerde RL met RLlib

pip install ray[rllib]

Train met 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"Iteratie {i}, Beloning: {result['episode_reward_mean']}")

7. Genesis Vergelijken met Isaac Lab en MuJoCo

Wanneer Genesis Kiezen:

• U heeft hoogscalable multi-agent simulatie nodig (bijv., robotics zwermen, verkeersmodellering).
• U werkt met dynamische, proceduraal gegenereerde werelden.
• U prefereert Python-gebaseerde workflows met YAML-configuraties.

Wanneer Isaac Lab Kiezen:

• U heeft hoogwaardige 3D-rendering nodig (bijv., robotperceptie-stapels).
• Uw team gebruikt Omniverse of NVIDIA-hardware.

Wanneer MuJoCo Kiezen:

• U richt u op enkelvoudige RL-agenten met hoogprecise fysica.
• U heeft minimale instellingen nodig voor prototyping.

Wat Komt Er Nog?

1. Experimenteren met Parallelle Werelden: Probeer schalen naar 1.000 omgevingen en exporteer gegevens voor RL.
2. Integreer met uw Robot: Vervang simple_world.yaml met uw URDF/MJCF en test sensorfusie.
3. Implementeer in de Cloud: Gebruik de AWS/GCP-sjablonen van Genesis om simulaties op grote schaal uit te voeren.

Voor maatwerkoplossingen voor Fysieke AI—van simulatie tot implementatie—helpt de Fysieke AI Klaarheidsaudit van Hyperion Consulting teams om inbedde systemen sneller te implementeren.