VoxPoser: Mapas de valores 3D combináveis para operações de robôs usando um modelo de linguagem grande (GPT-4) [Interpretação do artigo]

Este é um artigo recente da equipe de Li Feifei em Stanford: VoxPoser: Composable 3D Value Maps for Robotic Manipulation with Language Models
É principalmente através da combinação do grande modelo de linguagem LLM e do modelo de linguagem visual VLM para executar várias operações diárias em robôs. Primeiro, vamos dar uma olhada no efeito real: um robô de propósito geral com um grande modelo de linguagem e um modelo visual
pode executar bem as operações diárias em diferentes cenários reais e tem a vantagem de que o robô não precisa ser treinado. Para a interpretação deste artigo, tente expressá-lo de acordo com seu próprio entendimento. Espero que seja útil para todos. Claro, o nível é limitado e há erros. Bem-vindo para me corrigir e progredirmos juntos.

1. A intenção original do desenvolvimento do VoxPoser

Nas operações anteriores do robô, todos nós precisamos pré-definir a trajetória, o que torna o robô mais limitado. Mais importante, é difícil obter dados do robô em grande escala, o que limita o desenvolvimento do campo do robô. . E a excelente resposta do ChatGPT4 nos faz sentir que é possível tornar o robô um robô de uso geral. Podemos usar esse LLM para raciocinar, dar ao robô algumas etapas úteis e usar o VLM para planejar o caminho. Isso é feito teoricamente, o robô é possível interagir com o mundo real por meio da linguagem natural. Assim foi desenvolvido o VoxPoser . O objetivo deste trabalho é sintetizar as trajetórias do robô, ou seja, usar o efetuador final de 6 graus de liberdade para planejar a sequência de pontos do caminho que será introduzida a seguir, abrir o conjunto de instruções e conjunto de objetos.
Vamos primeiro olhar para um diagrama VOXPOSER :

À esquerda está uma visão geral do VoxPoser e à direita está uma demonstração de algumas operações.
Pode-se ver que extraímos o suporte e as restrições do modelo de linguagem grande (o suporte aqui é o objetivo operacional do robô e também pode ser chamado de função ou visibilidade da função abaixo, o que significa a mesma coisa, e a restrição é o operação do robô durante a operação. Coisas a evitar), também pode ser chamada de evitação, como "Abra a gaveta de cima e cuidado com o vaso!" (abra a gaveta de cima, cuidado com o vaso!), então a gaveta aqui é o suporte, o vaso é o constrangimento.
As etapas resultantes são as seguintes:
        1. Segure a alça da gaveta superior
        2. A alça precisa ser transladada para fora
        3. O robô deve ficar longe do vaso
Essas etapas são combinadas com o modelo de linguagem visual e a trajetória do vaso O robô pode ser planejado usando a interface de código fornecida pelo VOXPOSER .

2. Realização do princípio VoxPoser

Apresentamos brevemente o VOXPOSER acima e, em seguida, apresentamos o princípio do VOXPOSER em detalhes. No diagrama esquemático acima, observamos cuidadosamente o espaço onde o robô está localizado à esquerda e descobriremos que as cores de cada área são diferentes. Veja na barra de cores, a esquerda é alto custo, à direita está alta recompensa, ou seja, quanto maior o custo, a cor é vermelha, e o local com alta recompensa é azul, o que permitirá ao robô fazer o planejamento do caminho para esse.

2.1、LLM+VLM

Então, como alcançá-lo? Da mesma forma, observe um diagrama:

