Accéder au contenu principal

Moteur physique Genesis : Un guide étape par étape pour configurer Genesis

Apprenez à configurer et à faire fonctionner le moteur physique Genesis sur Google Colab, en surmontant les difficultés d'installation et en commençant à réaliser des simulations physiques.
Actualisé 23 janv. 2025  · 12 min de lecture

L'année dernière, Genesis a été lancé comme un nouvel outil passionnant pour créer des simulations physiques réalistes, des mondes 4D interactifs, etc. J'étais impatient de l'essayer, mais il n'a pas été facile de le faire fonctionner. Je dois admettre que j'ai été confronté à de nombreux défis lors de l'installation. 

Dans ce tutoriel, je partagerai brièvement les problèmes que j'ai rencontrés, et je montrerai comment j'ai finalement réussi à le faire fonctionner en utilisant Google Colab et quelques astuces.

Si vous ne voulez qu'une vue d'ensemble de Genesis, consultez mon article précédent, Genesis Physics Engine : Un guide avec des exemples.

Ma première expérience d'installation avec Genesis

Lorsque j'ai commencé à travailler avec Genesis, j'ai suivi les étapes d'installation dans la documentation. Tout de suite, j'ai rencontré des problèmes de dépendances. Genesis nécessite une version spécifique d'un module appelé Taichi (1.7.x), mais mon macOS ne le supporte pas. À titre de référence, mon Mac a 8 ans....

Après quelques recherches, je me suis rendu compte que d'autres utilisateurs avaient les mêmes problèmes, même avec de meilleurs ordinateurs. Après des heures d'efforts, et après avoir découvert que Genesis ne fonctionne qu'avec certaines versions de Python, je l'ai finalement installé.

Mais de nouveaux problèmes sont apparus. Il ne rendait rien, et j'ai eu plusieurs problèmes avec OpenGL. Même lorsque j'ai essayé d'exécuter les fichiers d'exemple à partir de leur GitHub, j'ai été confronté à davantage d'erreurs et de conflits.

Puis, alors que je pensais avoir résolu le problème, j'ai commencé à recevoir des erreurs telles que "uniforme introuvable", ce qui signifiait que certains paramètres de rendu étaient manquants.

Tout au long de ce processus, j'ai fait des recherches en ligne pour voir si quelqu'un d'autre avait rencontré les mêmes problèmes. Il s'est avéré que je n'étais pas le seul - de nombreuses personnes ont rencontré les mêmes difficultés, et beaucoup semblaient incapables de trouver une solution pour faire fonctionner leurs scripts.

Comment j'ai fait fonctionner Genesis : Google Colab à la rescousse

Après la frustration initiale, j'ai décidé d'essayer Google Colab avec un compte Pro, et il s'est avéré être exactement ce dont j'avais besoin. En utilisant les ressources GPU de Colab, j'ai pu :

  • Installez toutes les dépendances requises sans aucun problème.
  • Utilisez le backend GPU pour obtenir d'excellentes performances et un rendu réaliste.
  • Enfin, exécutez des exemples de base et exploitez le potentiel de Genesis.

J'ai choisi la carte NVIDIA A100-SXM4-40GB, qui s'est avérée suffisamment puissante pour traiter efficacement les simulations de Genesis. 

Après avoir configuré mon environnement Google Colab et installé Genesis, j'ai essayé d'exécuter l'exemple le plus simple de la documentation :

import genesis as gs
gs.init(backend=gs.cpu)
scene = gs.Scene(show_viewer=True)

Cet exemple devrait initialiser Genesis avec le backend CPU et afficher une scène de base. Cependant, j'ai immédiatement rencontré l'erreur suivante :

GenesisException: No display detected. Use show_viewer=False for headless mode.

Le message d'erreur indique que Genesis tente de créer une fenêtre graphique pour rendre la scène, mais que Google Colab ne prend pas en charge la visualisation en temps réel. Colab fonctionne dans un environnement distant sans accès à un écran local, de sorte que le paramètre show_viewer=True dans l'initialisation de gs.Scene() ne fonctionne pas.

Comme le suggère le message d'erreur, j'ai modifié le code pour désactiver la visionneuse :

