Os modelos fundacionais para robôs não param de crescer, o que significa inferência mais lenta. As implantações reais escondem essa latência com inferência assíncrona: o robô continua executando o trecho de ação atual enquanto o modelo calcula o próximo. É suave, é necessário — e quebra silenciosamente o aprendizado por reforço online.
Aqui está o problema. Com execução assíncrona, as ações que o modelo planejou e as que o robô realmente executou deixam de ser a mesma coisa. Quando um novo trecho chega, o robô já percorreu parte do antigo; antes que o novo trecho termine, o resultado da próxima inferência sobrescreve sua cauda. Se você roda RL baseado em gradiente sobre o trecho inteiro de forma uniforme, você credita ações que o robô não podia mudar — e culpa outras que ele nunca executou.
É exatamente isso que o SmoothRL (arXiv:2608.29768, da equipe de modelos fundacionais da Astribot) resolve. É um framework de RL online que faz fine-tuning de uma política pré-treinada dentro do loop de inferência assíncrona, e seu truque central é brutalmente simples: reforçar apenas as ações que o robô realmente executou.
Três regiões, um caminho de gradiente
O SmoothRL divide cada trecho de ações por índice de frame em três zonas, com base no status real de execução:
- Região comprometida (Committed) — travada pela rodada de inferência anterior; inalterável e garantida de ser executada.
- Região de execução (Execution) — as ações recém-geradas que o robô realmente vai executar nesta rodada.
- Região descartada (Discarded) — gerada mas nunca executada; a próxima rodada de inferência a sobrescreve.
Tratar essas três igualmente durante o treinamento está errado. A percepção do SmoothRL: deixar os gradientes de valor passar apenas pela região de Execução, para que o objetivo de otimização corresponda à distribuição de trajetórias que o robô realmente experimenta.
Reforço em Deploy
O segundo princípio é sobre ritmo temporal. O SmoothRL roda inferência assíncrona diretamente durante os rollouts de treinamento — a computação do modelo e a execução do robô acontecem em paralelo, e o replay buffer registra as trajetórias sob essa relação em tempo real. Nada de “treinar num mundo síncrono limpo e mudar para assíncrono na hora do deploy”. Você encara desde o primeiro passo de gradiente a dinâmica de execução que encontrará em produção.
A configuração concreta
Para cada tarefa, a equipe faz fine-tuning do π0.5 como política base, constrói sobre o framework RLT e adiciona um actor-critic estilo TD3 leve que prediz correções residuais no espaço de ações original. Um esboço rápido do loop de treinamento:
# Pseudo-structure of SmoothRL's per-chunk update
for chunk in rollout:
committed, execution, discarded = split_chunk(chunk, execution_frames)
# residual policy corrects base policy in raw action space
residual = actor_critic.policy(base_policy(obs))
a = base_policy(obs) + residual
# value-gradient update, but ONLY through executed frames
q = critic(obs, a)
actor_loss = -q.mean() # pass gradient only over `execution`
# mask everything outside the Execution region
masked = execution_frames_mask(actor_loss)
update_actor(actor_loss * masked)
update_critic(replay_buffer.sample())No robô S1 acionado por tendões: ações a 30 Hz, requisições de inferência a 5 Hz (um novo trecho a cada 200 ms). A política base prediz trechos de 32 frames; dentro do orçamento de latência, Committed + Execution ocupam 12 frames, com 6 frames na região de Execução de fato — os 20 restantes são sobrescritos antes da execução.
Resultados em hardware real
Três tarefas reais, e os ganhos são o ponto central:
- Arremesso dinâmico: 39% → 94% — exige acúmulo contínuo de velocidade e liberação precisa; qualquer pausa dissipa a velocidade acumulada.
- Tampar caneta: 8% → 83% — alinhamento bimanual com erro de pose relativa de ~5 mm.
- Abrir pacote: 30% → 90% — inserir uma lâmina de ~1 mm em uma fenda de 2–3 mm.
E não é só a taxa de sucesso. Após o RL online, um rollout real e autônomo de arremesso mostrou queda de 52% no RMS de aceleração do end-effector direito e de 47% no jerk. O robô fica mais preciso e mais suave.
As falhas contam a história real: antes do RL, as três tarefas exibiam vieses sistemáticos fixos (velocidade de liberação errada para a distância do alvo, lâmina desviando para a esquerda, movimentos de tampar excessivamente parecidos). O RL online usou resultados reais de execução para corrigir exatamente esses desvios — um problema de deploy, não de reaprendizado do zero.
Conclusões práticas
- Inferência assíncrona e RL online só são incompatíveis se você não modelar o tempo. Mascare os gradientes para os frames realmente executados.
- Treine sob o mesmo ritmo assíncrono com que fará o deploy — os replay buffers devem carregar relações em tempo real, não idealizadas.
- Uma política residual leve (estilo TD3) sobre uma política base congelada é um meio-termo pragmático; ela não pode salvar uma política base fundamentalmente errada.
- Espere curvas não monotônicas. Exploração online real (a abertura de pacotes caiu de 30% para 20% antes de se recuperar) não melhora de forma constante.
Recursos
- Artigo: arXiv:2608.29768 — SmoothRL: Online Reinforcement Learning During Asynchronous Execution
- Página do projeto + vídeos: astribot.com/en/research/SmoothRL
