Saltar al contenido principal

Motor de Física Génesis: Guía paso a paso para configurar Génesis

Aprende a configurar y ejecutar el motor de física Genesis en Google Colab, a superar los problemas de instalación y a empezar con las simulaciones de física.
Actualizado 23 ene 2025  · 12 min de lectura

El año pasado se lanzó Génesis, una nueva y emocionante herramienta para crear simulaciones físicas realistas, mundos interactivos en 4D y mucho más. Estaba deseando probarlo, pero conseguir que funcionara no fue fácil. Debo admitir que me enfrenté a muchos retos durante la instalación. 

En este tutorial, compartiré brevemente los problemas con los que me encontré, y mostraré cómo conseguí finalmente que funcionara utilizando Google Colab y un par de trucos.

Si sólo quieres una visión general de Génesis, consulta mi artículo anterior, Motor de Física de Génesis: Guía con ejemplos.

Mi experiencia inicial de configuración con Génesis

Cuando empecé a trabajar con Génesis, seguí los pasos de instalación de la documentación. Enseguida me encontré con problemas de dependencias. Génesis requiere una versión específica de un módulo llamado Taichi (1.7.x), pero mi macOS no lo soportaba. Como referencia, mi Mac tiene 8 años....

Después de investigar un poco, me di cuenta de que otros usuarios tenían los mismos problemas, incluso con ordenadores mejores. Tras horas de esfuerzo, y descubrir que Génesis sólo funciona con determinadas versiones de Python, finalmente lo instalé.

Pero surgieron nuevos problemas. No renderizaba nada, y tuve varios problemas con OpenGL. Incluso cuando intenté ejecutar los archivos de ejemplo de su GitHub, me encontré con más errores y conflictos.

Entonces, cuando creía que lo había solucionado, empecé a recibir errores como "uniforme no encontrado", lo que significaba que faltaban algunos ajustes de renderizado.

A lo largo de este proceso, investigué en Internet para ver si alguien más se había encontrado con los mismos problemas. Resultó que no era el único: mucha gente se enfrentaba a las mismas dificultades, y muchos parecían incapaces de encontrar una solución para que sus guiones funcionaran.

Cómo hice funcionar Génesis: Google Colab al rescate

Tras la frustración inicial, decidí probar Google Colab con una cuenta Pro, y resultó ser exactamente lo que necesitaba. Utilizando los recursos de la GPU de Colab, pude:

  • Instala todas las dependencias necesarias sin ningún problema.
  • Utiliza el backend de la GPU para conseguir un gran rendimiento y un renderizado realista.
  • Por último, ejecuta ejemplos básicos y explora el potencial de Génesis.

Seleccioné la NVIDIA A100-SXM4-40GB, que demostró ser lo suficientemente potente como para manejar las simulaciones de Génesis con eficacia. 

Una vez configurado mi entorno Google Colab e instalado Génesis, intenté ejecutar el ejemplo más sencillo de la documentación:

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

Este ejemplo debería inicializar Génesis con el backend de la CPU y mostrar una escena básica. Sin embargo, inmediatamente me encontré con el siguiente error:

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

El mensaje de error indica que Génesis está intentando crear una ventana gráfica para representar la escena, pero Google Colab no admite la visualización en tiempo real. Colab se ejecuta en un entorno remoto sin acceso a una pantalla local, por lo que el parámetro show_viewer=True en la inicialización de gs.Scene() no funciona.

Como sugería el mensaje de error, he modificado el código para desactivar el visor:

scene = gs.Scene(show_viewer=False)

Esto permitió que el script se ejecutara sin bloquearse. Sin embargo, este enfoque significaba que no había forma de visualizar los resultados directamente.

Después de buscar en Internet, descubrí que otras personas se habían enfrentado al mismo problema. Muchas soluciones propuestas implicaban configurar entornos OpenGL remotos o utilizar Xvfb para crear una pantalla virtual. Por desgracia, no he conseguido que estos métodos funcionen de forma fiable en Colab, probablemente debido a conflictos de dependencias y limitaciones del entorno.

Llegados a este punto, ¡necesitaba una solución más práctica!

Como la renderización en tiempo real no era una opción en Colab, decidí guardar la salida renderizada fotograma a fotograma como imágenes. Con estas ideas, pude generar una secuencia de imágenes que más tarde podrían combinarse en una animación.

Ejecución y resultados

En esta sección, voy a guiarte a través de la implementación del código y los resultados que obtuve.

Configurar el entorno de la GPU

En primer lugar, instalé Génesis:

pip install genesis-world

A continuación, inicialicé Génesis con el backend CUDA para la aceleración por GPU.

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

Este es el resultado que obtuve:

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

Crear y construir la escena

Crea un directorio para guardar los resultados

Lo primero que necesitaba era una carpeta donde Génesis pudiera guardar las imágenes que renderizaba. 

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

La función os.makedirs() crea una carpeta llamada simulation_frames en la ruta especificada, y el argumento exist_ok=True garantiza que si la carpeta ya existe, no se producirá ningún error.