scene = gs.Scene(show_viewer=False)

Cela a permis au script de s'exécuter sans se bloquer. Cependant, cette approche ne permettait pas de visualiser directement les résultats.

Après avoir consulté Internet, j'ai découvert que d'autres personnes avaient été confrontées au même problème. De nombreuses solutions proposées impliquaient la configuration d'environnements OpenGL distants ou l'utilisation de Xvfb pour créer un affichage virtuel. Malheureusement, je n'ai pas réussi à faire fonctionner ces méthodes de manière fiable dans Colab, probablement en raison de conflits de dépendances et de limitations de l'environnement.

À ce stade, j'avais besoin d'une solution plus pratique !

Comme le rendu en temps réel n'était pas une option dans Colab, j'ai décidé d'enregistrer le rendu image par image sous forme d'images. Ces idées m'ont permis de générer une séquence d'images qui ont ensuite été combinées pour former une animation.

Mise en œuvre et résultats

Dans cette section, je vais vous expliquer la mise en œuvre du code et les résultats que j'ai obtenus.

Mise en place de l'environnement GPU

Tout d'abord, j'ai installé Genesis :

pip install genesis-world

Ensuite, j'ai initialisé Genesis avec le backend CUDA pour l'accélération GPU.

import genesis as gs
gs.init(backend=gs.cuda)

Voici le résultat que j'ai obtenu :

[Genesis] [INFO] Running on [NVIDIA A100-SXM4-40GB] with backend gs.cuda. Device memory: 39.56 GB.
[Genesis] [INFO] 🚀 Genesis initialized. Version: 0.2.1, Seed: None, Precision: 32.

Création et construction de la scène

Créez un répertoire pour enregistrer les résultats

La première chose dont j'avais besoin était un dossier dans lequel Genesis pouvait enregistrer les images qu'il rendait. 

import os
save_dir = "/content/simulation_frames"
os.makedirs(save_dir, exist_ok=True)

La fonction os.makedirs() crée un dossier appelé simulation_frames dans le chemin spécifié, et l'argument exist_ok=True garantit que si le dossier existe déjà, aucune erreur ne sera soulevée.

De cette façon, j'avais un endroit dédié pour sauvegarder toutes les images et les sorties de ma simulation.

Initialiser la scène

Ensuite, je devais créer une scène dans laquelle je pouvais ajouter des objets et interagir avec eux.

scene = gs.Scene(show_viewer=False)

gs.Scene() initialise un nouvel espace de simulation et show_viewer=False désactive la visualisation en temps réel. À ce stade, j'avais une scène vide prête à être construite.

Ajouter un plan et une boîte

La scène étant prête, j'ai commencé à ajouter des objets. J'ai d'abord ajouté un plan, qui fait office de sol.

plane = scene.add_entity(gs.morphs.Plane())

Le plan sert de base plane pour la simulation. Par défaut, il est infini et se situe à plat le long de l'axe x-y.

Ensuite, j'ai ajouté une boîte à la scène :

box = scene.add_entity(
    gs.morphs.Box(
        pos=(0, 0, 0),        # Position of the box
        size=(0.5, 0.5, 0.5)  # Size of the box
    )
)

J'ai placé la boîte à (0, 0, 0), au centre de la scène, et je l'ai redimensionnée pour qu'elle ait une largeur, une hauteur et une profondeur de 0.5, ce qui la rend plus petite que la valeur par défaut.

J'avais une configuration simple : un avion comme sol et une boîte posée dessus.

Ajouter une caméra

Pour capturer ce qui se passe dans la scène, j'ai ajouté une caméra.

cam = scene.add_camera(
    res=(320, 240),       # Resolution: 320x240 pixels
    pos=(3.5, 2.0, 2.5),  # Camera position
    lookat=(0, 0, 0.5),   # Point the camera is focused on
    fov=30                # Field of view (in degrees)
)

J'ai réglé la résolution de l'image sur 320x240 pixels, un choix pratique pour les tests, et j'ai placé l'appareil photo à l'adresse (3.5, 2.0, 2.5), ce qui lui a permis d'avoir une vue claire de la scène, légèrement au-dessus et sur le côté. Pour m'assurer que la boîte reste nette, j'ai orienté l'appareil photo vers (0, 0, 0,5), juste au-dessus du centre de la boîte. Avec un champ de vision (FOV) de 30 degrés, la caméra a capturé une perspective étroite et ciblée de la scène. 

