Comment configurer Genesis : Un guide pratique pour l’IA physique

En bref (TL;DR)

• Installez Genesis en 5 minutes avec pip install genesis-world ou via Docker pour une accélération GPU.
• Simulez des corps rigides, articulés et souples avec des configurations YAML/JSON — aucun codage requis pour les configurations de base.
• Générez plus de 10 000 environnements parallèles pour l’entraînement en apprentissage par renforcement (RL) avec Ray ou MPI.
• Importez des robots URDF/MJCF en une seule commande et ajoutez des capteurs (LiDAR, caméras) via l’API Python.
• Entraînez des politiques à grande échelle avec Stable Baselines3 ou RLlib — exportez les données en CSV/JSON pour analyse.

1. Installation et première scène

Installer Genesis

Choisissez votre méthode en fonction de votre matériel et de votre flux de travail :

Option 1 : Installation via Pip (Recommandé pour la plupart des utilisateurs)

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

Vérifiez l’installation :

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

Sortie attendue :

2.4.0

Option 2 : Docker (Accélération GPU)

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

Sortie attendue :

GPU détecté : True

Option 3 : Installation à partir des sources (Pour le développement)

git clone https://github.com/genesis-sim/genesis.git
cd genesis
pip install -e ".[dev]"  # Installe les dépendances de développement (tests, linting)

Créer votre première scène

Genesis utilise des configurations YAML/JSON pour les environnements. Commencez par un monde 2D simple :

1. Créez simple_world.yaml :

   name: "Monde 2D Simple"
   description: "Un environnement de base avec 1 agent et des obstacles statiques."
   physics:
     engine: "pybullet"  # Prend en charge "pybullet", "mujoco" ou "custom"
     gravity: [0.0, 0.0, -9.81]
   agents:
     - name: "agent_0"
       type: "circle"
       radius: 0.5
       color: [0.0, 0.5, 1.0]  # RVB
       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. Lancez la simulation :

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

   Copy

   Sortie attendue : Une fenêtre s’ouvre avec un rendu 2D affichant votre agent et l’obstacle.

Points critiques à connaître

• Erreur : ModuleNotFoundError: No module named 'pybullet' → Installez PyBullet :

  pip install pybullet
  

  Copy
• Erreur : CUDA non disponible → Assurez-vous d’utiliser la commande Docker avec GPU ou d’avoir les pilotes CUDA installés Documentation Genesis.

2. Simulation de corps rigides, articulés et souples

Physique des corps rigides

Modifiez simple_world.yaml pour ajouter un robot à corps rigide :

agents:
  - name: "bras_robot"
    type: "urdf"
    urdf_file: "chemin/vers/robot.urdf"
    initial_position: [1.0, 0.0]
    joints:
      - name: "joint_1"
        type: "revolute"
        lower_limit: -1.57
        upper_limit: 1.57

Corps articulés (URDF/MJCF)

1. Téléchargez un exemple URDF (par exemple, depuis ROS Industrial) :

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

   Copy

2. Mettez à jour simple_world.yaml :

   physics:
     engine: "mujoco"  # Plus adapté pour les corps articulés
   agents:
     - name: "panda"
       type: "urdf"
       urdf_file: "panda.urdf"
       initial_position: [0.0, 0.0, 0.5]
   

   Copy

3. Lancez avec :

   python -m genesis run --config simple_world.yaml
   

   Copy

Dynamique des corps souples (Nouveau en v2.4.0)

Activez la physique des corps souples dans la configuration :

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

3. Environnements parallèles pour la génération de données

Genesis excelle dans la simulation haute performance pour la collecte de données en apprentissage par renforcement. Utilisez Ray pour les environnements distribués :

Étape 1 : Installer Ray

pip install "ray[default]"

Étape 2 : Configurer les mondes parallèles

Créez parallel_worlds.yaml :