De esta forma, tenía un lugar dedicado para guardar todos los fotogramas y salidas de mi simulación.

Inicializar la escena

A continuación, necesitaba crear una escena en la que pudiera añadir objetos e interactuar con ellos.

scene = gs.Scene(show_viewer=False)

gs.Scene() inicializa un nuevo espacio de simulación, y show_viewer=False desactiva la visualización en tiempo real. Llegados a este punto, tenía una escena vacía lista para empezar a construir sobre ella.

Añade un plano y una caja

Con la escena lista, empecé a añadir objetos. Primero añadí un plano, que actúa como suelo.

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

El plano sirve de base plana para la simulación. Por defecto, es infinita y está plana a lo largo del eje x-y.

A continuación, añadí una caja a la escena:

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

Puse la caja en (0, 0, 0), justo en el centro de la escena, y la redimensioné para que tuviera 0.5 unidades de ancho, alto y profundidad, haciéndola más pequeña que la predeterminada.

Tenía un montaje sencillo: un avión como suelo y una caja apoyada sobre él.

Añade una cámara

Para captar lo que ocurría en la escena, añadí una cámara.

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

Ajusté la resolución de la imagen a 320x240 píxeles, una opción práctica para las pruebas, y coloqué la cámara en (3.5, 2.0, 2.5), lo que le daba una visión clara de la escena desde un poco por encima y por los lados. Para asegurarme de que la caja permanecía enfocada, apunté la cámara a (0, 0, 0,5), justo por encima del centro de la caja. Con un campo de visión (FOV) de 30 grados, la cámara captó una perspectiva estrecha y enfocada de la escena. 

Construye la escena

El siguiente paso fue construir la escena para prepararla para la simulación y el renderizado.

scene.build()

Este paso es crucial porque Génesis utiliza la compilación justo a tiempo (JIT) para optimizar la simulación. Cuando construí la escena, Génesis:

  • Memoria asignada a los objetos de la escena.
  • Preparó núcleos de GPU para renderizado y cálculos de física.
  • Configura todas las estructuras de datos necesarias para que la simulación se desarrolle sin problemas.

Ahora todo estaba listo: mi avión, mi caja y mi cámara estaban preparados, y la escena estaba construida.

Renderizar y guardar salidas

Para visualizar la simulación, he renderizado y guardado los resultados fotograma a fotograma. Cada fotograma se almacenó como una imagen en el directorio 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}")

Durante el proceso de renderizado, observé que los primeros fotogramas se renderizaban rápidamente (hasta 2.297 FPS), pero el rendimiento disminuía a medida que avanzaba la simulación. Al final, los FPS descendieron a unos 0,33 FPS en el fotograma 25. Esto podría deberse al aumento de la complejidad computacional de la simulación o quizá a limitaciones de recursos de la GPU para escenas más grandes.

Este es el resultado que obtuve:

[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

Estasson las imágenes que obtuve:

Cuadro 1

Cuadro 2

Cuadro 3

Cuadro 4

Cuadro 5

Cada imagen muestracómo se mueve la caja en relación con el plano a lo largo del tiempo, visto a través de la cámara. La simulación se ejecuta por pasos, y con cada paso, la posición de la caja cambia, haciendo que parezca que la caja se mueve.

Este ejemplo muestra cómo Génesis puede simular y mostrar interacciones físicas sencillas. Aunque esta configuración es básica, da una buena idea de cómo se comportan los objetos en la escena. ¡Pero puedes crear totalmente escenarios más complejos y realistas con Génesis! Exploraremos algunas de estas capacidades en la siguiente sección.

Explorando el Génesis: Capacidades y características

Creación de objetos y escenas

Génesis te permite crear escenas complejas añadiendo diversos objetos y morphs. Los objetos pueden ser desde simples primitivos como planos, cajas y esferas, hasta entidades más complejas como robots y terrenos.

Primitivas de forma:

  • gs.morphs.Plane
  • gs.morphs.Box
  • gs.morphs.Cylinder
  • gs.morphs.Esfera

Soporte para archivos externos:

  • MJCF: gs.morphs.MJCF para configuraciones de robots MuJoCo XML.
  • URDF: gs.morphs.URDF para archivos de Formato Unificado de Descripción de Robots.
  • Malla: gs.morphs.Mesh para activos 3D como .obj, .ply, .stl, .glb y .gltf.

Génesis utiliza un concepto unificado llamado "morph", que encapsula información de geometría y pose. Este diseño orientado a objetos permite interactuar directamente con las entidades utilizando sus métodos.

Renderizado y visualización

Uno de los puntos fuertes de Génesis es su capacidad para crear resultados visuales detallados utilizando funciones avanzadas de la cámara. Las cámaras funcionan en "modo sin cabeza", lo que significa que pueden generar imágenes sin necesidad de una pantalla de visualización. Pueden producir varios tipos de visuales, como imágenes en color normales (RGB), mapas de profundidad que muestran la distancia a la que se encuentran los objetos, máscaras de segmentación que etiquetan las distintas partes de la escena y mapas normales que representan los detalles de la superficie.

Grabación de vídeos

Puedes crear vídeos dejando que las cámaras graben automáticamente cada fotograma de la simulación. Incluso puedes mover la cámara durante la grabación para que el vídeo sea más dinámico e inmersivo.

Por ejemplo, puedes configurar una cámara para que se mueva en una trayectoria circular alrededor de la escena mientras captura fotogramas. La función cam.start_recording() inicia la grabación y, durante cada paso de la simulación, se actualiza la posición de la cámara. Una vez capturados todos los fotogramas, cam.stop_recording() guarda el vídeo como "video.mp4".

El vídeo final ofrece una visión fluida de la simulación, mostrando cómo interactúan y se mueven los objetos a lo largo del tiempo.

Generación del terreno para tareas de locomoción

También puedes crear distintos tipos de terrenos para entrenamiento de robótica e IA. Puedes utilizar sus opciones de terreno incorporadas o diseñar las tuyas propias proporcionando mapas de altura personalizados con gs.morphs.Terrain. Estos terrenos son perfectos para probar y entrenar cómo se mueven los robots, lo que convierte a Génesis en una gran herramienta para la investigación robótica.

Extensibilidad

También puedes personalizar tus simulaciones de varias formas. Puedes añadir texturas realistas a los objetos, para que parezcan más reales. También admite muchos formatos de archivo para importar modelos, y si un formato no es compatible, puedes solicitar que se añada. Además, puedes crear tus propias formas de objeto personalizadas (llamadas morfos) utilizando archivos y ajustes personalizados.

Conclusión

Este tutorial proporciona un ejemplo sencillo para ayudarte a empezar con Génesis. Cubrimos los aspectos básicos, como crear escenas, añadir objetos y renderizar salidas, para mostrar cómo funciona este potente motor de física.

Sin embargo, esto es sólo el principio de lo que Génesis puede hacer. Con el hardware adecuado, como una GPU potente y memoria suficiente, hay muchas posibilidades. Puedes utilizarlo para complejas simulaciones robóticas o para crear conjuntos de datos de alta calidad para el entrenamiento de IA. Aunque configurarlo puede ser complicado, ¡sin duda es una herramienta con un enorme potencial!


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

Ana Rojo Echeburúa es especialista en IA y datos y doctora en Matemáticas Aplicadas. Le encanta convertir los datos en información práctica y tiene una amplia experiencia dirigiendo equipos técnicos. A Ana le gusta trabajar en estrecha colaboración con los clientes para resolver sus problemas empresariales y crear soluciones innovadoras de IA. Conocida por su capacidad para resolver problemas y su claridad de comunicación, es una apasionada de la IA, especialmente de la IA generativa. Ana se dedica al aprendizaje continuo y al desarrollo ético de la IA, así como a simplificar problemas complejos y explicar la tecnología de forma accesible.

Temas

Aprende IA con estos cursos

programa

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.
Ver detallesRight Arrow
Comienza el curso
Ver másRight Arrow
Relacionado
An AI juggles tasks

blog

Cinco proyectos que puedes crear con modelos de IA generativa (con ejemplos)

Aprende a utilizar modelos de IA generativa para crear un editor de imágenes, un chatbot similar a ChatGPT con pocos recursos y una aplicación clasificadora de aprobación de préstamos y a automatizar interacciones PDF y un asistente de voz con GPT.
Abid Ali Awan's photo

Abid Ali Awan

10 min

tutorial

Ajuste fino de LLaMA 2: Guía paso a paso para personalizar el modelo de lenguaje grande

Aprende a ajustar Llama-2 en Colab utilizando nuevas técnicas para superar las limitaciones de memoria y computación y hacer más accesibles los grandes modelos lingüísticos de código abierto.
Abid Ali Awan's photo

Abid Ali Awan

12 min

tutorial

Tutorial FLAN-T5: Guía y puesta a punto

Una guía completa para afinar un modelo FLAN-T5 para una tarea de respuesta a preguntas utilizando la biblioteca de transformadores, y ejecutando la inferencia optmizada en un escenario del mundo real.
Zoumana Keita 's photo

Zoumana Keita

15 min

tutorial

Visión GPT-4: Guía completa para principiantes

Este tutorial le presentará todo lo que necesita saber sobre GPT-4 Vision, desde cómo acceder a él hasta ejemplos prácticos del mundo real y sus limitaciones.
Arunn Thevapalan's photo

Arunn Thevapalan

12 min

tutorial

Cómo ajustar GPT 3.5: Liberar todo el potencial de la IA

Explore GPT-3.5 Turbo y descubra el potencial transformador del ajuste fino. Aprenda a personalizar este modelo de lenguaje avanzado para aplicaciones especializadas, mejore su rendimiento y comprenda los costes asociados, la seguridad y las consideraciones de privacidad.
Moez Ali's photo

Moez Ali

11 min

tutorial

Tutorial de GitHub y Git para principiantes

Un tutorial para principiantes que muestra cómo funciona el control de versiones Git y por qué es crucial para los proyectos de ciencia de datos.
Abid Ali Awan's photo

Abid Ali Awan

17 min

Ver másVer más