Construire la scène

L'étape suivante a consisté à construire la scène pour la préparer à la simulation et au rendu.

scene.build()

Cette étape est cruciale car Genesis utilise la compilation juste à temps (JIT) pour optimiser la simulation. Lorsque j'ai construit la scène, Genesis :

  • Mémoire allouée aux objets de la scène.
  • Préparation des noyaux GPU pour le rendu et les calculs physiques.
  • Mettez en place toutes les structures de données nécessaires au bon déroulement de la simulation.

Tout était prêt : mon avion, ma boîte et mon appareil photo étaient prêts, et la scène était construite.

Rendu et enregistrement des résultats

Pour visualiser la simulation, j'ai rendu et enregistré les résultats image par image. Chaque image a été stockée dans le répertoire simulation_frames

from PIL import Image
import numpy as np

# Render and save images
for i in range(30):
    scene.step()  # Advance simulation
    if i % 5 == 0:  # Save every 5th frame
        print(f"Step {i}/30")
        rgb_data = cam.render(rgb=True)
        
        # Extract image data and save it
        img_array = rgb_data[0]
        img = Image.fromarray((img_array * 255).astype(np.uint8))
        img.save(f"{save_dir}/frame_{i:03d}.png")
        print(f"Frame {i} saved to {save_dir}")

Au cours du processus de rendu, j'ai observé que les premières images étaient rendues rapidement (jusqu'à 2 297 FPS), mais que les performances diminuaient au fur et à mesure que la simulation progressait. Le FPS est finalement tombé à environ 0,33 FPS à l'image 25. Cela pourrait être dû à la complexité croissante de la simulation ou à des contraintes de ressources du GPU pour les scènes plus importantes.

Voici le résultat que j'ai obtenu :

