Genesis Physics Engine: Panduan Langkah demi Langkah Menyiapkan Genesis

Tahun lalu, Genesis dirilis sebagai alat baru yang menarik untuk membuat simulasi fisika yang realistis, dunia 4D interaktif, dan banyak lagi. Saya sangat ingin mencobanya, tetapi membuatnya berjalan tidaklah mudah. Saya harus mengakui bahwa saya menghadapi banyak tantangan saat proses penyiapan. 

Dalam tutorial ini, saya akan berbagi secara singkat masalah yang saya temui, dan menunjukkan bagaimana akhirnya saya berhasil menjalankannya menggunakan Google Colab dan beberapa trik.

Jika Anda hanya ingin gambaran umum tentang Genesis, lihat artikel saya sebelumnya, Genesis Physics Engine: A Guide With Examples.

Pengalaman Awal Saya Menyiapkan Genesis

Saat pertama kali mulai menggunakan Genesis, saya mengikuti langkah instalasi di dokumentasi. Langsung saja saya menemui masalah dependensi. Genesis memerlukan versi spesifik dari modul bernama Taichi (1.7.x), tetapi macOS saya tidak mendukungnya. Sebagai catatan, Mac saya berusia 8 tahun….

Setelah melakukan riset, saya sadar pengguna lain mengalami masalah yang sama, bahkan dengan komputer yang lebih baik. Setelah berjam-jam berusaha, dan mengetahui bahwa Genesis hanya berfungsi dengan versi Python tertentu, akhirnya saya berhasil memasangnya.

Namun muncul masalah baru. Tidak ada yang bisa dirender, dan saya mengalami beberapa isu dengan OpenGL. Bahkan saat mencoba menjalankan file contoh dari GitHub mereka, saya menghadapi lebih banyak error dan konflik.

Kemudian, saat saya kira semuanya sudah beres, saya mulai mendapatkan error seperti "uniform not found," yang berarti beberapa pengaturan rendering hilang.

Selama proses ini, saya menelusuri internet untuk melihat apakah orang lain mengalami hal yang sama. Ternyata saya bukan satu-satunya—banyak orang menghadapi kesulitan yang sama, dan banyak yang tampaknya tidak menemukan solusi agar skrip mereka bisa berjalan.

Bagaimana Saya Membuat Genesis Berfungsi: Google Colab Menjadi Penyelamat

Setelah frustrasi awal, saya memutuskan untuk mencoba Google Colab dengan akun Pro, dan itu ternyata tepat seperti yang saya butuhkan. Dengan memanfaatkan sumber daya GPU Colab, saya bisa:

• Memasang semua dependensi yang diperlukan tanpa kendala sama sekali.
• Menggunakan backend GPU untuk mendapatkan performa tinggi dan rendering yang realistis.
• Akhirnya, menjalankan contoh dasar dan mengeksplorasi potensi Genesis.

Saya memilih NVIDIA A100-SXM4-40GB, yang terbukti cukup bertenaga untuk menangani simulasi Genesis secara efisien. 

Setelah saya menyiapkan lingkungan Google Colab dan memasang Genesis, saya mencoba menjalankan contoh paling sederhana dari dokumentasi:

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

Contoh ini seharusnya menginisialisasi Genesis dengan backend CPU dan menampilkan sebuah scene dasar. Namun, saya langsung menemui error berikut:

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

Pesan error menunjukkan bahwa Genesis mencoba membuat jendela grafis untuk merender scene, tetapi Google Colab tidak mendukung visualisasi real-time. Colab berjalan di lingkungan jarak jauh tanpa akses ke tampilan lokal, sehingga parameter show_viewer=True pada inisialisasi gs.Scene() tidak berfungsi.

Seperti yang disarankan oleh pesan error, saya memodifikasi kode untuk menonaktifkan viewer:

scene = gs.Scene(show_viewer=False)

Ini membuat skrip dapat dieksekusi tanpa crash. Namun, pendekatan ini berarti tidak ada cara untuk memvisualisasikan hasilnya secara langsung.

Setelah mencari secara daring, saya menemukan bahwa orang lain juga mengalami masalah yang sama. Banyak solusi yang diusulkan melibatkan konfigurasi lingkungan OpenGL jarak jauh atau menggunakan Xvfb untuk membuat tampilan virtual. Sayangnya, saya tidak berhasil membuat metode ini berjalan andal di Colab, kemungkinan karena konflik dependensi dan keterbatasan lingkungan.

Pada titik ini, saya membutuhkan solusi praktis yang lebih memungkinkan!

