🌉 Sim-to-Real: From Virtual to Physical

O reality gap is the difference between a robot’s behavior in the simulator and in the real world. A policy that’s perfect in sim can fail 100% of the time in reality—and understanding why is the starting point for any solid sim-to-real approach.

Domain randomization systematically varies the simulator parameters in each episode. The policy is forced to generalize because it never sees the same scenario twice — reality becomes just another "domain" the model has learned to handle.

# Visual DR — randomiza aparência
visual_dr:
  texture_randomization: true       # texturas aleatórias em cada objeto
  background_color: [0.1, 0.9]      # range de luminosidade do fundo
  light_intensity: [0.5, 1.5]       # posição e intensidade das luzes
  camera_position_noise: 0.02       # ruído na posição da câmera (m)

# Physics DR — randomiza dinâmica
physics_dr:
  object_mass: [0.7, 1.3]           # ±30% na massa dos objetos
  friction_coefficient: [0.5, 1.5]  # ±50% no coeficiente de atrito
  joint_damping: [0.8, 1.2]         # amortecimento das juntas
  action_delay_steps: [1, 3]        # delay de 1 a 3 steps nos comandos

# ADR — Automatic Domain Randomization
adr:
  enabled: true
  performance_threshold: 0.85       # aumenta ranges quando perf > 85%
  range_increment: 0.05             # incremento gradual dos ranges

System identification (sysid) is the process of measuring the robot’s actual physical parameters—masses, inertias, friction, stiffness—and configuring the simulator to match them. Instead of randomizing everything, you calibrate the sim to be as close as possible to reality.

O complete sim-to-real transfer pipeline involves training with DR/sysid, sim-to-sim validation, progressive deployment with safety constraints, and iteration with real-world data. It's the bottleneck for all learning-based robotics.

class ActionSmoother:
    """Filtro EMA para suavizar comandos e evitar movimentos bruscos."""
    def __init__(self, alpha: float = 0.7):
        self.alpha = alpha          # 0.7 = suave; 1.0 = sem filtro
        self.prev_action = None

    def __call__(self, raw_action):
        if self.prev_action is None:
            self.prev_action = raw_action
            return raw_action
        # Exponential Moving Average
        smoothed = self.alpha * raw_action + (1 - self.alpha) * self.prev_action
        self.prev_action = smoothed
        return smoothed

# Uso no loop de controle
smoother = ActionSmoother(alpha=0.7)
while True:
    obs = robot.get_observation()
    raw_action = policy(obs)
    safe_action = smoother(raw_action)
    robot.execute(np.clip(safe_action, -v_max, v_max))

A single sim-to-real pass is rarely enough. The real-to-sim-to-real loop is iterative: collect data on the real robot, use that data to calibrate and improve the simulator, retrain the policy in the improved sim, and deploy again. Each cycle improves both the sim and the policy.

The sim-to-real milestones prove that the approach works for tasks of extreme complexity. Lessons learned from these projects apply directly to any VLA pipeline.