[Genesis] [22:16:38] [INFO] Running at 2297.81 FPS.
INFO:genesis:Running at ~<2297.81>~ FPS.
Step 0/30
[Genesis] [22:16:56] [INFO] Running at 1.11 FPS.
INFO:genesis:Running at ~<1.11>~ FPS.
[Genesis] [22:16:56] [INFO] Running at 1.17 FPS.
INFO:genesis:Running at ~<1.17>~ FPS.
[Genesis] [22:16:56] [INFO] Running at 1.23 FPS.
INFO:genesis:Running at ~<1.23>~ FPS.
[Genesis] [22:16:56] [INFO] Running at 1.29 FPS.
INFO:genesis:Running at ~<1.29>~ FPS.
[Genesis] [22:16:56] [INFO] Running at 1.36 FPS.
INFO:genesis:Running at ~<1.36>~ FPS.
Frame 0 saved to /content/simulation_frames
Step 5/30
[Genesis] [22:17:14] [INFO] Running at 0.63 FPS.
INFO:genesis:Running at ~<0.63>~ FPS.
[Genesis] [22:17:14] [INFO] Running at 0.67 FPS.
INFO:genesis:Running at ~<0.67>~ FPS.
[Genesis] [22:17:14] [INFO] Running at 0.70 FPS.
INFO:genesis:Running at ~<0.70>~ FPS.
[Genesis] [22:17:14] [INFO] Running at 0.74 FPS.
INFO:genesis:Running at ~<0.74>~ FPS.
[Genesis] [22:17:14] [INFO] Running at 0.78 FPS.
INFO:genesis:Running at ~<0.78>~ FPS.
Frame 5 saved to /content/simulation_frames
Step 10/30
[Genesis] [22:17:32] [INFO] Running at 0.47 FPS.
INFO:genesis:Running at ~<0.47>~ FPS.
[Genesis] [22:17:32] [INFO] Running at 0.50 FPS.
INFO:genesis:Running at ~<0.50>~ FPS.
[Genesis] [22:17:32] [INFO] Running at 0.53 FPS.
INFO:genesis:Running at ~<0.53>~ FPS.
[Genesis] [22:17:32] [INFO] Running at 0.55 FPS.
INFO:genesis:Running at ~<0.55>~ FPS.
[Genesis] [22:17:32] [INFO] Running at 0.58 FPS.
INFO:genesis:Running at ~<0.58>~ FPS.
Frame 10 saved to /content/simulation_frames
Step 15/30
[Genesis] [22:17:49] [INFO] Running at 0.40 FPS.
INFO:genesis:Running at ~<0.40>~ FPS.
[Genesis] [22:17:49] [INFO] Running at 0.42 FPS.
INFO:genesis:Running at ~<0.42>~ FPS.
[Genesis] [22:17:49] [INFO] Running at 0.44 FPS.
INFO:genesis:Running at ~<0.44>~ FPS.
[Genesis] [22:17:49] [INFO] Running at 0.46 FPS.
INFO:genesis:Running at ~<0.46>~ FPS.
[Genesis] [22:17:49] [INFO] Running at 0.49 FPS.
INFO:genesis:Running at ~<0.49>~ FPS.
Frame 15 saved to /content/simulation_frames
Step 20/30
[Genesis] [22:18:07] [INFO] Running at 0.35 FPS.
INFO:genesis:Running at ~<0.35>~ FPS.
[Genesis] [22:18:07] [INFO] Running at 0.37 FPS.
INFO:genesis:Running at ~<0.37>~ FPS.
[Genesis] [22:18:07] [INFO] Running at 0.39 FPS.
INFO:genesis:Running at ~<0.39>~ FPS.
[Genesis] [22:18:07] [INFO] Running at 0.41 FPS.
INFO:genesis:Running at ~<0.41>~ FPS.
[Genesis] [22:18:07] [INFO] Running at 0.43 FPS.
INFO:genesis:Running at ~<0.43>~ FPS.
Frame 20 saved to /content/simulation_frames
Step 25/30
[Genesis] [22:18:24] [INFO] Running at 0.33 FPS.
INFO:genesis:Running at ~<0.33>~ FPS.
[Genesis] [22:18:24] [INFO] Running at 0.35 FPS.
INFO:genesis:Running at ~<0.35>~ FPS.
[Genesis] [22:18:24] [INFO] Running at 0.36 FPS.
INFO:genesis:Running at ~<0.36>~ FPS.
[Genesis] [22:18:24] [INFO] Running at 0.38 FPS.
INFO:genesis:Running at ~<0.38>~ FPS.
Frame 25 saved to /content/simulation_frames

Voiciles images que j'ai obtenues :

Cadre 1

Cadre 2

Cadre 3

Cadre 4

Cadre 5

Chaque image montrecomment la boîte se déplace par rapport à l'avion au fil du temps, telle qu'elle est vue par l'appareil photo. La simulation se déroule par étapes et, à chaque étape, la position de la boîte change, ce qui donne l'impression que la boîte se déplace.

Cet exemple montre comment Genesis peut simuler et afficher des interactions physiques simples. Bien que cette configuration soit basique, elle donne une bonne idée du comportement des objets dans la scène. Mais vous pouvez tout à fait créer des scénarios plus complexes et plus réalistes avec Genesis ! Nous examinerons certaines de ces possibilités dans la section suivante.

Explorer la Genèse : Capacités et caractéristiques

Création d'objets et de scènes

Genesis vous permet de créer des scènes complexes en ajoutant divers objets et morphes. Les objets peuvent aller de simples primitives telles que des plans, des boîtes et des sphères à des entités plus complexes telles que des robots et des terrains.

Primitives de forme :

  • gs.morphs.Plane
  • gs.morphs.Box
  • gs.morphs.Cylinder
  • gs.morphs.Sphere

Support de fichiers externes :

  • MJCF : gs.morphs.MJCF pour les configurations de robots MuJoCo XML.
  • URDF : gs.morphs.URDF pour Unified Robot Description Format files.
  • Mesh : gs.morphs.Mesh pour les ressources 3D telles que .obj, .ply, .stl, .glb et .gltf.

Genesis utilise un concept unifié appelé "morph", qui encapsule les informations relatives à la géométrie et à la pose. Cette conception orientée objet permet une interaction directe avec les entités en utilisant leurs méthodes.