Karena rendering real-time tidak memungkinkan di Colab, saya memutuskan untuk menyimpan output render frame demi frame sebagai gambar. Dengan ide ini, saya dapat menghasilkan serangkaian gambar yang nantinya dapat digabungkan menjadi sebuah animasi.

Implementasi dan Output

Di bagian ini, saya akan memandu Anda melalui implementasi kode dan output yang saya peroleh.

Menyiapkan lingkungan GPU

Pertama-tama, saya memasang Genesis:

pip install genesis-world

Kemudian, saya menginisialisasi Genesis dengan backend CUDA untuk akselerasi GPU.

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

Ini adalah output yang saya dapatkan:

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

Membuat dan membangun scene

Buat direktori untuk menyimpan hasil

Hal pertama yang saya perlukan adalah folder tempat Genesis dapat menyimpan gambar yang dirender. 

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

Fungsi os.makedirs() membuat folder bernama simulation_frames pada path yang ditentukan, dan argumen exist_ok=True memastikan bahwa jika folder sudah ada, tidak akan muncul error.

Dengan cara ini, saya memiliki tempat khusus untuk menyimpan semua frame dan output dari simulasi saya.

Inisialisasi scene

Selanjutnya, saya perlu membuat scene tempat saya bisa menambahkan objek dan berinteraksi dengannya.

scene = gs.Scene(show_viewer=False)

gs.Scene() menginisialisasi ruang simulasi baru, dan show_viewer=False menonaktifkan visualisasi real-time. Pada tahap ini, saya memiliki scene kosong yang siap untuk dibangun.

Tambahkan bidang datar (plane) dan kotak

Dengan scene siap, saya mulai menambahkan objek. Pertama, saya menambahkan bidang datar (plane) yang bertindak sebagai permukaan tanah.

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

Bidang ini berfungsi sebagai alas datar untuk simulasi. Secara default, bidangnya tidak terbatas dan terletak rata sepanjang sumbu x-y.

Berikutnya, saya menambahkan sebuah kotak ke dalam scene:

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

Saya menempatkan kotak pada (0, 0, 0), tepat di tengah scene, dan saya ubah ukurannya menjadi 0.5 unit lebar, tinggi, dan kedalaman, sehingga lebih kecil dari default.

Kini, saya memiliki setelan sederhana: sebuah bidang sebagai tanah dan sebuah kotak yang berada di atasnya.

Tambahkan kamera

Untuk menangkap apa yang terjadi di dalam scene, saya menambahkan sebuah kamera.

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

Saya menetapkan resolusi gambar 320x240 piksel, pilihan praktis untuk pengujian, dan memosisikan kamera di (3.5, 2.0, 2.5), yang memberikan pandangan jelas ke scene dari agak atas dan samping. Untuk memastikan kotak tetap dalam fokus, saya arahkan kamera ke (0, 0, 0.5), sedikit di atas pusat kotak. Dengan bidang pandang (FOV) 30 derajat, kamera menangkap perspektif yang sempit dan terfokus pada scene. 

Bangun scene

Langkah berikutnya adalah membangun scene untuk mempersiapkannya agar siap simulasi dan rendering.

scene.build()

Langkah ini krusial karena Genesis menggunakan kompilasi just-in-time (JIT) untuk mengoptimalkan simulasi. Saat saya membangun scene, Genesis:

• Mengalokasikan memori untuk objek-objek dalam scene.
• Menyiapkan kernel GPU untuk rendering dan perhitungan fisika.
• Membuat semua struktur data yang diperlukan agar simulasi berjalan mulus.

Sekarang semuanya siap—bidang, kotak, dan kamera sudah diatur, dan scene telah dibangun.

Merender dan menyimpan output

Untuk memvisualisasikan simulasi, saya merender dan menyimpan output frame demi frame. Setiap frame disimpan sebagai gambar di direktori 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}")

Selama proses rendering, saya mengamati bahwa beberapa frame pertama dirender dengan cepat (hingga 2.297 FPS), tetapi performa menurun seiring berjalannya simulasi. FPS akhirnya turun hingga sekitar 0,33 FPS pada frame ke-25. Ini bisa disebabkan oleh meningkatnya kompleksitas komputasi simulasi atau mungkin keterbatasan sumber daya GPU untuk scene yang lebih besar.

Ini adalah output yang saya dapatkan:

[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

Gambar-gambar yang saya dapatkan adalah sebagai berikut:

Setiap gambar menunjukkan bagaimana kotak bergerak relatif terhadap bidang seiring waktu, seperti yang terlihat melalui kamera. Simulasi berjalan per langkah, dan pada setiap langkah, posisi kotak berubah, membuatnya tampak seperti kotak sedang bergerak.

Contoh ini menyoroti bagaimana Genesis dapat mensimulasikan dan menampilkan interaksi fisik sederhana. Meskipun setelan ini dasar, ini memberikan gambaran bagus tentang bagaimana objek berperilaku di dalam scene. Namun Anda tentu bisa membuat skenario yang lebih kompleks dan realistis dengan Genesis! Kita akan mengeksplorasi beberapa kemampuannya di bagian berikutnya.

Mengeksplorasi Genesis: Kapabilitas dan Fitur

Pembuatan objek dan scene

Genesis memungkinkan Anda membuat scene yang kompleks dengan menambahkan berbagai objek dan morph. Objek dapat berupa primitif sederhana seperti plane, box, dan sphere hingga entitas yang lebih kompleks seperti robot dan permukaan medan (terrain).

Primitif Bentuk:

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

Dukungan Berkas Eksternal:

• MJCF: gs.morphs.MJCF untuk konfigurasi robot MuJoCo XML.
• URDF: gs.morphs.URDF untuk berkas Unified Robot Description Format.
• Mesh: gs.morphs.Mesh untuk aset 3D seperti .obj, .ply, .stl, .glb, dan .gltf.

Genesis menggunakan konsep terpadu bernama "morph," yang merangkum informasi geometri dan pose. Desain berorientasi objek ini memungkinkan interaksi langsung dengan entitas melalui metode-metodenya.

Rendering dan visualisasi

Salah satu kekuatan utama Genesis adalah kemampuannya menghasilkan output visual yang detail menggunakan fitur kamera tingkat lanjut. Kamera bekerja dalam "headless mode," artinya dapat menghasilkan gambar tanpa memerlukan layar tampilan. Kamera dapat menghasilkan berbagai jenis visual, termasuk gambar warna biasa (RGB), peta kedalaman yang menunjukkan jarak objek, segmentation mask yang memberi label bagian-bagian berbeda dalam scene, dan normal map yang merepresentasikan detail permukaan.

Merekam video

Anda dapat membuat video dengan membiarkan kamera merekam setiap frame simulasi secara otomatis. Anda bahkan dapat menggerakkan kamera selama perekaman untuk membuat video yang lebih dinamis dan imersif.

Sebagai contoh, Anda dapat mengonfigurasi kamera untuk bergerak dalam lintasan melingkar mengelilingi scene sambil menangkap frame. Fungsi cam.start_recording() memulai perekaman, dan pada setiap langkah simulasi, posisi kamera diperbarui. Setelah semua frame ditangkap, cam.stop_recording() menyimpan video sebagai "video.mp4".

Video akhir memberikan tampilan halus atas simulasi, menunjukkan bagaimana objek berinteraksi dan bergerak dari waktu ke waktu.

Pembuatan terrain untuk tugas lokomosi

Anda juga dapat membuat berbagai jenis terrain untuk pelatihan robotika dan AI. Anda bisa menggunakan opsi terrain bawaan atau merancang sendiri dengan menyediakan height map kustom menggunakan gs.morphs.Terrain. Terrain ini sangat cocok untuk menguji dan melatih pergerakan robot, sehingga Genesis menjadi alat yang hebat untuk riset robotika.

Ekstensibilitas

Anda juga dapat menyesuaikan simulasi Anda dengan berbagai cara. Anda bisa menambahkan tekstur realistis pada objek, membuatnya terlihat lebih nyata. Genesis juga mendukung banyak format berkas untuk mengimpor model, dan jika suatu format belum didukung, Anda dapat meminta agar ditambahkan. Selain itu, Anda dapat membuat bentuk objek kustom sendiri (disebut morph) menggunakan berkas dan pengaturan yang dipersonalisasi.

Kesimpulan

Tutorial ini memberikan contoh sederhana untuk membantu Anda memulai dengan Genesis. Kita membahas dasar-dasarnya, seperti membuat scene, menambahkan objek, dan merender output, untuk menunjukkan bagaimana mesin fisika yang kuat ini bekerja.

Namun, ini baru permulaan dari apa yang dapat dilakukan Genesis. Dengan perangkat keras yang tepat, seperti GPU yang kuat dan memori yang cukup, ada begitu banyak kemungkinan. Anda dapat menggunakannya untuk simulasi robotika yang kompleks atau untuk membuat dataset berkualitas tinggi untuk pelatihan AI. Meskipun penyiapannya bisa rumit, ini jelas alat dengan potensi besar!