Direkt zum Inhalt

Genesis Physics Engine: Eine Schritt-für-Schritt-Anleitung zur Einrichtung von Genesis

Erfahre, wie du die Genesis Physics Engine auf Google Colab einrichtest und ausführst, wie du die Herausforderungen bei der Installation meisterst und wie du mit Physiksimulationen beginnst.
Aktualisierte 23. Jan. 2025  · 12 Min. Lesezeit

Letztes Jahr wurde Genesis als aufregendes neues Werkzeug zur Erstellung realistischer Physiksimulationen, interaktiver 4D-Welten und mehr veröffentlicht. Ich wollte es unbedingt ausprobieren, aber es war nicht einfach, es zum Laufen zu bringen. Ich muss zugeben, dass ich bei der Einrichtung vor vielen Herausforderungen stand. 

In diesem Tutorial erzähle ich kurz von den Problemen, auf die ich gestoßen bin, und zeige, wie ich es schließlich mit Google Colab und ein paar Tricks zum Laufen gebracht habe.

Wenn du dir nur einen Überblick über Genesis verschaffen willst, schau dir meinen vorherigen Artikel an: Genesis Physics Engine: Ein Leitfaden mit Beispielen.

Meine ersten Erfahrungen mit der Einrichtung von Genesis

Als ich anfing, mit Genesis zu arbeiten, habe ich die Installationsschritte in der Dokumentation. Gleich zu Beginn stieß ich auf Probleme mit Abhängigkeiten. Genesis benötigt eine bestimmte Version eines Moduls namens Taichi (1.7.x), aber mein macOS unterstützt es nicht. Zum Vergleich: Mein Mac ist 8 Jahre alt....

Nach einigen Recherchen stellte ich fest, dass andere Nutzer dieselben Probleme hatten, sogar mit besseren Computern. Nach stundenlangem Bemühen und der Entdeckung, dass Genesis nur mit bestimmten Python-Versionen funktioniert, habe ich es schließlich installiert.

Aber es tauchten neue Probleme auf. Es ließ sich nichts rendern und ich hatte mehrere Probleme mit OpenGL. Selbst als ich versuchte, die Beispieldateien von GitHub auszuführen, stieß ich auf mehr Fehler und Konflikte.

Dann, als ich dachte, ich hätte das Problem gelöst, bekam ich Fehlermeldungen wie "Uniform nicht gefunden", was bedeutete, dass einige der Rendering-Einstellungen fehlten.

Während dieses Prozesses habe ich im Internet recherchiert, um herauszufinden, ob noch jemand auf die gleichen Probleme gestoßen ist. Es stellte sich heraus, dass ich nicht der Einzige war - viele Leute hatten die gleichen Schwierigkeiten und viele schienen keine Lösung zu finden, um ihre Skripte zum Laufen zu bringen.

Wie ich Genesis zum Laufen gebracht habe: Google Colab zur Rettung

Nach der anfänglichen Frustration entschied ich mich, Google Colab mit einem Pro-Konto auszuprobieren, und es stellte sich heraus, dass es genau das war, was ich brauchte. Mit den GPU-Ressourcen von Colab konnte ich das:

  • Installiere alle erforderlichen Abhängigkeiten ohne jegliche Probleme.
  • Nutze das GPU-Backend, um eine hohe Leistung und realistisches Rendering zu erreichen.
  • Schließlich kannst du einfache Beispiele ausführen und das Potenzial von Genesis erkunden.

Ich entschied mich für den NVIDIA A100-SXM4-40GB, der sich als leistungsstark genug erwies, um Genesis-Simulationen effizient zu bewältigen. 

Nachdem ich meine Google Colab-Umgebung eingerichtet und Genesis installiert hatte, habe ich versucht, das einfachste Beispiel aus der Dokumentation auszuführen:

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

Dieses Beispiel sollte Genesis mit dem CPU-Backend initialisieren und eine einfache Szene anzeigen. Allerdings stieß ich sofort auf den folgenden Fehler:

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

Die Fehlermeldung zeigt an, dass Genesis versucht, ein grafisches Fenster zu erstellen, um die Szene zu rendern, aber Google Colab unterstützt keine Echtzeit-Visualisierung. Colab läuft in einer entfernten Umgebung ohne Zugriff auf einen lokalen Bildschirm, daher funktioniert der Parameter show_viewer=True in der Initialisierung von gs.Scene() nicht.

Wie in der Fehlermeldung vorgeschlagen, habe ich den Code geändert, um den Viewer zu deaktivieren:

scene = gs.Scene(show_viewer=False)

Dadurch konnte das Skript ohne Absturz ausgeführt werden. Dieser Ansatz bedeutete jedoch, dass es keine Möglichkeit gab, die Ergebnisse direkt zu visualisieren.

