💻 computer science

Embodied.cpp: A Portable Inference Runtime of Embodied AI Models on Heterogeneous Robots

Este artigo apresenta o Embodied.cpp, um tempo de execução de inferência em C++ portátil projetado para unificar a implantação fragmentada de diversos modelos de IA incorporada (tais como VLAs e WAMs) em robôs de borda heterogêneos ao fornecer uma arquitetura modular de cinco camadas que permite o controle de malha fechada de baixa latência e múltiplas taxas, enquanto melhora significativamente a eficiência de memória e as taxas de sucesso de tarefas.

Autores originais: Ling Xu, Chuyu Han, Borui Li, Hao Wu, Shiqi Jiang, Ting Cao, Chuanyou Li, Sheng Zhong, Shuai Wang

Publicado 2026-07-03

📖 5 min de leitura🧠 Leitura aprofundada

CC BY 4.0

Autores originais: Ling Xu, Chuyu Han, Borui Li, Hao Wu, Shiqi Jiang, Ting Cao, Chuanyou Li, Sheng Zhong, Shuai Wang

Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo

Imagine que você construiu um cérebro robótico brilhante e altamente inteligente. Ele consegue ver, entender linguagem e planejar como mover seus braços para pegar uma xícara. Mas, neste momento, fazer esse cérebro funcionar de fato em um robô real é como tentar encaixar um motor de Fórmula 1 em um quadro de bicicleta usando fita adesiva e um canivete suíço.

Atualmente, toda vez que um cientista constrói um novo cérebro robótico, ele tem que escrever um conjunto completamente novo de "código de cola" (o software que conecta o cérebro ao robô e aos seus sensores e motores). Esse código é frequentemente bagunçado, escrito em Python e só funciona em computadores específicos. Se você mudar o robô ou o cérebro, tem que reconstruir toda a conexão do zero.

Apresentando o "Embodied.cpp".

Pense no Embodied.cpp como um kit de adaptadores universal e de alto desempenho para cérebros robóticos. É uma peça de software escrita em C++ (uma linguagem conhecida por ser rápida e eficiente) que atua como uma ponte entre qualquer novo cérebro robótico e qualquer corpo de robô, seja um pequeno robô em um chip ou um robô de estação de trabalho gigante.

Veja como ele funciona, usando algumas analogias simples:

1. O Problema: O Adaptador "Um Tamanho Não Serve para Todos"

Imagine que você tem um sistema de casa inteligente. Algumas luzes ligam a cada segundo, o termostato verifica a temperatura a cada minuto e a câmera de segurança grava a cada hora.

O Jeito Antigo: Você constrói um temporizador, um sensor e um interruptor separados para cada dispositivo. Se você adicionar um novo dispositivo, tem que montar todo um novo circuito.
O Problema do Artigo: Os cérebros robóticos são a mesma coisa. Algumas partes (como os olhos) precisam atualizar lentamente, enquanto outras (como os controles de motor) precisam atualizar super rápido. Os softwares existentes tentam executar tudo na mesma velocidade, o que é ineficiente e causa atrasos.

2. A Solução: Um Sistema Modular de "Lego"

Os autores projetaram o Embodied.cpp como um conjunto de Lego de alta tecnologia com cinco camadas específicas:

Adaptadores de Entrada: Estes são como plugues universais. Quer o robô veja uma câmera, sinta um sensor de toque ou leia um medidor de força, esta camada traduz isso para uma linguagem que o cérebro entenda.
Construtores de Sequência: Isso organiza os dados, como um bibliotecário organizando livros antes de colocá-los na prateleira.
Execução do Backbone: Esta é a "sala de máquinas" onde o pensamento principal acontece.
Plugins de Cabeça (Head Plugins): Estas são as ferramentas especializadas. Um robô pode precisar de uma ferramenta de "preensão", outro de uma ferramenta de "caminhada". Você apenas encaixa o plugin certo sem reconstruir o motor.
Adaptadores de Implantação: Esta é a camada de saída que fala com o mundo real, enviando comandos para os motores do robô ou para o software de simulação.

3. Os Três Superpoderes

O artigo destaca três maneiras específicas pelas quais este sistema é melhor do que o que existe hoje:

