O momento Skill da inteligência incorporada! NVIDIA abre o código da biblioteca de habilidades de robôs, Jim Fan: o paradigma mudou

6! Os robôs também podem aprender Skills.

Acabou de ser lançado pela NVIDIA um conjunto de skills que permite aos robôs crescer continuamente —

ASPIRE.

De forma simples, o ASPIRE é como um Coding Agent para robôs.

Tal como o GPT pode transformar os teus prompts e registos de trabalho em skills reutilizáveis, este sistema também vai transformar cada falha e correção do robô em experiência que pode ser reutilizada mais tarde.

A diferença é que não revê código, mas sim o processo de operação do robô.

Sempre que o robô executa uma tarefa, o ASPIRE regista todos esses processos — perceção, navegação, preensão, colisão, planeamento de movimento.

O GPT / Claude que é chamado por detrás, tal como um investigador, avalia onde ocorreu o problema na tarefa e itera o programa. Se funcionar, a experiência é transformada numa Skill.

Assim, o robô pode aprender continuamente escrevendo código, observando trajetórias de execução, corrigindo programas e acumulando skills.

E isto não é apenas transformar experiência em Skill.

Jim Fan, diretor de robótica da NVIDIA, afirma que o ASPIRE representa um novo paradigma de aprendizagem contínua.

Entre os quais:

• O treino deixa de ser gradiente descendente e passa a ser refinamento contínuo de skills (Skill Refinement);

• O modelo treinado já não corresponde apenas a um conjunto de pesos de ponto flutuante, mas a uma biblioteca de skills sensoriomotoras em constante expansão;

• O treino distribuído torna-se um grupo de Agentes que praticam diferentes skills e depois agregam a experiência numa única biblioteca de skills.

O que é treinado nem sempre são pesos

Embora já tenha sido introduzido no início, antes de explicar como inova o paradigma de treino de robôs, vamos primeiro falar um pouco do contexto.

O nome completo do ASPIRE é Agentic Skill Programming through Iterative Robot Exploration.

Permite que o robô execute tarefas com código, veja trajetórias multimodais de execução quando falha, depois corrija o programa e guarde a experiência corrigida numa biblioteca de skills que se vai tornando mais espessa.

Aqui, Skill, embora seja essencialmente um contexto alimentado ao modelo de grande escala, incorpora um padrão de reparação de código verificado (Code Repair Pattern), que ensina o robô como modificar o programa de controlo quando enfrenta determinados tipos de problemas.

Por exemplo, quando o robô se prepara para pegar num rádio, já identificou o alvo, mas não consegue aproximar-se.

O Agente consegue analisar que a razão não é uma identificação errada, mas sim que os pontos-alvo fornecidos pelo planeador (Planner) caem todos na zona de colisão do obstáculo.

Assim, o ASPIRE, com base nesta experiência, resume uma nova Skill:

Se este tipo de falha de planeamento ocorrer, tenta aproximar-se novamente do alvo a partir de diferentes ângulos — 45°, 90°, 180° — até encontrar um caminho livre de colisões.

No futuro, em situações semelhantes, independentemente do alvo ser um rádio, um micro-ondas ou outros móveis, esta experiência pode ser reutilizada diretamente, sem necessidade de recomeçar o processo de tentativa e erro.

A esta altura, podes estar curioso. O treino de robôs não deveria ser tudo sobre dados, gradiente descendente, pesos de modelo, aquisição em robô real, transferência da simulação para a realidade?

Porque é que de repente se tornou acumulação de skills?

Aqui é preciso introduzir primeiro um paradigma recente muito popular, Code as Policy.

Ao contrário dos modelos de política de ponta a ponta como o VLA, o Code as Policy não faz com que o modelo produza diretamente as ações do robô, mas sim que um grande modelo escreva um programa de controlo de robô executável.

O programa pode chamar módulos de perceção, APIs de planeamento e primitivas de controlo, como reconhecer objetos, planear caminhos, mover o braço robótico e executar a preensão.

Desta forma, o comportamento do robô já não está completamente escondido nos pesos da rede neural, mas sim em código operacional executável.

Com código, pode ser inspecionado, modificado, depurado e otimizado pelos modelos de Agente, que são agora incrivelmente poderosos.

Mas no passado, o Code as Policy tinha dois problemas.

Primeiro, quando o robô falha, o sistema geralmente sabe apenas que "a tarefa não foi concluída", mas não sabe se foi a perceção que falhou, a preensão não se manteve, o planeamento de caminho colidiu ou se a ação de recuperação foi mal executada.

Segundo, e mais crucial, não guarda memória.

Depois de concluir uma tarefa, as soluções de reparação, estratégias de recuperação e o formato do prompt descobertos durante a depuração são descartados, e da próxima vez que um problema semelhante surgir, tudo começa de novo.

É por isso que Jim Fan diz:

(Com o ASPIRE) Quando o robô completa a 100.ª tarefa, finalmente já não está tão ignorante como quando completou a 1.ª tarefa.

Em suma, todo este processo é como um engenheiro de robótica humano:

Quando um programa de robô falha, o engenheiro reproduz o processo de execução, vê os resultados da perceção, analisa a trajetória de movimento e determina se foi erro de preensão, planeamento ou se alguma ação de recuperação não foi ligada.

Depois de corrigir, o engenheiro regista a experiência. Da próxima vez que encontrar um objeto à beira da mesa, uma pega de gaveta ou navegar em espaços estreitos, não começa do zero.

O que o ASPIRE faz é delegar este mecanismo de acumulação de experiência ao agente. Não só faz o grande modelo escrever o código do robô, como também faz o grande modelo tentar repetidamente, observar repetidamente e corrigir repetidamente no ambiente de execução, até que a experiência de reparação verificada é cristalizada numa Skill.

Portanto, no ASPIRE, o treino já não é apenas gradiente descendente.

O processo de treino transforma-se em Skill Refinement; o produto do treino não são apenas os pesos do modelo, mas uma Biblioteca de Skills que o robô acumula e desenvolve continuamente.

Pipeline de três fases

No artigo, esta ideia é implementada como um pipeline de três fases.

Primeiro, o robot execution engine, ou seja, o motor de execução do robô.

Quando um programa de robô tradicional falha, o sistema pode apenas indicar que a tarefa não foi concluída.

O ASPIRE decompõe a falha: cada perceção, planeamento, preensão, chamada de controlo deixa entradas, saídas, evidências visuais e registos de erro.

Tal como um engenheiro humano que, ao depurar um robô, reproduz vídeos, vê trajetórias e verifica se foi erro de perceção ou de preensão, o ASPIRE entrega esta ação ao agente de codificação.

De seguida, a skill library. Depois de o agente corrigir o programa, a experiência não é descartada, mas sim transformada em conhecimento reutilizável.

No site da skill library é possível ver itens bastante específicos, como como escrever prompts de texto para SAM3, como aproximar objetos à beira da mesa de vários ângulos, como filtrar falsas deteções de puxadores de gavetas, que primitiva de movimento usar para empurrar objetos numa superfície plana.

Estes não são como os pesos tradicionais do modelo; são mais como notas de erros de um programador de robôs.

Por fim, a evolutionary search.

Um agente não se limita a tentar uma única via de reparação; o sistema gera múltiplos programas de controlo candidatos, fá-los correr no ambiente de execução e, com base nos programas sobreviventes e nas trajetórias de falha, continua a iterar.

Em engenharia de software, os agentes de codificação já estão habituados a escrever código, correr testes, ver traces e corrigir bugs. O que o ASPIRE faz é trazer este ciclo para o mundo físico.

Validação experimental

Para validar este método, o artigo testou em três benchmarks clássicos de robótica, incluindo LIBERO-Pro, Robosuite e BEHAVIOR-1K, que cobrem operações de generalização, operações intensivas em contacto e tarefas domésticas de longa duração.

Os resultados foram, de modo geral, significativamente melhores do que os métodos anteriores de Code as Policy.

Por exemplo, na tarefa de transferência bimanual de objetos (Bimanual Handover) no Robosuite, o ASPIRE aumentou a taxa de sucesso de 20% para 92%.

Quanto à capacidade de generalização.

O estudo primeiro acumulou Skill Library no LIBERO-90 e depois transferiu diretamente para a tarefa longa LIBERO-Pro Long, sem treino adicional para a nova tarefa e sem atualizar a skill library.

Os resultados mostram que, à medida que a skill library se torna mais rica, a taxa de sucesso do robô em novas tarefas aumenta, de quase zero até atingir 31%. Por outras palavras, quanto mais espessa a Skill Library, menos o robô parece um novato.

Apresentação dos autores

No final do blog técnico, a NVIDIA também divulgou a lista completa de autores.

Continuam as caras conhecidas da equipa GEAR: Jim Fan, Zhu Yuke, Guanzhi Wang, Shi Guanya, entre outros.

Os três primeiros autores contribuíram igualmente.

Entre eles, Runyu Lu é atualmente estudante de doutoramento na Universidade de Michigan, no segundo ano, e está a estagiar na GEAR; Yuubo Wu é da Universidade de Illinois em Urbana-Champaign (UIUC), e Ethan Kou é da Universidade da Califórnia, Berkeley, ainda estudante de licenciatura.

Vale a pena mencionar que, apenas ontem, a NVIDIA anunciou também a expansão do recrutamento da sua equipa de robótica na China, abrindo várias vagas em Pequim, Xangai e Shenzhen, abrangendo áreas como inteligência incorporada, simulação, implantação de robôs e arquitetura de soluções.

Este artigo é originário do Quantum Bit.

Aviso de risco e termos de isenção de responsabilidade

        O mercado tem riscos, o investimento requer cautela. Este artigo não constitui aconselhamento de investimento pessoal e também não considera os objetivos de investimento específicos, situação financeira ou necessidades de utilizadores individuais. Os utilizadores devem considerar se as opiniões, pontos de vista ou conclusões contidos neste artigo são adequados às suas circunstâncias específicas. Investir com base nisto é por sua conta e risco.