Nachdem ich im Internet nachgeschaut hatte, entdeckte ich, dass andere das gleiche Problem hatten. Viele Lösungsvorschläge beinhalteten die Konfiguration von entfernten OpenGL-Umgebungen oder die Verwendung von Xvfb zur Erstellung einer virtuellen Anzeige. Leider konnte ich nicht erreichen, dass diese Methoden in Colab zuverlässig funktionieren, wahrscheinlich aufgrund von Abhängigkeitskonflikten und Einschränkungen in der Umgebung.

An diesem Punkt brauchte ich eine praktischere Lösung!

Da Echtzeit-Rendering in Colab keine Option war, habe ich mich entschieden, die gerenderte Ausgabe Frame für Frame als Bilder zu speichern. Mit diesen Ideen konnte ich eine Reihe von Bildern erstellen, die später zu einer Animation kombiniert werden konnten.

Umsetzung und Outputs

In diesem Abschnitt gehe ich mit dir durch die Implementierung des Codes und die Ergebnisse, die ich erhalten habe.

Einrichten der GPU-Umgebung

Als Erstes habe ich Genesis installiert:

pip install genesis-world

Dann habe ich Genesis mit dem CUDA-Backend für die GPU-Beschleunigung initialisiert.

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

Das ist die Ausgabe, die ich erhalten habe:

[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.

Erstellen und Aufbauen der Szene

Erstelle ein Verzeichnis zum Speichern der Ergebnisse

Das erste, was ich brauchte, war ein Ordner, in dem Genesis die gerenderten Bilder speichern konnte. 

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

Die Funktion os.makedirs() erstellt einen Ordner namens simulation_frames im angegebenen Pfad, und das Argument exist_ok=True sorgt dafür, dass kein Fehler ausgelöst wird, wenn der Ordner bereits existiert.

Auf diese Weise hatte ich einen speziellen Ort, um alle Bilder und Ausgaben meiner Simulation zu speichern.

Initialisiere die Szene

Als nächstes musste ich eine Szene erstellen, in der ich Objekte hinzufügen und mit ihnen interagieren konnte.

scene = gs.Scene(show_viewer=False)

gs.Scene() initialisiert einen neuen Simulationsraum und show_viewer=False deaktiviert die Echtzeit-Visualisierung. Zu diesem Zeitpunkt hatte ich eine leere Szene, auf der ich aufbauen konnte.

Füge ein Flugzeug und eine Box hinzu

Als die Szene fertig war, habe ich angefangen, Objekte hinzuzufügen. Zuerst habe ich eine Ebene hinzugefügt, die als Boden dient.

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

Die Ebene dient als flache Basis für die Simulation. Standardmäßig ist sie unendlich und liegt flach entlang der x-y-Achse.

Als Nächstes habe ich der Szene einen Kasten hinzugefügt:

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
    )
)

Ich habe die Box auf (0, 0, 0) gesetzt, genau in der Mitte der Szene, und ich habe die Größe auf 0.5 Einheiten in Breite, Höhe und Tiefe geändert, so dass sie kleiner ist als die Standardgröße.

Ich hatte einen einfachen Aufbau: ein Flugzeug als Boden und eine Kiste, die auf dem Boden lag.

Eine Kamera hinzufügen

Um das Geschehen in der Szene festzuhalten, habe ich eine Kamera hinzugefügt.

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)
)

Ich stellte die Bildauflösung auf 320x240 Pixel ein, eine praktische Wahl für den Test, und positionierte die Kamera auf (3.5, 2.0, 2.5), so dass sie einen klaren Blick auf die Szene von leicht oben und zur Seite hatte. Um sicherzustellen, dass der Kasten im Fokus bleibt, habe ich die Kamera auf (0, 0, 0,5) gerichtet, also genau über der Mitte des Kastens. Mit einem 30-Grad-Sichtfeld (FOV) hat die Kamera einen engen und fokussierten Blickwinkel auf die Szene eingefangen. 

Baue die Szene auf

Der nächste Schritt bestand darin, die Szene zu erstellen, um sie für die Simulation und das Rendering vorzubereiten.

scene.build()

Dieser Schritt ist wichtig, da Genesis die Simulation durch Just-in-Time-Kompilierung (JIT) optimiert. Als ich die Szene gebaut habe, hat Genesis:

  • Zugewiesener Speicher für die Objekte in der Szene.
  • Bereite GPU-Kernel für Rendering und Physikberechnungen vor.
  • Richte alle notwendigen Datenstrukturen ein, damit die Simulation reibungslos funktioniert.

Jetzt war alles bereit - mein Flugzeug, die Box und die Kamera waren aufgebaut, und die Szene war fertig.

Rendering und Speichern von Ausgaben