Os códigos de duas funções são fornecidos aqui, affordance_map() e constraint_map() , que representam respectivamente o mapeamento do alvo que precisa ser operado e do alvo que precisa ser evitado.
O modelo de linguagem grande gera código que interage com o modelo de linguagem visual para gerar uma série de mapas de função 3D e mapas de restrição (coletivamente referidos como mapas de valor) com base no espaço de observação do robô. Em seguida, os mapas de valor sintetizados são usados como planejadores de movimento para sintetizar as trajetórias de operação do robô a função objetivo de .
Do ponto de vista das duas funções, elas são semelhantes. Elas primeiro inicializam um mapa de matriz tridimensional (tensor) e, em seguida, detectam o alvo detect('handle') e detect ('vase') . A diferença é que o affordance_map precisa converter o objeto de destino A posição (top_handle.pos) é definida como 1. No constraint_map , a posição da grade (vase.occup_grid) ocupada pelo objeto detectado é definida como -1 , e os dois últimos retornam seus mapas de valores correspondentes.
Após o processamento acima, existe o Motion Planning: um método usado no campo da robótica e controle automático para planejar o caminho do movimento de objetos no espaço para evitar colisões e atender a outras restrições.

2.2. Métodos e fórmulas

Sabemos que o que é expresso na linguagem é relativamente livre, ou relativamente amplo, mas o que os robôs precisam é de instruções de operação específicas e direcionadas.

Por exemplo, "abrir a gaveta superior", pode ser difícil gerar uma trajetória com base apenas nesta frase, então decompomos um problema em subtarefas específicas e especificamos claramente a tarefa de operação, que pode ser decomposta em "Pegue a alça de a gaveta superior” e “abrir a gaveta”, essa subtarefa concreta derivada de planejadores avançados, como LLM ou planejadores baseados em pesquisa, torna-se acionável.
A próxima etapa é otimizar cada subtarefa, onde as subtarefas são instruções de linguagem LLM e o caminho de movimento do robô, onde o caminho de movimento é uma sequência de pontos de caminho de efetor final densos executados pelo controlador de espaço de operação, e cada ponto de caminho é composto por 6 Os graus de liberdade pose do efetor final, velocidade do efetor final e ação da garra são compostos .

Nós os expressamos como uma fórmula da seguinte forma:

$T_i$ : A evolução do estado do ambiente
$T_i^r \subseteq T_i$ : A trajectória do robô
$C(T_i)$ : As restrições dinâmicas e cinemáticas relevantes, sujeito a sujeito a meios.
$F_{tarefa}$ : $T_i$ Pontuado pelo grau de conclusão das instruções
$F_{controle}$ : especifica os custos de controle, por exemplo, incentiva $T_i^r$ a minimização do tempo total de controle

Ao resolver este problema de otimização para cada subtarefa, obtemos uma sequência de trajetórias do robô que, juntas, realizam a tarefa geral especificada pela instrução L.

Para instruções de linguagem de forma livre, a computação $F_{tarefa}$ é extremamente desafiadora não apenas pela riqueza do espaço que as linguagens semânticas podem transmitir, mas também pela escassez de dados rotulados roboticamente. No entanto, fornecemos uma observação importante de que um grande número de tarefas pode ser $V \in R^{w*h*d}$ representado por um mapa com valor de voxel no espaço de observação do robô. O valor do voxel aqui pode ser entendido como uma matriz tridimensional ou coordenadas no espaço e, em seguida, mapeado.

"Pegue a alça da gaveta superior" (inferido por LLMs). A "entidade de interesse" é o efetor final do robô, e o mapa de valores de voxel deve refletir a atração pela alça da gaveta. Ao comandar ainda mais "tenha cuidado com os vasos", o mapa também pode ser atualizado para refletir a repulsão dos vasos.
Denotamos a "entidade de interesse" como e , cuja trajetória é $T^e$ , usando o mapa de valores voxels da instrução dada, $F_{tarefa}$ a tarefa pode ser aproximada acumulando os valores e percorridos da seguinte forma:

onde $p_j^e\in N^3$ é a posição discreta (x, y, z) de e na etapa j . Como essas posições são esparsas, aumentamos a densidade do mapa de voxels suavizando as operações, incentivando o planejador de movimento a otimizar para trajetórias mais suaves. Como o VoxPoser usa um grande modelo de linguagem com rico senso comum para sintetizar as trajetórias do robô, as trajetórias sintéticas de disparo zero podem servir como um viés prévio útil para a distribuição de amostragem de ação , o que pode acelerar significativamente o processo de aprendizado. Na prática, isso pode ser obtido amostrando ações nas proximidades, adicionando um pequeno ruído ε para encorajar a exploração local em vez da exploração em todo o espaço de ação.
$T_0^r$ $P(a_t | o_t,T_0^r)$ $T_0^r$

2.3. Nuvem de pontos de reconstrução

Os LLMs usam seu próprio código gerado, onde cada programa de modelo de linguagem (LMP) é responsável por uma função única (por exemplo, lidar com chamadas de percepção). Este artigo usa a API aberta GPT-4 da OpenAI.
Vamos primeiro olhar para os resultados experimentais em comparação com a linha de base:

Pode-se observar que o VoxPoser tem uma alta taxa de sucesso na execução das tarefas diárias, não só nas tarefas visíveis, mas também nas tarefas invisíveis.
Quais são as operações específicas?
Dada uma consulta de objeto/parte do LLM , primeiro chamamos o detector de vocabulário aberto OWL-ViT para obter a caixa delimitadora, alimentamos o Segment Anything (Meta's Segment Anything Object Model) para obter a máscara e usamos o rastreador de vídeo XMEM ( Atkinson-Shiffrin Memory Model-Based Object Segmentation in Long Video) Tracking Mask. Uma nuvem de pontos de um objeto ou parte é reconstruída usando uma máscara de rastreamento combinada com observações RGB-D .

2.4. Mapa de valor (mapeamento) e planejador de movimento

Definimos mapas de valor dos seguintes tipos: visibilidade de recursos de recursos, evitação de evitação , velocidade do efetuador final velocidade do efetuador final, rotação do efetuador final rotação do efetuador final e ação de garra ação de preensão .
Cada tipo usa um programa de modelo de linguagem diferente ( LMP ) que recebe instruções e gera um mapa voxel de forma (100,100,100,k) , onde k é diferente para cada mapa de valor (por exemplo, k=1 para recursos visíveis e evitados, k=4 para rotação)
Aplicamos a transformação de distância euclidiana ao mapa de visibilidade do recurso e o filtro gaussiano ao mapa de prevenção. No topo do LMP de mapeamento de valores , definimos dois LMPs de alto nível para coordenar seu comportamento: o planejador recebe como entrada uma instrução de usuário L (por exemplo, “abrir gaveta”) e gera uma série de subtarefas $l_{1:N}$ e, em seguida, o compositor assume as subtarefas como Mapear LMPs $eu_eu$ para entrada e invocar valores associados com parametrização de linguagem detalhada.

O próximo passo é construir um planejador de movimento.Na otimização do planejador, apenas o mapa de visibilidade e o mapa de prevenção são considerados, e uma série de posições de efetor final livres de colisão são encontradas usando busca gulosa $p_{1:N} \em R^3$ . Em seguida, aplicamos parametrizações adicionais em cada p pelos mapas de valor restantes (por exemplo, mapas de rotação, mapas de velocidade) . O mapa de custo usado pelo planejador de movimento é calculado como o negativo da soma ponderada dos mapas de visibilidade e evitação normalizados com pesos 2 e 1. Depois de sintetizar a trajetória 6-DOF, o primeiro ponto de rota é executado, seguido por A frequência replaneja o nova trajetória.

Especificamente, primeiro usamos o VoxPoser para sintetizar k trajetórias diferentes, cada uma representada como uma sequência de waypoints do efetor final. Em seguida, aprendemos um modelo dinâmico MLP $o_t$ para aprender e $no$ prever por meio de um processo iterativo $o_{t+1}$ no qual o agente alterna entre a coleta de dados e o aprendizado do modelo. Na distribuição de amostragem de ação do MPC $o_{t+1}$ , adicionamos , trajetórias sintéticas iniciais como anteriores a $T_0^r$ cada waypoint em , incentivando a exploração local, usando essas trajetórias como explorações anteriores, podemos aprender em menos de 3 minutos de interação online Modelo cinético eficaz, resultando em uma taxa de sucesso final mais elevada. Por outro lado, sem prévias, é muito difícil aprender modelos dinâmicos, pois a maioria das ações não leva a mudanças significativas no ambiente.

3. Resposta a emergências

Como lidar com alguns fenômenos imprevisíveis de grandes modelos, aqui usamos o LLM , que possui uma riqueza de conhecimento mundial. Em particular, concentramos nossa pesquisa nas capacidades comportamentais exclusivas do VoxPoser . Observamos as seguintes capacidades:

1. Estimativa de propriedades físicas: Dados dois blocos de massa desconhecida, a tarefa do robô é realizar experimentos físicos usando as ferramentas disponíveis para determinar qual bloco é mais pesado.
2. Raciocínio comportamental de senso comum: Na tarefa do robô que coloca a mesa, o usuário pode especificar uma preferência comportamental, como "eu sou canhoto", que exige que o robô entenda seu significado no contexto da tarefa.
3. Correção de erro de linguagem refinada: Para tarefas de alta precisão, como "cobrir o bule com a tampa", o usuário pode fornecer instruções precisas ao robô, como "você se desviou 1 cm para a esquerda", e esse requisito preciso pode também sem problemas.
4. Programa de visualização em várias etapas: Dada a tarefa de "abrir metade da gaveta com precisão", devido ao modelo de objeto indisponível e informações insuficientes, o VoxPoser pode propor uma estratégia de operação em várias etapas. De acordo com o feedback visual, em primeiro lugar, o a gaveta é totalmente aberta enquanto registra o deslocamento da alça. Abra e feche-a novamente até o ponto médio para atender aos requisitos.

Os recursos de emergência acima são refletidos na figura a seguir:

4. Limitações do VoxPoser

Neste trabalho, propomos o VoxPoser , um framework geral de manipulação robótica que extrai recursos e restrições de LLMs , fornecendo benefícios significativos de generalização para instruções e objetos de conjunto aberto. Em particular, codificamos LLMs para interagir com VLMs para compor mapas de valor 3D baseados no espaço de observação para sintetizar trajetórias para tarefas operacionais diárias. Além disso, mostramos que o VoxPoser pode se beneficiar de interações online aprendendo eficientemente um modelo dinâmico para tarefas de contato ricas.
Claro, VoxPoser também tem as seguintes limitações:

Primeiro, ele se baseia em um módulo de percepção extrínseca, que é limitado em tarefas que exigem raciocínio visual holístico ou compreensão da geometria de objetos de baixa granularidade.
Em segundo lugar, embora adequado para aprendizado dinâmico eficiente, um modelo dinâmico geral ainda é necessário para tarefas multitoque com o mesmo nível de generalização.
Em terceiro lugar, nosso planejador de movimento considera apenas as trajetórias do efetuador final, enquanto o planejamento de braço completo também é viável e pode ser uma escolha de projeto melhor.

5, Transforms3d do VoxPoser

Entre eles, o núcleo do VoxPoser é fornecer suporte de código para LLM . Além das bibliotecas Numpy e Transforms3d , ele também fornece descrições detalhadas de muitas bibliotecas APIs Transforms3d: http://matthew-brett.github.io/transforms3d/index. Comando htmlInstall transforms3d, traga o espelho Aliyun para acelerar: pip install transforms3d -i http://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com

Verifique novamente se a instalação foi bem-sucedida:

import transforms3d
transforms3d.__version__
#'0.4.1'

dir(transforms3d)
#['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__path__', '__spec__', '__version__', '_version', 'affines', 'axangles', 'euler', 'quaternions', 'reflections', 'shears', 'taitbryan', 'utils', 'zooms']

Esta biblioteca destina-se principalmente à conversão de transformação de matriz, ângulo de Euler, quaternion, etc. Para uso detalhado, consulte o link fornecido acima.

6. APIs do VoxPoser

Vamos dar uma olhada em quais interfaces externas o VoxPoser fornece:
detect(obj name) : aceita um nome de objeto e retorna uma lista de dicionários, onde cada dicionário corresponde a uma instância do objeto correspondente, incluindo a posição central, grade de ocupação e média normal vetor (vetor médio normal)

execute(móvel, mapa de recursos, mapa de prevenção, mapa de rotação, mapa de velocidade, mapa de garras) : aceita "entidade de interesse" como lista de "móveis" (dicionário retornado pordetect) e (opcionalmente) mapas de valor e chama o planejador de movimento para executar a trajetória. Observe que na configuração do MPC, "móvel" e o mapa de valores de entrada são funções que podem ser reavaliadas para refletir as últimas observações do ambiente e que a entidade de interesse aqui é o efetor final do robô, por meio de seu movimento para manipular o alvo.

cm2index(cm,direction) : Obtém a distância de deslocamento desejada em centímetros ao longo da direção e retorna um vetor 3D refletindo o deslocamento em coordenadas de voxel

index2cm(index,direction) : pega um inteiro "index" e um vetor "direction" e retorna a distância em coordenadas mundiais substituídas pelo "inteiro" em coordenadas voxel

pointat2quat(vector) : Obtém a direção de apontamento desejada para o efetor final e retorna um quaternion de destino satisfatório

set_voxel_by_radius(voxel_map,voxel_xyz,radius_cm,value) : atribui valores aos voxels voxels dentro de "radius" de "voxel_xyz" em "voxel_map voxel map".

get_empty_affordance_map() : Retorna um mapa de visibilidade de feição (mapa) inicializado em 0, onde valores altos atrairão entidades.
Entre eles, existem muitas traduções de affordance, como visibilidade de função, disponibilidade de função, auto-explicação, esclarecimento, etc. Pode ser um pouco confuso pela primeira vez, mas não importa. O ponto principal aqui é sabe o que significa. Significa que a função apresentada por esta coisa irá associar-se naturalmente com a forma de a usar. Por exemplo, quando vires o puxador de uma gaveta, vais querer puxá-la ou empurrá-la; Quando vires um botão, sabes que é um premir .Isso é chamado de visibilidade da função.

get_empty_avoidance_map() : Retorna um mapa (mapa) de desvio de obstáculos inicializado em 0, onde valores altos irão repelir entidades.

get_empty_rotation_map() : Retorna o mapa de rotação padrão inicializado com o quaternion end-effector atual.

get_empty_gripper_map() : retorna o mapa padrão da garra inicializado com a ação atual da garra, onde 1 significa "desligado" e 0 significa "ligado"

get_empty_velocity_map() : retorna ummapa de recursos padrão1o fator de escala(por exemplo, 0,5 representa metade da velocidade padrão)

reset_to_default_pose() : redefine o robô para uma pose de repouso

7. Avisos

Por fim, os prompts mencionados acima que precisam ser usados nas tarefas de operação diária, bem como alguns atributos invisíveis, são decompostos em etapas específicas. Obviamente, os códigos a seguir não foram divulgados no site no momento e devem ser abertos em breve.

7.1, planejador planejador

Uma instrução do usuário L é recebida e uma sequência de subtarefas é gerada $eu_eu$ , que $eu_eu$ é alimentada no compositor (observe que o planejador não é utilizado na simulação, pois a tarefa avaliada consiste em um único estágio operacional).
O resumo de https://voxposer.github.io/prompts/real_planner_prompt.txt
é o seguinte

import numpy as np
from env_utils import execute
from perception_utils import parse_query_obj
import action_utils import composer

objects = ['blue block', 'yellow block', 'mug']# ['蓝色块','黄色块','马克杯']
# Query: place the blue block on the yellow block, and avoid the mug at all time.
# 把蓝色块放在黄色块上，并且一直避免杯子

composer("grasp the blue block while keeping at least 15cm away from the mug")#抓住蓝色方块，同时与杯子保持至少15厘米的距离
composer("back to default pose")#回到默认姿势
composer("move to 5cm on top of the yellow block while keeping at least 15cm away from the mug")#移动到黄色方块上方5厘米处，同时与杯子保持至少15厘米的距离
composer("open gripper")# 打开抓取器

Pode-se ver que o método fornecido ainda é muito claro e conciso. Primeiro, salve a lista de objetos que precisam de atenção e evite , e então use o composer para analisar cada instrução de linguagem específica.

7.2, escritor compositor

Aceite as instruções da subtarefa $eu_eu$ e chame os LMPs de mapeamento de valores necessários para formar o mapeamento de função e o mapeamento de restrição.
O seguinte será dividido em simulador e
simulação de ambiente real: https://voxposer.github.io/prompts/sim_composer_prompt.txt
mundo real: https://voxposer.github.io/prompts/real_composer_prompt.txt
O resumo é como segue:

import numpy as np
from env_utils import execute, reset_to_default_pose
from perception_utils import parse_query_obj
from plan_utils import get_affordance_map, get_avoidance_map, get_velocity_map, get_rotation_map, get_gripper_map

# Query: move ee forward for 7cm.
# 将对象ee向前移动7厘米
movable = parse_query_obj('ee')
affordance_map = get_affordance_map(f'a point 7cm in front of {movable.position}')
execute(movable, affordance_map)

7.3、parse_query_obj

Aceita uma consulta de texto para nomes de objetos/peças e retorna uma lista de dicionários, onde cada dicionário corresponde a uma instância de um objeto correspondente contendo a localização central, a grade de ocupação e o vetor médio normal.
simulação: https://voxposer.github.io/prompts/sim_parse_query_obj_prompt.txt
mundo real: https://voxposer.github.io/prompts/real_parse_query_obj_prompt.txt
O resumo é o seguinte:

import numpy as np
from perception_utils import detect

objects = ['green block', 'yellow line']
# Query: ee.
ee = detect('ee')[0]
ret_val = ee

objects = ['drawer', 'blue block', 'yellow block']
# Query: topmost handle.
# 顶层把手
handles = detect('drawer handle')
# topmost so sort by z, take the last one
# 最上面：按z排序取最后一个
handles = sorted(handles, key=lambda x: x.position[2])
top_handle = handles[-1]
ret_val = top_handle

7.4、get_affordance_map

Aceita parametrizações de linguagem natural de escritores e retorna matrizes NumPy para mapeamentos fornecidos por tarefas.
simulação: https://voxposer.github.io/prompts/sim_get_affordance_map_prompt.txt
mundo real: https://voxposer.github.io/prompts/real_get_affordance_map_prompt.txt
O resumo é o seguinte:

import numpy as np
from perception_utils import parse_query_obj
from plan_utils import get_empty_affordance_map, set_voxel_by_radius, cm2index

# Query: a point 10cm in front of [10, 15, 60].
# 在[10,15,60]位置前面10cm处的一个点
affordance_map = get_empty_affordance_map()
# 10cm in front of so we add to x-axis
# 在前面10cm处，我们添加到x轴
x = 10 + cm2index(10, 'x')
y = 15
z = 60
affordance_map[x, y, z] = 1
ret_val = affordance_map

# Query: a point on the right side of the table.
# 表右侧的一个点
affordance_map = get_empty_affordance_map()
table = parse_query_obj('table')
(min_x, min_y, min_z), (max_x, max_y, max_z) = table.aabb
center_x, center_y, center_z = table.position
# right side so y = max_y
x = center_x
y = max_y
z = center_z
affordance_map[x, y, z] = 1
ret_val = affordance_map

7.5、get_avoidance_map

Aceita a parametrização de linguagem natural do gravador e retorna a matriz NumPy para mapeamento de prevenção de tarefas.
simulação: https://voxposer.github.io/prompts/sim_get_avoidance_map_prompt.txt
mundo real: https://voxposer.github.io/prompts/real_get_avoidance_map_prompt.txt
O resumo é o seguinte:

import numpy as np
from perception_utils import parse_query_obj
from plan_utils import get_empty_avoidance_map, set_voxel_by_radius, cm2index

# Query: 10cm from the bowl.
# 离碗10cm
avoidance_map = get_empty_avoidance_map()
bowl = parse_query_obj('bowl')
set_voxel_by_radius(avoidance_map, bowl.position, radius_cm=10, value=1)
ret_val = avoidance_map

7.6, get_rotation_map

Aceita uma parametrização de linguagem natural do gravador e retorna uma matriz NumPy do mapa de rotação do efetuador final.
simulação: https://voxposer.github.io/prompts/sim_get_rotation_map_prompt.txt
mundo real: https://voxposer.github.io/prompts/real_get_rotation_map_prompt.txt
O resumo é o seguinte:

import numpy as np
from plan_utils import get_empty_rotation_map, set_voxel_by_radius, cm2index, vec2quat
from perception_utils import parse_query_obj
from transforms3d.euler import euler2quat, quat2euler
from transforms3d.quaternions import qmult, qinverse

# Query: face the support surface of the bowl.
# 面朝碗的支撑面
rotation_map = get_empty_rotation_map()
bowl = parse_query_obj('bowl')
target_rotation = vec2quat(-bowl.normal)
rotation_map[:, :, :] = target_rotation
ret_val = rotation_map

7.7, get_gripper_map

Aceita parametrização de linguagem natural do gravador e retorna
a simulação de matriz NumPy para o mapa de garras: https://voxposer.github.io/prompts/sim_get_gripper_map_prompt.txt
mundo real: https://voxposer.github.io/prompts O resumo de /real_get_gripper_map_prompt .txt
é o seguinte:

import numpy as np
from perception_utils import parse_query_obj
from plan_utils import get_empty_gripper_map, set_voxel_by_radius, cm2index

# Query: open everywhere except 1cm around the green block.
# 除绿色块周围1cm外，所有地方都打开
gripper_map = get_empty_gripper_map()
# open everywhere
gripper_map[:, :, :] = 0
# close when 1cm around the green block
green_block = parse_query_obj('green block')
set_voxel_by_radius(gripper_map, green_block.position, radius_cm=1, value=1)
ret_val = gripper_map

7.8, get_velocity_map

Aceita uma parametrização de linguagem natural do gravador e retorna uma matriz NumPy do mapa de velocidade do efetuador final.
simulação: https://voxposer.github.io/prompts/sim_get_velocity_map_prompt.txt
mundo real: https://voxposer.github.io/prompts/real_get_velocity_map_prompt.txt
O resumo é o seguinte:

import numpy as np
from plan_utils import get_empty_velocity_map, set_voxel_by_radius, cm2index
from perception_utils import parse_query_obj

# Query: faster when on the right side of the table and slower when on the left side of the table.
# 在桌子右边时速度更快，在桌子左边时速度更慢
velocity_map = get_empty_velocity_map()
table = parse_query_obj('table')
center_x, center_y, center_z = table.position
# faster on right side so 1.5 when y > center_y, slower on left side so 0.5 when y < center_y
velocity_map[:, center_y:, :] = 1.5
velocity_map[:, :center_y, :] = 0.5
ret_val = velocity_map

Para mais detalhes, recomenda-se a leitura do texto original do artigo. Este é principalmente o meu entendimento pessoal. Se houver algum erro, por favor, corrija-me.
Referências:
voxposer: https://voxposer.github.io/
XMem: https://github.com/hkchengrex/XMem