Execução de Taxa Múltipla (O Maestro de uma Orquestra):
Em um robô, os "olhos" não precisam piscar tão rápido quanto os "dedos". O Embodied.cpp atua como um maestro, permitindo que os olhos corram em um ritmo lento e os dedos corram em um ritmo rápido, tudo dentro do mesmo sistema. Os softwares antigos tentam fazer todos marcharem no mesmo ritmo, o que desperdiça energia e causa atrasos.
Controle Prioritário de Latência (O Piloto de Carro de Corrida):
Na computação em nuvem (como conversar com uma IA), a velocidade é medida por quantas pessoas você pode atender de uma vez. Mas, para um robô, a velocidade é medida por o quão rápido ele reage a um único comando. Se um robô está pegando um objeto que está caindo, ele não pode esperar por um "lote" de cálculos; ele precisa de uma resposta instantânea. O Embodied.cpp foi construído para priorizar esse tempo de reação de milésimos de segundo em diferentes tipos de hardware (desde pequenos chips até grandes computadores).
Interfaces Extensíveis (O Controle Remoto Universal):
Robôs não geram apenas "palavras" ou "tokens". Eles geram coisas complexas como "mover o braço 30 graus", "prever onde a bola estará em 2 segundos" ou "apertar suavemente". O Embodied.cpp foi construído para lidar com essas saídas customizadas e estranhas sem precisar ser reescrito toda vez que um novo robô é inventado.

4. Os Resultados: Isso Funciona?

Os autores testaram este sistema com dois tipos diferentes de cérebros robóticos:

Cérebros "Visão-Linguagem" (VLA): Eles testaram dois modelos (HY-VLA e pi0.5). O sistema controlou com sucesso um robô para completar tarefas.
- Resultado: Um modelo obteve sucesso 100% das vezes, e o outro 91%. Isso provou que o software pode rodar cérebros complexos em hardware real sem travar.
Cérebros "Mundo-Ação" (WAM): Estes são modelos mais novos que tentam prever o futuro (como adivinhar para onde uma bola vai rolar). Eles testaram uma pequena parte deste cérebro.
- Resultado: Ao usar este novo software, eles reduziram a memória necessária para rodar essa parte do cérebro de 312 MiB para 88 MiB. Isso é como encolher uma mochila pesada para um pequeno estojo, tornando muito mais fácil rodar em robôs menores e mais baratos.

A Conclusão

Embodied.cpp é um motor portátil e de alta velocidade para a inteligência robótica. Ele impede que os cientistas tenham que reinventar a roda toda vez que constroem um novo robô. Em vez de escrever um código customizado e bagunçado para cada novo projeto, eles podem conectar seu novo cérebro robótico a este sistema universal, e ele simplesmente funciona — de forma rápida, eficiente e em quase qualquer hardware.

Resumo Técnico: Embodied.cpp

Declaração do Problema

A implantação prática de modelos de IA incorporada (Embodied AI) — abrangendo modelos de Visão-Linguagem-Ação (VLA) e Modelos de Mundo-Ação (WAMs) — é atualmente dificultada pela fragmentação. As soluções existentes dependem de pilhas Python específicas para cada modelo, suposições de backend e "códigos de colagem" (glue code) customizados para cada família de robôs, tornando a implantação em dispositivos de borda heterogêneos (ex: Jetson, placas baseadas em RK, caixas de borda x86) ineficiente e não portátil.

Além disso, os runtimes de inferência de propósito geral existentes (ex: llama.cpp, vLLM, ONNX Runtime) são projetados primariamente para o serviço de requisição-resposta com interfaces de tokens uniformes e otimização voltada para o throughput. Eles falham em satisfazer o "contrato de runtime" específico exigido para a implantação de IA incorporada, que demanda:

Execução de múltiplas taxas (multi-rate): Diferentes componentes (codificadores de percepção, backbones, ramos preditivos, cabeças de ação) devem operar em frequências distintas dentro de um único ciclo de controle de malha fechada.
Controle de malha fechada focado em latência: Otimização para controle de inferência de lote único (batch-1) com baixa latência e baixo jitter em hardware heterogêneo, em vez de processamento de lote de alto throughput.
Interfaces incorporadas extensíveis: Os sistemas devem suportar operadores customizados, entradas multimodais heterogêneas (imagens, propriocepção, força/tátil) e saídas diversas (pedaços de ação/action chunks, futuros preditos) além de I/O de tokens fixos.

Metodologia: Arquitetura Embodied.cpp

Os autores apresentam o Embodied.cpp, um runtime de inferência em C++ portátil projetado para unificar a execução de diversos modelos incorporados. O sistema é construído sobre uma análise arquitetural de modelos representativos de VLA e WAM, identificando um caminho de execução compartilhado onde as divergências são confinadas a um pequeno conjunto de módulos e cabeças plugáveis.

O runtime organiza este caminho compartilhado em uma arquitetura de cinco camadas:

Adaptadores de Entrada (Input Adapters): Absorvem fluxos de sensores online e amostras de datasets offline (câmeras, IMU, sinais de força/tátil) através de uma interface incorporada tipada.
Construtores de Sequência (Sequence Builders): Constroem sequências de entrada para o modelo.
Execução de Backbone (Backbone Execution): Executa a lógica central do transformer ou do backbone.
Plugins de Cabeça (Head Plugins): Lida com cabeças específicas do modelo (ex: cabeças de ação, cabeças preditivas, modelos de mundo).
Adaptadores de Implantação (Deployment Adapters): Faz a ponte entre as saídas do runtime e simuladores (ex: ManiSkill, Isaac Sim) e stacks de software de robôs do mundo real.

Princípios de Design Principais

Para abordar os desafios identificados, o Embodied.cpp adere a três princípios de design:

Execução Modular de Múltiplas Taxas: Unidades de execução explícitas e pools de estado compartilhado permitem que os componentes rodem em diferentes frequências de atualização sem forçar um caminho síncrono único.
Execução Fundida Focada em Latência: Prioriza o desempenho estável do controle via replay de grafo, reutilização de buffers, fusão de operadores e despacho específico de backend para inferência eficiente de pequenos lotes em hardware heterogêneo (CPU, GPU, NPU).
Suporte Extensível de Operadores e I/O: Fornece interfaces tipadas e cabeças plugáveis para acomodar novas famílias de modelos e operadores customizados sem reconstruir o runtime.

O sistema inclui um "Armazém de Kernels de IA Incorporada" contendo operadores reutilizáveis e kernels específicos de modelos para suportar arquiteturas em evolução.

Contribuições Principais

Análise Arquitetural: Uma taxonomia de modelos incorporados (VLA e WAM) revelando um caminho de execução compartilhado onde as diferenças estruturais são localizadas em módulos plugáveis, permitindo uma abordagem de runtime unificada.
Runtime C++ Portátil: O design e a implementação do Embodied.cpp, que mapeia o caminho de execução compartilhado na arquitetura de cinco camadas descrita acima, fornecendo abstração de backend para dispositivos de borda heterogêneos.
Avaliação Empírica: Validação quantitativa do runtime em dois modelos VLA e um benchmark preliminar de WAM, demonstrando ganhos de eficiência enquanto preserva a precisão.

Resultados Experimentais

Os autores avaliaram o Embodied.cpp em dois modelos VLA e um componente WAM:

Implantação de VLA (HY-VLA e pi0.5):
- HY-VLA: Implantado em uma tarefa RoboTwin (place_empty_cup), alcançando uma taxa de sucesso de tarefa de 100,0%. O sistema lidou com um backbone maior (Hunyuan-VL) e entradas complexas (três visões, histórico de vídeo) com uma latência de passo amortizada de 735,9 ms.
- pi0.5: Alcançou uma taxa de sucesso de tarefa de 91,0% usando um backbone PaliGemma mais leve. Demonstrou uma latência de passo amortizada menor (56,85 ms) devido a uma estratégia de pedaço de ação (action chunk) mais longa.
- Ambos os modelos rodaram com sucesso através do runtime C++, mantendo o comportamento da tarefa enquanto gerenciavam o pico de memória da GPU (6,5–6,8 GiB).
Benchmark de WAM (LingBot-VA):
- Devido a restrições de estabilidade na configuração de borda local, os autores testaram um único bloco Transformer do modelo LingBot-VA em vez de uma execução completa de WAM em malha fechada.
- Eficiência de Memória: A implementação em C++ usando quantização Q4_K reduziu a memória do bloco de 312,2 MiB (Python BF16) para 88,1 MiB.
- Precisão: O bloco C++ quantizado manteve alta fidelidade, com Erro Médio Absoluto (MAE) < $3,3 \times 10^{-2}$ e Similaridade de Cosseno > $9,997 \times 10^{-1}$ em comparação com a linha de base em Python.
- Latência: O caminho C++ alcançou latência comparável (3,171 ms vs. 3,236 ms) para a computação do bloco único.

Significância e Alegações

O artigo afirma que o Embodied.cpp aborda a lacuna crítica entre a construção de modelos e a implantação confiável no lado do robô. Ao tratar o caminho de execução comum como infraestrutura e as partes divergentes como plugins, o runtime permite:

Portabilidade: Implantação em dispositivos, robôs e simuladores heterogêneos via uma única abstração de backend.
Eficiência: Redução significativa de memória (via quantização) e execução otimizada para latência, adequada para controle de malha fechada.
Escalabilidade: Um núcleo estável e reutilizável que pode absorver novas variantes de modelos incorporados (VLA, WAM e arquiteturas futuras) sem exigir uma reconstrução completa da stack de software.

Os autores posicionam o Embodied.cpp não como um substituto para runtimes gerais de LLM, mas como uma solução especializada para o "contrato de runtime" único da IA incorporada, que prioriza o controle de estado, múltiplas taxas e baixa latência sobre o throughput.