num_environments: 1000  # Passez à 10 000+
base_config: "simple_world.yaml"  # Réutilisez votre configuration existante
randomization:
  agent_position: True
  obstacle_count: [0, 5]  # Nombre aléatoire d’obstacles par environnement

Étape 3 : Lancer la simulation distribuée

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

Sortie attendue :

[Genesis] 1000 environnements lancés sur 8 CPU.
[Genesis] Exportation des données activée : /tmp/genesis_data/

Exporter les données pour le RL

Genesis sauvegarde automatiquement les données dans /tmp/genesis_data/ (configurable). Chargez-les en Python :

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

4. Importation de robots URDF/MJCF

Exemple URDF

1. Placez votre fichier .urdf dans un dossier robots/.
2. Mettez à jour simple_world.yaml :

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

   Copy

Exemple MJCF

1. Convertissez MJCF en URDF en utilisant les outils de MuJoCo.
2. Utilisez le même champ urdf_file dans la configuration.

Valider l’URDF

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

Sortie attendue :

[Genesis] URDF validé avec succès.
[Genesis] Articulations : 6 (révolute : 4, prismatique : 2)

5. Capteurs et rendu

Ajouter des capteurs aux agents

Étendez simple_world.yaml :

agents:
  - name: "agent_capteurs"
    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

Visualiser les données des capteurs

Lancez avec visualisation :

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

Sortie attendue : Une fenêtre avec des superpositions de capteurs en temps réel (images de caméra, balayages LiDAR).

Enregistrer les rendus

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

Sortie : Les images sont sauvegardées dans ./renders/ sous forme de frame_001.png, frame_002.png, etc.

6. Entraînement de politiques à grande échelle

Intégration avec Stable Baselines3

1. Installez les dépendances RL :

   pip install stable-baselines3[extra]
   

   Copy

2. Créez un wrapper d’environnement Genesis personnalisé (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):
           # Définissez en fonction de vos capteurs (ex. caméra + LiDAR)
           return gym.spaces.Box(low=-1, high=1, shape=(64*64*3 + 360,))
   
       def _get_action_space(self):
           # Adaptez aux degrés de liberté de votre robot
           return gym.spaces.Box(low=-1, high=1, shape=(6,))
   
   env = GenesisWrapper()
   check_env(env)  # Validez l’environnement
   

   Copy

3. Entraînez une politique PPO :

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

   Copy

Apprentissage par renforcement distribué avec RLlib

pip install ray[rllib]

Entraînez avec 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"Itération {i}, Récompense moyenne : {result['episode_reward_mean']}")

7. Comparaison entre Genesis, Isaac Lab et MuJoCo

Quand choisir Genesis :

• Vous avez besoin de simulations multi-agents haute performance (ex. : essaims de robotique, modélisation du trafic).
• Vous travaillez avec des mondes dynamiques et générés procéduralement.
• Vous préférez des workflows Python-first avec des configurations YAML.

Quand choisir Isaac Lab :

• Vous avez besoin d’un rendu 3D haute fidélité (ex. : piles de perception robotique).
• Votre équipe utilise Omniverse ou du matériel NVIDIA.

Quand choisir MuJoCo :

• Vous vous concentrez sur le RL single-agent avec une physique haute précision.
• Vous avez besoin d’une configuration minimale pour le prototypage.

Que faire ensuite ?

1. Expérimentez avec les mondes parallèles : Testez une échelle de 1 000 environnements et exportez les données pour le RL.
2. Intégrez avec votre robot : Remplacez simple_world.yaml par votre fichier URDF/MJCF et testez la fusion de capteurs.
3. Déployez sur le cloud : Utilisez les modèles AWS/GCP de Genesis pour exécuter des simulations à grande échelle.

Pour des solutions Physical AI sur mesure — de la simulation au déploiement — l’Audit de Prêt pour l’IA Physique de Hyperion Consulting aide les équipes à livrer des systèmes incarnés plus rapidement.