Rendu et visualisation

L'un des principaux atouts de Genesis est sa capacité à créer des sorties visuelles détaillées à l'aide de fonctions avancées de la caméra. Les caméras fonctionnent en mode "sans tête", ce qui signifie qu'elles peuvent générer des images sans avoir besoin d'un écran d'affichage. Ils peuvent produire différents types d'images, notamment des images en couleurs normales (RVB), des cartes de profondeur indiquant la distance à laquelle se trouvent les objets, des masques de segmentation étiquetant les différentes parties de la scène et des cartes de normalité représentant les détails de la surface.

Enregistrement de vidéos

Vous pouvez créer des vidéos en laissant les caméras enregistrer automatiquement chaque image de la simulation. Vous pouvez même déplacer la caméra pendant l'enregistrement pour rendre la vidéo plus dynamique et immersive.

Par exemple, vous pouvez configurer une caméra pour qu'elle se déplace sur une trajectoire circulaire autour de la scène tout en capturant des images. La fonction cam.start_recording() lance l'enregistrement et, à chaque étape de la simulation, la position de la caméra est mise à jour. Une fois toutes les images capturées, cam.stop_recording() enregistre la vidéo sous "video.mp4".

La vidéo finale donne une vue fluide de la simulation, montrant comment les objets interagissent et se déplacent au fil du temps.

Génération de terrain pour les tâches de locomotion

Vous pouvez également créer différents types de terrains pour la formation à la robotique et à l'IA. Vous pouvez utiliser les options de terrain intégrées ou concevoir les vôtres en fournissant des cartes d'altitude personnalisées à l'adresse gs.morphs.Terrain. Ces terrains sont parfaits pour tester et entraîner les mouvements des robots, ce qui fait de Genesis un outil formidable pour la recherche en robotique.

Extensibilité

Vous pouvez également personnaliser vos simulations de plusieurs façons. Vous pouvez ajouter des textures réalistes aux objets, ce qui leur donne un aspect plus vivant. Il prend également en charge de nombreux formats de fichiers pour l'importation de modèles, et si un format n'est pas pris en charge, vous pouvez demander à ce qu'il soit ajouté. En outre, vous pouvez créer vos propres formes d'objets personnalisées (appelées morphes) à l'aide de fichiers et de paramètres personnalisés.

Conclusion

Ce tutoriel fournit un exemple simple pour vous aider à démarrer avec Genesis. Nous avons couvert les bases, comme la création de scènes, l'ajout d'objets et le rendu des sorties, pour montrer comment fonctionne ce puissant moteur physique.

Cependant, ce n'est que le début de ce que Genesis peut faire. Avec le bon matériel, comme un GPU puissant et suffisamment de mémoire, les possibilités sont nombreuses. Vous pouvez l'utiliser pour des simulations robotiques complexes ou pour créer des ensembles de données de haute qualité pour l'entraînement à l'IA. Bien que sa mise en place puisse s'avérer délicate, il s'agit d'un outil au potentiel énorme !


Dr Ana Rojo-Echeburúa's photo
Author
Dr Ana Rojo-Echeburúa
LinkedIn
Twitter

Ana Rojo Echeburúa est une spécialiste de l'IA et des données, titulaire d'un doctorat en mathématiques appliquées. Elle aime transformer les données en informations exploitables et possède une grande expérience de la direction d'équipes techniques. Ana aime travailler en étroite collaboration avec ses clients pour résoudre leurs problèmes commerciaux et créer des solutions d'IA innovantes. Connue pour ses compétences en matière de résolution de problèmes et de communication claire, elle est passionnée par l'IA, en particulier l'IA générative. Ana se consacre à l'apprentissage continu et au développement éthique de l'IA, ainsi qu'à la simplification des problèmes complexes et à l'explication de la technologie de manière accessible.

Sujets

Apprenez l'IA avec ces cours !

cursus

Les fondamentaux du lama

5 heures hr
Expérimentez Llama 3 pour exécuter l'inférence sur des modèles pré-entraînés, les affiner sur des ensembles de données personnalisés et optimiser les performances.
Afficher les détailsRight Arrow
Commencer le cours
Voir plusRight Arrow