🖥️ Simuladores: MuJoCo, Isaac Sim, PyBullet
Treinar robôs sem quebrar nada: simulação física de alta fidelidade para VLA. MuJoCo a 2.7M steps/s, Isaac Sim com ray-tracing a 94k FPS, e PyBullet para prototipagem rápida — cada um com seu nicho.
Conteúdo detalhado
⚡ MuJoCo: 2.7M steps/s, o padrão acadêmico
O simulador de física mais rápido para treinamento de RL e políticas VLA em CPU.
Conceito Principal
MuJoCo (Multi-Joint dynamics with Contact) é um motor de física otimizado para simulação de contato entre corpos rígidos e articulações. Adquirido pelo Google DeepMind em 2021 e liberado como open-source (Apache 2), processa 2.7 milhões de steps por segundo em CPU — tornando viável treinar políticas VLA com milhões de episódios em horas.
✓ Quando usar MuJoCo
- ✓ Reproduzir papers acadêmicos (dm_control, Gymnasium)
- ✓ Treinar RL em escala massiva em CPU
- ✓ Simular manipulação com contato suave e preciso
- ✓ Usar MJX para GPU paralela (JAX backend)
✗ Quando NÃO usar MuJoCo
- ✗ Precisar de renderização fotorrealística para sim-to-real visual
- ✗ Simular sensores LiDAR/câmera depth nativos
- ✗ Integrar diretamente com ROS2 sem bridge
- ✗ Simular fluidos ou materiais deformáveis
🎮 NVIDIA Isaac Sim: 94k FPS, ray-tracing
Simulação fotorrealística para sim-to-real de alta fidelidade — o ambiente do GR00T N1.
Número que importa: 94.000 FPS
Isaac Sim roda a 94.000 frames por segundo com ray-tracing em GPU NVIDIA A100. Isso significa que 1 hora de GPU equivale a ~26 horas de simulação em tempo real — viabilizando domain randomization com texturas fotorrealísticas em escala. O GR00T N1 da NVIDIA foi treinado inteiramente neste ambiente.
Isaac Sim é a plataforma de simulação robótica da NVIDIA construída sobre Omniverse e PhysX 5. Oferece renderização fotorrealística em tempo real e pode simular milhares de robôs em paralelo usando GPU.
Evolução da plataforma
Isaac Gym (descontinuado)
Primeiro ambiente de RL massivamente paralelo em GPU da NVIDIA. Precursor do Isaac Sim, sem renderização fotorrealística.
Isaac Sim + Omniverse
Integração com USD (Universal Scene Description) e ray-tracing RTX em tempo real. PhysX 5 com simulação de GPU acelerada.
Isaac Lab + GR00T N1
Framework unificado de RL/IL sobre Isaac Sim. Ambiente de treinamento do modelo GR00T N1 — humanóide foundation model da NVIDIA.
🐍 PyBullet: leve e open-source
Um simulador funcional em qualquer laptop — o caminho mais rápido para rodar sua primeira política.
Início rápido com PyBullet
import pybullet as p
import pybullet_data
# 1. Conectar ao simulador
p.connect(p.GUI) # ou p.DIRECT para headless
p.setAdditionalSearchPath(pybullet_data.getDataPath())
# 2. Configurar física
p.setGravity(0, 0, -9.81)
plane = p.loadURDF("plane.urdf")
# 3. Carregar robô
robot = p.loadURDF("kuka/kuka.urdf", basePosition=[0, 0, 0])
# 4. Loop de simulação
for _ in range(1000):
p.stepSimulation()
joint_state = p.getJointState(robot, 0)
p.disconnect()PyBullet é o wrapper Python do Bullet Physics Engine. Com um simples pip install pybullet, você tem simulação 3D com URDF loader, detecção de colisão e constraints — ideal para prototipar políticas antes de migrar para simuladores mais pesados.
Dica: headless para treinamento
Use p.connect(p.DIRECT) em vez de p.GUI para treinar sem display — até 10× mais rápido pois não renderiza frames. Reserve GUI para debugging visual.
🔗 Gazebo + ROS2: integração nativa
O simulador que fala ROS2 nativamente — código do sim e do robô real são quase idênticos.
Gazebo (agora "Gz") é o simulador integrado ao ecossistema ROS2. Diferente de MuJoCo (focado em RL), Gazebo simula sensores reais — câmeras depth, LiDAR, IMU — e se comunica com ROS2 via topics nativamente através do ros_gz_bridge.
✓ Vantagens do Gazebo
- ✓ Código ROS2 idêntico no sim e no robô real
- ✓ Sensores virtuais (câmera, LiDAR, IMU) embutidos
- ✓ Gazebo Fuel: repositório de modelos 3D prontos
- ✓ Integração nativa com Nav2 e MoveIt2
✗ Limitações
- ✗ Mais lento que MuJoCo para RL em escala
- ✗ Renderização não fotorrealística (vs Isaac Sim)
- ✗ Configuração mais trabalhosa (SDF + plugins)
- ✗ Gzebo clássico vs Gz (incompatibilidades)
🎲 Domain Randomization: variabilidade para transferência
A técnica que viabilizou o primeiro sim-to-real bem-sucedido em larga escala.
Conceito Central
Domain randomization varia aleatoriamente parâmetros do simulador — texturas, iluminação, massas, fricção, cores — durante o treinamento. A política aprende a ser robusta às variações em vez de memorizar o ambiente perfeito do sim. Foi a técnica que permitiu à OpenAI ensinar um robô a resolver o cubo de Rubik em 2019.
Tipos de randomização
Visual Randomization
Varia texturas de objetos, cor do fundo, posição e intensidade de luzes, tipo de câmera. A política não deve depender de cores específicas para reconhecer um objeto.
Physics Randomization
Varia massa dos objetos, coeficiente de fricção, damping das juntas, latência do atuador. Simula a imprecisão do mundo real onde parâmetros físicos nunca são exatos.
ADR — Automatic Domain Randomization
Curriculum automático: começa com variações pequenas e aumenta progressivamente conforme a política melhora. Implementado pela OpenAI para o projeto Dactyl (mão robótica).
Dica: começa simples, escala depois
Não randomize tudo de uma vez — a política pode não convergir. Comece com randomização visual mínima (cor do fundo), valide que a política ainda aprende, depois adicione física. Use ADR para automatizar esse curriculum.
🔄 Sim-to-sim: validação antes do real
Teste em 2 simuladores diferentes antes de arriscar hardware caro — uma validação barata e poderosa.
Sim-to-sim é a prática de transferir uma política treinada em um simulador (ex: MuJoCo) para outro simulador com física diferente (ex: Isaac Sim) como etapa intermediária. Se a política falha em outro sim, vai falhar no robô real — mas você descobriu isso sem quebrar nada.
Conversão de formatos de robô
# URDF → MJCF (MuJoCo)
python -m mujoco.mjcf.convert robot.urdf robot.xml
# URDF → USD (Isaac Sim / Omniverse)
from omni.isaac.urdf import _urdf
urdf_interface = _urdf.acquire_urdf_interface()
urdf_interface.parse_urdf(urdf_path, dest_path)
# Benchmark cross-simulator com SIMPLER
python eval_simpler.py \
--policy checkpoint.pt \
--env SimplerEnv-MuJoCo \
--n_eval_episodes 50
# Mesmo benchmark em Isaac Sim
python eval_simpler.py \
--policy checkpoint.pt \
--env SimplerEnv-IsaacSim \
--n_eval_episodes 50✓ Sinais de política robusta
- ✓ Success rate semelhante em MuJoCo e Isaac Sim
- ✓ Comportamento consistente com diferentes texturas
- ✓ Tolerance intervals se sobrepõem entre sims
- ✓ Falhas são distribuídas aleatoriamente, não sistemáticas
✗ Sinais de overfitting ao sim
- ✗ 90% sucesso no MuJoCo, 20% no Isaac Sim
- ✗ Política pára no mesmo frame toda vez no 2º sim
- ✗ Falhas consistentes ao mudar textura do objeto
- ✗ Comportamento diferente com mesmo URDF/MJCF
Protocolo mínimo de validação
Use sempre N ≥ 50 episódios por ambiente para calcular intervalos de confiança (95%). Com N < 20, a variância é tão alta que você pode confundir sorte com robustez. Registre vídeos de episódios falhos — eles revelam padrões que métricas não capturam.
✅ Resumo do Módulo
Próximo módulo
2.4 — ROS2: Middleware para Robótica Real