Um die Simulation zu visualisieren, habe ich die Ergebnisse Frame für Frame gerendert und gespeichert. Jedes Bild wurde als Bild im Verzeichnis simulation_frames gespeichert. 

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}")

Während des Rendering-Prozesses konnte ich beobachten, dass die ersten Bilder schnell gerendert wurden (bis zu 2.297 FPS), aber die Leistung sank, je weiter die Simulation fortschritt. Die FPS fielen schließlich auf etwa 0,33 FPS bei Frame 25. Das könnte an der zunehmenden Rechenkomplexität der Simulation liegen oder an den begrenzten GPU-Ressourcen für größere Szenen.

Das ist die Ausgabe, die ich erhalten habe:

[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

Dassind die Bilder, die ich bekommen habe:

Rahmen 1

Rahmen 2

Rahmen 3

Rahmen 4

Rahmen 5

Jedes Bild zeigt, wie sich die Kiste im Laufe der Zeit im Verhältnis zur Ebene bewegt, wie sie von der Kamera gesehen wird. Die Simulation läuft schrittweise ab und mit jedem Schritt ändert sich die Position der Box, so dass es so aussieht, als würde sich die Box bewegen.

Dieses Beispiel zeigt, wie Genesis einfache physikalische Interaktionen simulieren und darstellen kann. Dieses Setup ist zwar einfach, aber es vermittelt einen guten Eindruck davon, wie sich Objekte in der Szene verhalten. Aber du kannst mit Genesis durchaus komplexere und realistischere Szenarien erstellen! Wir werden einige dieser Möglichkeiten im nächsten Abschnitt untersuchen.

Die Genesis erforschen: Fähigkeiten und Merkmale

Objekte und Szenen erstellen

Mit Genesis kannst du komplexe Szenen erstellen, indem du verschiedene Objekte und Morphs hinzufügst. Objekte können von einfachen Primitiven wie Ebenen, Kästen und Kugeln bis hin zu komplexeren Objekten wie Robotern und Terrains reichen.

Shape Primitives:

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

Unterstützung für externe Dateien:

  • MJCF: gs.morphs.MJCF für MuJoCo XML Roboterkonfigurationen.
  • URDF: gs.morphs.URDF für Unified Robot Description Format-Dateien.
  • Mesh: gs.morphs.Mesh für 3D-Assets wie .obj, .ply, .stl, .glb, und .gltf.

Genesis verwendet ein einheitliches Konzept, das "Morph" genannt wird und Geometrie- und Poseninformationen enthält. Dieses objektorientierte Design ermöglicht die direkte Interaktion mit Entitäten über deren Methoden.

Rendering und Visualisierung

Eine der Hauptstärken von Genesis ist die Fähigkeit, mit fortschrittlichen Kamerafunktionen detaillierte visuelle Ausgaben zu erstellen. Die Kameras arbeiten im "Headless-Modus", das heißt, sie können Bilder erzeugen, ohne einen Bildschirm zu benötigen. Sie können verschiedene Arten von Bildern erzeugen, z. B. normale Farbbilder (RGB), Tiefenkarten, die zeigen, wie weit Objekte entfernt sind, Segmentierungsmasken, die verschiedene Teile der Szene kennzeichnen, und Normalkarten, die Oberflächendetails darstellen.

Videos aufnehmen

Du kannst Videos erstellen, indem du die Kameras automatisch jedes Bild der Simulation aufzeichnen lässt. Du kannst die Kamera sogar während der Aufnahme bewegen, um das Video dynamischer und immersiver zu machen.

Du kannst zum Beispiel eine Kamera so konfigurieren, dass sie sich auf einem kreisförmigen Pfad um die Szene bewegt, während sie Bilder aufnimmt. Mit der Funktion cam.start_recording() wird die Aufzeichnung gestartet und bei jedem Schritt der Simulation wird die Position der Kamera aktualisiert. Sobald alle Bilder erfasst sind, speichert cam.stop_recording() das Video als "video.mp4".

Das abschließende Video zeigt eine flüssige Darstellung der Simulation, die zeigt, wie die Objekte interagieren und sich mit der Zeit bewegen.

Terraingenerierung für Fortbewegungsaufgaben

Du kannst auch verschiedene Geländetypen für Robotik und KI-Training erstellen. Du kannst die eingebauten Geländeoptionen nutzen oder deine eigenen entwerfen, indem du eigene Höhenkarten mit gs.morphs.Terrain bereitstellst. Diese Terrains eignen sich perfekt zum Testen und Trainieren der Bewegungsabläufe von Robotern und machen Genesis zu einem großartigen Werkzeug für die Robotikforschung.

Erweiterbarkeit

Du kannst deine Simulationen auch auf verschiedene Arten anpassen. Du kannst realistische Texturen zu Objekten hinzufügen, damit sie lebensechter aussehen. Außerdem werden viele Dateiformate für den Import von Modellen unterstützt. Wenn ein Format nicht unterstützt wird, kannst du beantragen, dass es hinzugefügt wird. Außerdem kannst du deine eigenen benutzerdefinierten Objektformen (Morphs genannt) mit personalisierten Dateien und Einstellungen erstellen.

Fazit

Dieses Tutorial bietet ein einfaches Beispiel, um dir den Einstieg in Genesis zu erleichtern. Wir haben die Grundlagen behandelt, wie das Erstellen von Szenen, das Hinzufügen von Objekten und das Rendern von Ausgaben, um zu zeigen, wie diese leistungsstarke Physik-Engine funktioniert.

Das ist aber nur der Anfang dessen, was Genesis tun kann. Mit der richtigen Hardware, wie einer starken GPU und genügend Speicher, gibt es so viele Möglichkeiten. Du kannst es für komplexe Robotersimulationen oder zur Erstellung hochwertiger Datensätze für das KI-Training verwenden. Auch wenn die Einrichtung schwierig sein kann, ist es definitiv ein Werkzeug mit großem Potenzial!


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

Ana Rojo Echeburúa ist KI- und Datenspezialistin und hat einen Doktortitel in angewandter Mathematik. Sie liebt es, Daten in verwertbare Erkenntnisse umzuwandeln und hat umfangreiche Erfahrung in der Leitung technischer Teams. Ana arbeitet gerne eng mit ihren Kunden zusammen, um deren Geschäftsprobleme zu lösen und innovative KI-Lösungen zu entwickeln. Sie ist für ihre Problemlösungsfähigkeiten und ihre klare Kommunikation bekannt und hat eine Leidenschaft für KI, insbesondere für generative KI. Ana widmet sich dem kontinuierlichen Lernen und der ethischen KI-Entwicklung sowie der Vereinfachung komplexer Probleme und der Erklärung von Technologien auf verständliche Weise.

Themen

Lerne KI mit diesen Kursen!

Lernpfad

Llama Fundamentals

5 hours hr
Experiment with Llama 3 to run inference on pre-trained models, fine-tune them on custom datasets, and optimize performance.
Siehe DetailsRight Arrow
Kurs starten
Mehr anzeigenRight Arrow
Verwandt

Der Blog

Top 30 Generative KI Interview Fragen und Antworten für 2024

Dieser Blog bietet eine umfassende Sammlung von Fragen und Antworten zu generativen KI-Interviews, die von grundlegenden Konzepten bis hin zu fortgeschrittenen Themen reichen.
Hesam Sheikh Hassani's photo

Hesam Sheikh Hassani

15 Min.

Der Blog

Lehrer/innen und Schüler/innen erhalten das Premium DataCamp kostenlos für ihre gesamte akademische Laufbahn

Keine Hacks, keine Tricks. Schüler/innen und Lehrer/innen, lest weiter, um zu erfahren, wie ihr die Datenerziehung, die euch zusteht, kostenlos bekommen könnt.
Nathaniel Taylor-Leach's photo

Nathaniel Taylor-Leach

4 Min.

Der Blog

Die 32 besten AWS-Interview-Fragen und Antworten für 2024

Ein kompletter Leitfaden zur Erkundung der grundlegenden, mittleren und fortgeschrittenen AWS-Interview-Fragen, zusammen mit Fragen, die auf realen Situationen basieren. Es deckt alle Bereiche ab und sorgt so für eine abgerundete Vorbereitungsstrategie.
Zoumana Keita 's photo

Zoumana Keita

30 Min.

Der Blog

Die 20 besten Snowflake-Interview-Fragen für alle Niveaus

Bist du gerade auf der Suche nach einem Job, der Snowflake nutzt? Bereite dich mit diesen 20 besten Snowflake-Interview-Fragen vor, damit du den Job bekommst!
Nisha Arya Ahmed's photo

Nisha Arya Ahmed

20 Min.

Der Blog

2022-2023 DataCamp Classrooms Jahresbericht

Zu Beginn des neuen Schuljahres ist DataCamp Classrooms motivierter denn je, das Lernen mit Daten zu demokratisieren. In den letzten 12 Monaten sind über 7.650 neue Klassenzimmer hinzugekommen.
Nathaniel Taylor-Leach's photo

Nathaniel Taylor-Leach

8 Min.

Der Blog

Q2 2023 DataCamp Donates Digest

DataCamp Donates hat im zweiten Quartal 2023 über 20.000 Stipendien an unsere gemeinnützigen Partner vergeben. Erfahre, wie fleißige benachteiligte Lernende diese Chancen in lebensverändernde berufliche Erfolge verwandelt haben.
Nathaniel Taylor-Leach's photo

Nathaniel Taylor-Leach

Mehr anzeigenMehr anzeigen