diff --git a/atec_robot_model/objects/task_e/KLT_Bin/.thumbs/256x256/.small_KLT.usd.last_generated b/atec_robot_model/objects/task_e/KLT_Bin/.thumbs/256x256/.small_KLT.usd.last_generated new file mode 100644 index 0000000000000000000000000000000000000000..82baea903f9f6cf0900ed7fd698d32e89c371da6 --- /dev/null +++ b/atec_robot_model/objects/task_e/KLT_Bin/.thumbs/256x256/.small_KLT.usd.last_generated @@ -0,0 +1 @@ +2025-01-15 22:28:57 \ No newline at end of file diff --git a/atec_robot_model/objects/task_e/KLT_Bin/.thumbs/256x256/.small_KLT_visual.usd.last_generated b/atec_robot_model/objects/task_e/KLT_Bin/.thumbs/256x256/.small_KLT_visual.usd.last_generated new file mode 100644 index 0000000000000000000000000000000000000000..6f87eb67370f56d76bcfa9baf0083c67626201e6 --- /dev/null +++ b/atec_robot_model/objects/task_e/KLT_Bin/.thumbs/256x256/.small_KLT_visual.usd.last_generated @@ -0,0 +1 @@ +2025-01-15 22:29:04 \ No newline at end of file diff --git a/atec_robot_model/objects/task_e/KLT_Bin/.thumbs/256x256/.small_KLT_visual_collision.usd.last_generated b/atec_robot_model/objects/task_e/KLT_Bin/.thumbs/256x256/.small_KLT_visual_collision.usd.last_generated new file mode 100644 index 0000000000000000000000000000000000000000..421e3640f4159deb979fb98b46f023d7afb6d49e --- /dev/null +++ b/atec_robot_model/objects/task_e/KLT_Bin/.thumbs/256x256/.small_KLT_visual_collision.usd.last_generated @@ -0,0 +1 @@ +2025-01-15 22:29:09 \ No newline at end of file diff --git a/atec_robot_model/objects/task_e/KLT_Bin/.thumbs/small_KLT.thumb.usd b/atec_robot_model/objects/task_e/KLT_Bin/.thumbs/small_KLT.thumb.usd new file mode 100644 index 0000000000000000000000000000000000000000..b738494356fce68177b708fb231161f8a5d92081 Binary files /dev/null and b/atec_robot_model/objects/task_e/KLT_Bin/.thumbs/small_KLT.thumb.usd differ diff --git a/atec_robot_model/objects/task_e/KLT_Bin/.thumbs/small_KLT_visual.thumb.usd b/atec_robot_model/objects/task_e/KLT_Bin/.thumbs/small_KLT_visual.thumb.usd new file mode 100644 index 0000000000000000000000000000000000000000..d3ca910d749f2b4a2c3a9c72a24950e16f24b9cb Binary files /dev/null and b/atec_robot_model/objects/task_e/KLT_Bin/.thumbs/small_KLT_visual.thumb.usd differ diff --git a/atec_robot_model/objects/task_e/KLT_Bin/.thumbs/small_KLT_visual_collision.thumb.usd b/atec_robot_model/objects/task_e/KLT_Bin/.thumbs/small_KLT_visual_collision.thumb.usd new file mode 100644 index 0000000000000000000000000000000000000000..854fb8d2e49d613035cddc0ff9c972d8a5c5494b Binary files /dev/null and b/atec_robot_model/objects/task_e/KLT_Bin/.thumbs/small_KLT_visual_collision.thumb.usd differ diff --git a/atec_robot_model/objects/task_e/KLT_Bin/small_KLT.usd b/atec_robot_model/objects/task_e/KLT_Bin/small_KLT.usd new file mode 100644 index 0000000000000000000000000000000000000000..6c11b2707e9cf319a3f2d95eab052094f5b196d8 Binary files /dev/null and b/atec_robot_model/objects/task_e/KLT_Bin/small_KLT.usd differ diff --git a/atec_robot_model/objects/task_e/shop_table/.collect.mapping.json b/atec_robot_model/objects/task_e/shop_table/.collect.mapping.json new file mode 100644 index 0000000000000000000000000000000000000000..10cb9eb5a26541031fb8167b23c26073adc44d7c --- /dev/null +++ b/atec_robot_model/objects/task_e/shop_table/.collect.mapping.json @@ -0,0 +1,77 @@ +{ + "version": "1.0", + "file_records": [ + { + "source_url": "/home/wxm/VLA/IsaacSim/isaac-sim-asserts/isaac-sim-assets-1@4.5.0-rc.36+release.19112.f59b3005/Assets/Isaac/4.5/Isaac/Samples/Examples/FrankaNutBolt/SubUSDs/Shop_Table/textures/aluminum_feet_basecolor.png", + "source_hash": "f57c28888268a580c183fdeb41f7bb9e9eb0b134", + "target_url": "./textures/aluminum_feet_basecolor.png", + "target_hash": "8ceaebf96f29d4ca23d43b0b35a4a9d7d591b9a2" + }, + { + "source_url": "/home/wxm/VLA/IsaacSim/isaac-sim-asserts/isaac-sim-assets-1@4.5.0-rc.36+release.19112.f59b3005/Assets/Isaac/4.5/Isaac/Samples/Examples/FrankaNutBolt/SubUSDs/Shop_Table/textures/aluminum_feet_normal.png", + "source_hash": "90799c1ef386f466fd2fc4ec065edd8c0d6c4a7e", + "target_url": "./textures/aluminum_feet_normal.png", + "target_hash": "782bdfd98942e2e209de7ad9685ed07fe221d45c" + }, + { + "source_url": "/home/wxm/VLA/IsaacSim/isaac-sim-asserts/isaac-sim-assets-1@4.5.0-rc.36+release.19112.f59b3005/Assets/Isaac/4.5/Isaac/Samples/Examples/FrankaNutBolt/SubUSDs/Shop_Table/textures/aluminum_feet_roughness.png", + "source_hash": "2b7a4d8487620024cc43a6e796b52a3a92b566e5", + "target_url": "./textures/aluminum_feet_roughness.png", + "target_hash": "ff5571089243d1d75b7509293beabe4f24f973ea" + }, + { + "source_url": "/home/wxm/VLA/IsaacSim/isaac-sim-asserts/isaac-sim-assets-1@4.5.0-rc.36+release.19112.f59b3005/Assets/Isaac/4.5/Isaac/Samples/Examples/FrankaNutBolt/SubUSDs/Shop_Table/textures/metal_tabletop_basecolor.png", + "source_hash": "e70234bdc6a607996b395667c8a1dee815703a4a", + "target_url": "./textures/metal_tabletop_basecolor.png", + "target_hash": "f07f6619e46cc26545f5061bec0cbdb94e37c922" + }, + { + "source_url": "/home/wxm/VLA/IsaacSim/isaac-sim-asserts/isaac-sim-assets-1@4.5.0-rc.36+release.19112.f59b3005/Assets/Isaac/4.5/Isaac/Samples/Examples/FrankaNutBolt/SubUSDs/Shop_Table/textures/metal_tabletop_metallic.png", + "source_hash": "d21eeeb9e675f4203387875b1d690151cb574c74", + "target_url": "./textures/metal_tabletop_metallic.png", + "target_hash": "2c6266f3ab51d0537ad38b54df02007eb9111803" + }, + { + "source_url": "/home/wxm/VLA/IsaacSim/isaac-sim-asserts/isaac-sim-assets-1@4.5.0-rc.36+release.19112.f59b3005/Assets/Isaac/4.5/Isaac/Samples/Examples/FrankaNutBolt/SubUSDs/Shop_Table/textures/metal_tabletop_normal.png", + "source_hash": "330003f7b33e37a63ff1547d603c9f54ecac6f1c", + "target_url": "./textures/metal_tabletop_normal.png", + "target_hash": "ce62d74aa3f6a05b8662b1a8f938a6421a9819aa" + }, + { + "source_url": "/home/wxm/VLA/IsaacSim/isaac-sim-asserts/isaac-sim-assets-1@4.5.0-rc.36+release.19112.f59b3005/Assets/Isaac/4.5/Isaac/Samples/Examples/FrankaNutBolt/SubUSDs/Shop_Table/textures/metal_tabletop_roughness.png", + "source_hash": "679380766abf4ca418c1d1681dec38a96f74d24e", + "target_url": "./textures/metal_tabletop_roughness.png", + "target_hash": "e4e2dc752544d7a9d0919520a33f084adff9cf50" + }, + { + "source_url": "/home/wxm/VLA/IsaacSim/isaac-sim-asserts/isaac-sim-assets-1@4.5.0-rc.36+release.19112.f59b3005/Assets/Isaac/4.5/Isaac/Samples/Examples/FrankaNutBolt/SubUSDs/Shop_Table/textures/steel_orange_basecolor.png", + "source_hash": "19de24af03b4a0a2a9fb1213e72b8dbb9fe43446", + "target_url": "./textures/steel_orange_basecolor.png", + "target_hash": "ada63e416ff77d9579ddb44bf24069b4d7393e84" + }, + { + "source_url": "/home/wxm/VLA/IsaacSim/isaac-sim-asserts/isaac-sim-assets-1@4.5.0-rc.36+release.19112.f59b3005/Assets/Isaac/4.5/Isaac/Samples/Examples/FrankaNutBolt/SubUSDs/Shop_Table/textures/steel_orange_metallic.png", + "source_hash": "a3b4c3c79ac1f820465b66078faf40131e83deb1", + "target_url": "./textures/steel_orange_metallic.png", + "target_hash": "6ef5e8a42ce00c27e79275c54258d9f99fe09ca7" + }, + { + "source_url": "/home/wxm/VLA/IsaacSim/isaac-sim-asserts/isaac-sim-assets-1@4.5.0-rc.36+release.19112.f59b3005/Assets/Isaac/4.5/Isaac/Samples/Examples/FrankaNutBolt/SubUSDs/Shop_Table/textures/steel_orange_normal.png", + "source_hash": "2024c4b6f6a2bed8812d854df83e115f15b132df", + "target_url": "./textures/steel_orange_normal.png", + "target_hash": "6c49a1bdb10f7b66c8e4028988fa6bafd416ab5b" + }, + { + "source_url": "/home/wxm/VLA/IsaacSim/isaac-sim-asserts/isaac-sim-assets-1@4.5.0-rc.36+release.19112.f59b3005/Assets/Isaac/4.5/Isaac/Samples/Examples/FrankaNutBolt/SubUSDs/Shop_Table/textures/steel_orange_roughness.png", + "source_hash": "529db0802c83a483c28e235ff6c706b99159d778", + "target_url": "./textures/steel_orange_roughness.png", + "target_hash": "fd92178c5427e9a2728bb4f866827724cb0025a5" + }, + { + "source_url": "/home/wxm/VLA/IsaacSim/isaac-sim-asserts/isaac-sim-assets-1@4.5.0-rc.36+release.19112.f59b3005/Assets/Isaac/4.5/Isaac/Samples/Examples/FrankaNutBolt/SubUSDs/Shop_Table/textures/vibrationtable_base_basecolor.png", + "source_hash": "c526c43071d2aa9dd4399e7682390774d84a9ee5", + "target_url": "./textures/vibrationtable_base_basecolor.png", + "target_hash": "933a0ca8cf7d13fbae9a8980a58798842625483a" + } + ] +} \ No newline at end of file diff --git a/demo/act/detr/backbone.py b/demo/act/detr/backbone.py new file mode 100644 index 0000000000000000000000000000000000000000..859c62656c2befd68f838fa9a5d91ae559a3a3fb --- /dev/null +++ b/demo/act/detr/backbone.py @@ -0,0 +1,126 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved +""" +Backbone modules. +""" +from collections import OrderedDict + +import torch +import torch.nn.functional as F +import torchvision +from torch import nn +from torchvision.models._utils import IntermediateLayerGetter +from typing import Dict, List + +from .utils import NestedTensor +from .position_encoding import build_position_encoding + +class FrozenBatchNorm2d(torch.nn.Module): + """ + BatchNorm2d where the batch statistics and the affine parameters are fixed. + + Copy-paste from torchvision.misc.ops with added eps before rqsrt, + without which any other policy_models than torchvision.policy_models.resnet[18,34,50,101] + produce nans. + """ + + def __init__(self, n): + super(FrozenBatchNorm2d, self).__init__() + self.register_buffer("weight", torch.ones(n)) + self.register_buffer("bias", torch.zeros(n)) + self.register_buffer("running_mean", torch.zeros(n)) + self.register_buffer("running_var", torch.ones(n)) + + def _load_from_state_dict(self, state_dict, prefix, local_metadata, strict, + missing_keys, unexpected_keys, error_msgs): + num_batches_tracked_key = prefix + 'num_batches_tracked' + if num_batches_tracked_key in state_dict: + del state_dict[num_batches_tracked_key] + + super(FrozenBatchNorm2d, self)._load_from_state_dict( + state_dict, prefix, local_metadata, strict, + missing_keys, unexpected_keys, error_msgs) + + def forward(self, x): + # move reshapes to the beginning + # to make it fuser-friendly + w = self.weight.reshape(1, -1, 1, 1) + b = self.bias.reshape(1, -1, 1, 1) + rv = self.running_var.reshape(1, -1, 1, 1) + rm = self.running_mean.reshape(1, -1, 1, 1) + eps = 1e-5 + scale = w * (rv + eps).rsqrt() + bias = b - rm * scale + return x * scale + bias + + +class BackboneBase(nn.Module): + + def __init__(self, backbone: nn.Module, train_backbone: bool, num_channels: int, return_interm_layers: bool): + super().__init__() + # for name, parameter in backbone.named_parameters(): # only train later layers # TODO do we want this? + # if not train_backbone or 'layer2' not in name and 'layer3' not in name and 'layer4' not in name: + # parameter.requires_grad_(False) + if return_interm_layers: + return_layers = {"layer1": "0", "layer2": "1", "layer3": "2", "layer4": "3"} + else: + return_layers = {'layer4': "0"} + self.body = IntermediateLayerGetter(backbone, return_layers=return_layers) + self.num_channels = num_channels + + def forward(self, tensor): + xs = self.body(tensor) + return xs + # out: Dict[str, NestedTensor] = {} + # for name, x in xs.items(): + # m = tensor_list.mask + # assert m is not None + # mask = F.interpolate(m[None].float(), size=x.shape[-2:]).to(torch.bool)[0] + # out[name] = NestedTensor(x, mask) + # return out + + +class Backbone(BackboneBase): + """ResNet backbone with frozen BatchNorm.""" + def __init__(self, name: str, + train_backbone: bool, + return_interm_layers: bool, + dilation: bool, + include_depth: bool): + backbone = getattr(torchvision.models, name)( + replace_stride_with_dilation=[False, False, dilation], + pretrained=False, norm_layer=FrozenBatchNorm2d) # pretrained # TODO do we want frozen batch_norm?? + + # for rgbd data + if include_depth: + w = backbone.conv1.weight + w = torch.cat([w, torch.full((64, 1, 7, 7), 0)], dim=1) + backbone.conv1.weight = nn.Parameter(w) + + num_channels = 512 if name in ('resnet18', 'resnet34') else 2048 + super().__init__(backbone, train_backbone, num_channels, return_interm_layers) + + +class Joiner(nn.Sequential): + def __init__(self, backbone, position_embedding): + super().__init__(backbone, position_embedding) + + def forward(self, tensor_list: NestedTensor): + xs = self[0](tensor_list) + out: List[NestedTensor] = [] + pos = [] + for name, x in xs.items(): + out.append(x) + # position encoding + pos.append(self[1](x).to(x.dtype)) + + return out, pos + + +def build_backbone(args): + position_embedding = build_position_encoding(args) + train_backbone = args.lr_backbone > 0 + return_interm_layers = args.masks + backbone = Backbone(args.backbone, train_backbone, return_interm_layers, args.dilation, args.include_depth) + model = Joiner(backbone, position_embedding) + model.num_channels = backbone.num_channels + return model diff --git a/demo/act/detr/detr_vae.py b/demo/act/detr/detr_vae.py new file mode 100644 index 0000000000000000000000000000000000000000..f618542a92c3eb8bd783c335ba1ded5a3b3b46ac --- /dev/null +++ b/demo/act/detr/detr_vae.py @@ -0,0 +1,137 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved +""" +DETR model and criterion classes. +""" +import torch +from torch import nn +from torch.autograd import Variable +from .transformer import build_transformer, TransformerEncoder, TransformerEncoderLayer + +import numpy as np + +def reparametrize(mu, logvar): + std = logvar.div(2).exp() + eps = Variable(std.data.new(std.size()).normal_()) + return mu + std * eps + + +def get_sinusoid_encoding_table(n_position, d_hid): + def get_position_angle_vec(position): + return [position / np.power(10000, 2 * (hid_j // 2) / d_hid) for hid_j in range(d_hid)] + + sinusoid_table = np.array([get_position_angle_vec(pos_i) for pos_i in range(n_position)]) + sinusoid_table[:, 0::2] = np.sin(sinusoid_table[:, 0::2]) # dim 2i + sinusoid_table[:, 1::2] = np.cos(sinusoid_table[:, 1::2]) # dim 2i+1 + + return torch.FloatTensor(sinusoid_table).unsqueeze(0) + + +class DETRVAE(nn.Module): + """ This is the DETR module that performs object detection """ + def __init__(self, backbones, transformer, encoder, state_dim, action_dim, num_queries): + super().__init__() + self.num_queries = num_queries + self.transformer = transformer + self.encoder = encoder + hidden_dim = transformer.d_model + self.action_head = nn.Linear(hidden_dim, action_dim) + self.query_embed = nn.Embedding(num_queries, hidden_dim) + if backbones is not None: + self.input_proj = nn.Conv2d(backbones[0].num_channels, hidden_dim, kernel_size=1) + self.backbones = nn.ModuleList(backbones) + self.input_proj_robot_state = nn.Linear(state_dim, hidden_dim) + else: + self.input_proj_robot_state = nn.Linear(state_dim, hidden_dim) + self.backbones = None + + # encoder extra parameters + self.latent_dim = 32 # size of latent z + self.cls_embed = nn.Embedding(1, hidden_dim) # extra cls token embedding + self.encoder_state_proj = nn.Linear(state_dim, hidden_dim) # project state to embedding + self.encoder_action_proj = nn.Linear(action_dim, hidden_dim) # project action to embedding + self.latent_proj = nn.Linear(hidden_dim, self.latent_dim*2) # project hidden state to latent std, var + self.register_buffer('pos_table', get_sinusoid_encoding_table(1+1+num_queries, hidden_dim)) # [CLS], state, actions + + # decoder extra parameters + self.latent_out_proj = nn.Linear(self.latent_dim, hidden_dim) # project latent sample to embedding + self.additional_pos_embed = nn.Embedding(2, hidden_dim) # learned position embedding for state and proprio + + def forward(self, obs, actions=None): + is_training = actions is not None + state = obs['state'] if self.backbones is not None else obs + bs = state.shape[0] + + if is_training: + # project CLS token, state sequence, and action sequence to embedding dim + cls_embed = self.cls_embed.weight # (1, hidden_dim) + cls_embed = torch.unsqueeze(cls_embed, axis=0).repeat(bs, 1, 1) # (bs, 1, hidden_dim) + state_embed = self.encoder_state_proj(state) # (bs, hidden_dim) + state_embed = torch.unsqueeze(state_embed, axis=1) # (bs, 1, hidden_dim) + action_embed = self.encoder_action_proj(actions) # (bs, seq, hidden_dim) + # concat them together to form an input to the CVAE encoder + encoder_input = torch.cat([cls_embed, state_embed, action_embed], axis=1) # (bs, seq+2, hidden_dim) + encoder_input = encoder_input.permute(1, 0, 2) # (seq+2, bs, hidden_dim) + # no masking is applied to all parts of the CVAE encoder input + is_pad = torch.full((bs, encoder_input.shape[0]), False).to(state.device) # False: not a padding + # obtain position embedding + pos_embed = self.pos_table.clone().detach() + pos_embed = pos_embed.permute(1, 0, 2) # (seq+2, 1, hidden_dim) + # query CVAE encoder + encoder_output = self.encoder(encoder_input, pos=pos_embed, src_key_padding_mask=is_pad) + encoder_output = encoder_output[0] # take cls output only + latent_info = self.latent_proj(encoder_output) + mu = latent_info[:, :self.latent_dim] + logvar = latent_info[:, self.latent_dim:] + latent_sample = reparametrize(mu, logvar) + latent_input = self.latent_out_proj(latent_sample) + else: + mu = logvar = None + latent_sample = torch.zeros([bs, self.latent_dim], dtype=torch.float32).to(state.device) + latent_input = self.latent_out_proj(latent_sample) + + # CVAE decoder + if self.backbones is not None: + vis_data = obs['rgb'] + if "depth" in obs: + vis_data = torch.cat([vis_data, obs['depth']], dim=2) + num_cams = vis_data.shape[1] + + # Image observation features and position embeddings + all_cam_features = [] + all_cam_pos = [] + for cam_id in range(num_cams): + features, pos = self.backbones[0](vis_data[:, cam_id]) # HARDCODED + features = features[0] # take the last layer feature # (batch, hidden_dim, H, W) + pos = pos[0] # (1, hidden_dim, H, W) + all_cam_features.append(self.input_proj(features)) + all_cam_pos.append(pos) + + # proprioception features (state) + proprio_input = self.input_proj_robot_state(state) + # fold camera dimension into width dimension + src = torch.cat(all_cam_features, axis=3) # (batch, hidden_dim, 4, 8) + pos = torch.cat(all_cam_pos, axis=3) # (batch, hidden_dim, 4, 8) + hs = self.transformer(src, None, self.query_embed.weight, pos, latent_input, proprio_input, self.additional_pos_embed.weight)[0] # (batch, num_queries, hidden_dim) + else: + state = self.input_proj_robot_state(state) + hs = self.transformer(None, None, self.query_embed.weight, None, latent_input, state, self.additional_pos_embed.weight)[0] + + a_hat = self.action_head(hs) + return a_hat, [mu, logvar] + + +def build_encoder(args): + d_model = args.hidden_dim # 256 + dropout = args.dropout # 0.1 + nhead = args.nheads # 8 + dim_feedforward = args.dim_feedforward # 2048 + num_encoder_layers = args.enc_layers # 4 # TODO shared with VAE decoder + normalize_before = args.pre_norm # False + activation = "relu" + + encoder_layer = TransformerEncoderLayer(d_model, nhead, dim_feedforward, + dropout, activation, normalize_before) + encoder_norm = nn.LayerNorm(d_model) if normalize_before else None + encoder = TransformerEncoder(encoder_layer, num_encoder_layers, encoder_norm) + + return encoder diff --git a/demo/act/detr/position_encoding.py b/demo/act/detr/position_encoding.py new file mode 100644 index 0000000000000000000000000000000000000000..d04004d6240117e5ce15eca5b66bca2891401c6e --- /dev/null +++ b/demo/act/detr/position_encoding.py @@ -0,0 +1,90 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved +""" +Various positional encodings for the transformer. +""" +import math +import torch +from torch import nn + +from .utils import NestedTensor + +class PositionEmbeddingSine(nn.Module): + """ + This is a more standard version of the position embedding, very similar to the one + used by the Attention is all you need paper, generalized to work on images. + """ + def __init__(self, num_pos_feats=64, temperature=10000, normalize=False, scale=None): + super().__init__() + self.num_pos_feats = num_pos_feats + self.temperature = temperature + self.normalize = normalize + if scale is not None and normalize is False: + raise ValueError("normalize should be True if scale is passed") + if scale is None: + scale = 2 * math.pi + self.scale = scale + + def forward(self, tensor): + x = tensor + # mask = tensor_list.mask + # assert mask is not None + # not_mask = ~mask + + not_mask = torch.ones_like(x[0, [0]]) + y_embed = not_mask.cumsum(1, dtype=torch.float32) + x_embed = not_mask.cumsum(2, dtype=torch.float32) + if self.normalize: + eps = 1e-6 + y_embed = y_embed / (y_embed[:, -1:, :] + eps) * self.scale + x_embed = x_embed / (x_embed[:, :, -1:] + eps) * self.scale + + dim_t = torch.arange(self.num_pos_feats, dtype=torch.float32, device=x.device) + dim_t = self.temperature ** (2 * (dim_t // 2) / self.num_pos_feats) + + pos_x = x_embed[:, :, :, None] / dim_t + pos_y = y_embed[:, :, :, None] / dim_t + pos_x = torch.stack((pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()), dim=4).flatten(3) + pos_y = torch.stack((pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()), dim=4).flatten(3) + pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2) + return pos + + +class PositionEmbeddingLearned(nn.Module): + """ + Absolute pos embedding, learned. + """ + def __init__(self, num_pos_feats=256): + super().__init__() + self.row_embed = nn.Embedding(50, num_pos_feats) + self.col_embed = nn.Embedding(50, num_pos_feats) + self.reset_parameters() + + def reset_parameters(self): + nn.init.uniform_(self.row_embed.weight) + nn.init.uniform_(self.col_embed.weight) + + def forward(self, tensor_list: NestedTensor): + x = tensor_list.tensors + h, w = x.shape[-2:] + i = torch.arange(w, device=x.device) + j = torch.arange(h, device=x.device) + x_emb = self.col_embed(i) + y_emb = self.row_embed(j) + pos = torch.cat([ + x_emb.unsqueeze(0).repeat(h, 1, 1), + y_emb.unsqueeze(1).repeat(1, w, 1), + ], dim=-1).permute(2, 0, 1).unsqueeze(0).repeat(x.shape[0], 1, 1, 1) + return pos + + +def build_position_encoding(args): + N_steps = args.hidden_dim // 2 + if args.position_embedding in ('v2', 'sine'): + # TODO find a better way of exposing other arguments + position_embedding = PositionEmbeddingSine(N_steps, normalize=True) + elif args.position_embedding in ('v3', 'learned'): + position_embedding = PositionEmbeddingLearned(N_steps) + else: + raise ValueError(f"not supported {args.position_embedding}") + + return position_embedding diff --git a/demo/act/detr/transformer.py b/demo/act/detr/transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..aa16cb65978ec384fb40abfb907893e32fcf8eeb --- /dev/null +++ b/demo/act/detr/transformer.py @@ -0,0 +1,455 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved +""" +DETR Transformer class. + +Copy-paste from torch.nn.Transformer with modifications: + * positional encodings are passed in MHattention + * extra LN at the end of encoder is removed + * decoder returns a stack of activations from all decoding layers +""" +import copy +from typing import Optional, List + +import torch +import torch.nn.functional as F +from torch import nn, Tensor + +class Transformer(nn.Module): + + def __init__(self, d_model=512, nhead=8, num_encoder_layers=6, + num_decoder_layers=6, dim_feedforward=2048, dropout=0.1, + activation="relu", normalize_before=False, + return_intermediate_dec=False, use_xsa=False): + super().__init__() + + encoder_cls = XSATransformerEncoderLayer if use_xsa else TransformerEncoderLayer + decoder_cls = XSATransformerDecoderLayer if use_xsa else TransformerDecoderLayer + + encoder_layer = encoder_cls(d_model, nhead, dim_feedforward, + dropout, activation, normalize_before) + encoder_norm = nn.LayerNorm(d_model) if normalize_before else None + self.encoder = TransformerEncoder(encoder_layer, num_encoder_layers, encoder_norm) + + decoder_layer = decoder_cls(d_model, nhead, dim_feedforward, + dropout, activation, normalize_before) + decoder_norm = nn.LayerNorm(d_model) + self.decoder = TransformerDecoder(decoder_layer, num_decoder_layers, decoder_norm, + return_intermediate=return_intermediate_dec) + + self._reset_parameters() + + self.d_model = d_model + self.nhead = nhead + + def _reset_parameters(self): + for p in self.parameters(): + if p.dim() > 1: + nn.init.xavier_uniform_(p) + + def forward(self, src, mask, query_embed, pos_embed, latent_input=None, proprio_input=None, additional_pos_embed=None): + if src is None: + bs = proprio_input.shape[0] + query_embed = query_embed.unsqueeze(1).repeat(1, bs, 1) + pos_embed = additional_pos_embed.unsqueeze(1).repeat(1, bs, 1) # seq, bs, dim + src = torch.stack([latent_input, proprio_input], axis=0) + # TODO flatten only when input has H and W + elif len(src.shape) == 4: # has H and W + # flatten NxCxHxW to HWxNxC + bs, c, h, w = src.shape + src = src.flatten(2).permute(2, 0, 1) + pos_embed = pos_embed.flatten(2).permute(2, 0, 1).repeat(1, bs, 1) + query_embed = query_embed.unsqueeze(1).repeat(1, bs, 1) + # mask = mask.flatten(1) + + additional_pos_embed = additional_pos_embed.unsqueeze(1).repeat(1, bs, 1) # seq, bs, dim + pos_embed = torch.cat([additional_pos_embed, pos_embed], axis=0) + + addition_input = torch.stack([latent_input, proprio_input], axis=0) + src = torch.cat([addition_input, src], axis=0) + + tgt = torch.zeros_like(query_embed) + memory = self.encoder(src, src_key_padding_mask=mask, pos=pos_embed) + hs = self.decoder(tgt, memory, memory_key_padding_mask=mask, + pos=pos_embed, query_pos=query_embed) + hs = hs.transpose(1, 2) + return hs + + +class TransformerEncoder(nn.Module): + + def __init__(self, encoder_layer, num_layers, norm=None): + super().__init__() + self.layers = _get_clones(encoder_layer, num_layers) + self.num_layers = num_layers + self.norm = norm + + def forward(self, src, + mask: Optional[Tensor] = None, + src_key_padding_mask: Optional[Tensor] = None, + pos: Optional[Tensor] = None): + output = src + + for layer in self.layers: + output = layer(output, src_mask=mask, + src_key_padding_mask=src_key_padding_mask, pos=pos) + + if self.norm is not None: + output = self.norm(output) + + return output + + +class TransformerDecoder(nn.Module): + + def __init__(self, decoder_layer, num_layers, norm=None, return_intermediate=False): + super().__init__() + self.layers = _get_clones(decoder_layer, num_layers) + self.num_layers = num_layers + self.norm = norm + self.return_intermediate = return_intermediate + + def forward(self, tgt, memory, + tgt_mask: Optional[Tensor] = None, + memory_mask: Optional[Tensor] = None, + tgt_key_padding_mask: Optional[Tensor] = None, + memory_key_padding_mask: Optional[Tensor] = None, + pos: Optional[Tensor] = None, + query_pos: Optional[Tensor] = None): + output = tgt + + intermediate = [] + + for layer in self.layers: + output = layer(output, memory, tgt_mask=tgt_mask, + memory_mask=memory_mask, + tgt_key_padding_mask=tgt_key_padding_mask, + memory_key_padding_mask=memory_key_padding_mask, + pos=pos, query_pos=query_pos) + if self.return_intermediate: + intermediate.append(self.norm(output)) + + if self.norm is not None: + output = self.norm(output) + if self.return_intermediate: + intermediate.pop() + intermediate.append(output) + + if self.return_intermediate: + return torch.stack(intermediate) + + return output.unsqueeze(0) + + +class TransformerEncoderLayer(nn.Module): + + def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1, + activation="relu", normalize_before=False): + super().__init__() + self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout) + # Implementation of Feedforward model + self.linear1 = nn.Linear(d_model, dim_feedforward) + self.dropout = nn.Dropout(dropout) + self.linear2 = nn.Linear(dim_feedforward, d_model) + + self.norm1 = nn.LayerNorm(d_model) + self.norm2 = nn.LayerNorm(d_model) + self.dropout1 = nn.Dropout(dropout) + self.dropout2 = nn.Dropout(dropout) + + self.activation = _get_activation_fn(activation) + self.normalize_before = normalize_before + + def with_pos_embed(self, tensor, pos: Optional[Tensor]): + return tensor if pos is None else tensor + pos + + def forward_post(self, + src, + src_mask: Optional[Tensor] = None, + src_key_padding_mask: Optional[Tensor] = None, + pos: Optional[Tensor] = None): + q = k = self.with_pos_embed(src, pos) + src2 = self.self_attn(q, k, value=src, attn_mask=src_mask, + key_padding_mask=src_key_padding_mask)[0] + src = src + self.dropout1(src2) + src = self.norm1(src) + src2 = self.linear2(self.dropout(self.activation(self.linear1(src)))) + src = src + self.dropout2(src2) + src = self.norm2(src) + return src + + def forward_pre(self, src, + src_mask: Optional[Tensor] = None, + src_key_padding_mask: Optional[Tensor] = None, + pos: Optional[Tensor] = None): + src2 = self.norm1(src) + q = k = self.with_pos_embed(src2, pos) + src2 = self.self_attn(q, k, value=src2, attn_mask=src_mask, + key_padding_mask=src_key_padding_mask)[0] + src = src + self.dropout1(src2) + src2 = self.norm2(src) + src2 = self.linear2(self.dropout(self.activation(self.linear1(src2)))) + src = src + self.dropout2(src2) + return src + + def forward(self, src, + src_mask: Optional[Tensor] = None, + src_key_padding_mask: Optional[Tensor] = None, + pos: Optional[Tensor] = None): + if self.normalize_before: + return self.forward_pre(src, src_mask, src_key_padding_mask, pos) + return self.forward_post(src, src_mask, src_key_padding_mask, pos) + + +class TransformerDecoderLayer(nn.Module): + + def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1, + activation="relu", normalize_before=False): + super().__init__() + self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout) + self.multihead_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout) + # Implementation of Feedforward model + self.linear1 = nn.Linear(d_model, dim_feedforward) + self.dropout = nn.Dropout(dropout) + self.linear2 = nn.Linear(dim_feedforward, d_model) + + self.norm1 = nn.LayerNorm(d_model) + self.norm2 = nn.LayerNorm(d_model) + self.norm3 = nn.LayerNorm(d_model) + self.dropout1 = nn.Dropout(dropout) + self.dropout2 = nn.Dropout(dropout) + self.dropout3 = nn.Dropout(dropout) + + self.activation = _get_activation_fn(activation) + self.normalize_before = normalize_before + + def with_pos_embed(self, tensor, pos: Optional[Tensor]): + return tensor if pos is None else tensor + pos + + def forward_post(self, tgt, memory, + tgt_mask: Optional[Tensor] = None, + memory_mask: Optional[Tensor] = None, + tgt_key_padding_mask: Optional[Tensor] = None, + memory_key_padding_mask: Optional[Tensor] = None, + pos: Optional[Tensor] = None, + query_pos: Optional[Tensor] = None): + q = k = self.with_pos_embed(tgt, query_pos) + tgt2 = self.self_attn(q, k, value=tgt, attn_mask=tgt_mask, + key_padding_mask=tgt_key_padding_mask)[0] + tgt = tgt + self.dropout1(tgt2) + tgt = self.norm1(tgt) + tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt, query_pos), + key=self.with_pos_embed(memory, pos), + value=memory, attn_mask=memory_mask, + key_padding_mask=memory_key_padding_mask)[0] + tgt = tgt + self.dropout2(tgt2) + tgt = self.norm2(tgt) + tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt)))) + tgt = tgt + self.dropout3(tgt2) + tgt = self.norm3(tgt) + return tgt + + def forward_pre(self, tgt, memory, + tgt_mask: Optional[Tensor] = None, + memory_mask: Optional[Tensor] = None, + tgt_key_padding_mask: Optional[Tensor] = None, + memory_key_padding_mask: Optional[Tensor] = None, + pos: Optional[Tensor] = None, + query_pos: Optional[Tensor] = None): + tgt2 = self.norm1(tgt) + q = k = self.with_pos_embed(tgt2, query_pos) + tgt2 = self.self_attn(q, k, value=tgt2, attn_mask=tgt_mask, + key_padding_mask=tgt_key_padding_mask)[0] + tgt = tgt + self.dropout1(tgt2) + tgt2 = self.norm2(tgt) + tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt2, query_pos), + key=self.with_pos_embed(memory, pos), + value=memory, attn_mask=memory_mask, + key_padding_mask=memory_key_padding_mask)[0] + tgt = tgt + self.dropout2(tgt2) + tgt2 = self.norm3(tgt) + tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt2)))) + tgt = tgt + self.dropout3(tgt2) + return tgt + + def forward(self, tgt, memory, + tgt_mask: Optional[Tensor] = None, + memory_mask: Optional[Tensor] = None, + tgt_key_padding_mask: Optional[Tensor] = None, + memory_key_padding_mask: Optional[Tensor] = None, + pos: Optional[Tensor] = None, + query_pos: Optional[Tensor] = None): + if self.normalize_before: + return self.forward_pre(tgt, memory, tgt_mask, memory_mask, + tgt_key_padding_mask, memory_key_padding_mask, pos, query_pos) + return self.forward_post(tgt, memory, tgt_mask, memory_mask, + tgt_key_padding_mask, memory_key_padding_mask, pos, query_pos) + + +class _XSAAttention(nn.Module): + """XSA self-attention block adapted from the local LeRobot act_xsa plugin.""" + + def __init__(self, d_model, nhead, dropout=0.1): + super().__init__() + if d_model % nhead != 0: + raise ValueError(f"d_model={d_model} must be divisible by nhead={nhead}") + self.nhead = nhead + self.head_dim = d_model // nhead + self.scale = self.head_dim ** -0.5 + + self.q_proj = nn.Linear(d_model, d_model) + self.k_proj = nn.Linear(d_model, d_model) + self.v_proj = nn.Linear(d_model, d_model) + self.out_proj = nn.Linear(d_model, d_model) + self.gate_proj = nn.Linear(d_model, nhead) + self.q_norm = nn.RMSNorm(self.head_dim) + self.k_norm = nn.RMSNorm(self.head_dim) + self.dropout = nn.Dropout(dropout) + + @staticmethod + def with_pos_embed(tensor, pos: Optional[Tensor]): + return tensor if pos is None else tensor + pos + + def forward(self, x, pos: Optional[Tensor] = None, + attn_mask: Optional[Tensor] = None, + key_padding_mask: Optional[Tensor] = None): + q = k = self.with_pos_embed(x, pos) + q = self.q_proj(q) + k = self.k_proj(k) + v = self.v_proj(x) + + seq_len, batch_size, _ = q.shape + q = q.view(seq_len, batch_size, self.nhead, self.head_dim).permute(1, 2, 0, 3) + k = k.view(seq_len, batch_size, self.nhead, self.head_dim).permute(1, 2, 0, 3) + v = v.view(seq_len, batch_size, self.nhead, self.head_dim).permute(1, 2, 0, 3) + + q = self.q_norm(q) + k = self.k_norm(k) + attn_weights = torch.matmul(q, k.transpose(-2, -1)) * self.scale + if attn_mask is not None: + attn_weights = attn_weights + attn_mask + if key_padding_mask is not None: + attn_weights = attn_weights.masked_fill( + key_padding_mask.unsqueeze(1).unsqueeze(2), float("-inf") + ) + attn_weights = F.softmax(attn_weights, dim=-1) + attn_weights = self.dropout(attn_weights) + + y = torch.matmul(attn_weights, v) + v_norm = F.normalize(v, dim=-1) + projection = (y * v_norm).sum(dim=-1, keepdim=True) + y = y - projection * v_norm + + gate = self.gate_proj(x).sigmoid().permute(1, 2, 0).unsqueeze(-1) + y = y * gate + y = y.permute(2, 0, 1, 3).contiguous().view(seq_len, batch_size, -1) + return self.out_proj(y) + + +class XSATransformerEncoderLayer(nn.Module): + def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1, + activation="relu", normalize_before=False): + super().__init__() + self.self_attn = _XSAAttention(d_model, nhead, dropout=dropout) + self.linear1 = nn.Linear(d_model, dim_feedforward * 2) + self.dropout = nn.Dropout(dropout) + self.linear2 = nn.Linear(dim_feedforward, d_model) + self.norm1 = nn.RMSNorm(d_model) + self.norm2 = nn.RMSNorm(d_model) + self.dropout1 = nn.Dropout(dropout) + self.dropout2 = nn.Dropout(dropout) + + def forward(self, src, + src_mask: Optional[Tensor] = None, + src_key_padding_mask: Optional[Tensor] = None, + pos: Optional[Tensor] = None): + skip = src + src2 = self.norm1(src) + src = skip + self.dropout1( + self.self_attn(src2, pos=pos, attn_mask=src_mask, + key_padding_mask=src_key_padding_mask) + ) + skip = src + src2 = self.norm2(src) + gate, value = self.linear1(src2).chunk(2, dim=-1) + src2 = self.linear2(self.dropout(F.silu(gate) * value)) + src = skip + self.dropout2(src2) + return src + + +class XSATransformerDecoderLayer(nn.Module): + def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1, + activation="relu", normalize_before=False): + super().__init__() + self.self_attn = _XSAAttention(d_model, nhead, dropout=dropout) + self.multihead_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout) + self.linear1 = nn.Linear(d_model, dim_feedforward * 2) + self.dropout = nn.Dropout(dropout) + self.linear2 = nn.Linear(dim_feedforward, d_model) + self.norm1 = nn.RMSNorm(d_model) + self.norm2 = nn.RMSNorm(d_model) + self.norm3 = nn.RMSNorm(d_model) + self.dropout1 = nn.Dropout(dropout) + self.dropout2 = nn.Dropout(dropout) + self.dropout3 = nn.Dropout(dropout) + + @staticmethod + def with_pos_embed(tensor, pos: Optional[Tensor]): + return tensor if pos is None else tensor + pos + + def forward(self, tgt, memory, + tgt_mask: Optional[Tensor] = None, + memory_mask: Optional[Tensor] = None, + tgt_key_padding_mask: Optional[Tensor] = None, + memory_key_padding_mask: Optional[Tensor] = None, + pos: Optional[Tensor] = None, + query_pos: Optional[Tensor] = None): + skip = tgt + tgt2 = self.norm1(tgt) + tgt = skip + self.dropout1( + self.self_attn(tgt2, pos=query_pos, attn_mask=tgt_mask, + key_padding_mask=tgt_key_padding_mask) + ) + + skip = tgt + tgt2 = self.norm2(tgt) + tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt2, query_pos), + key=self.with_pos_embed(memory, pos), + value=memory, attn_mask=memory_mask, + key_padding_mask=memory_key_padding_mask)[0] + tgt = skip + self.dropout2(tgt2) + + skip = tgt + tgt2 = self.norm3(tgt) + gate, value = self.linear1(tgt2).chunk(2, dim=-1) + tgt2 = self.linear2(self.dropout(F.silu(gate) * value)) + tgt = skip + self.dropout3(tgt2) + return tgt + + +def _get_clones(module, N): + return nn.ModuleList([copy.deepcopy(module) for i in range(N)]) + + +def build_transformer(args): + return Transformer( + d_model=args.hidden_dim, + dropout=args.dropout, + nhead=args.nheads, + dim_feedforward=args.dim_feedforward, + num_encoder_layers=args.enc_layers, + num_decoder_layers=args.dec_layers, + normalize_before=args.pre_norm, + return_intermediate_dec=True, + use_xsa=getattr(args, "use_xsa", False), + ) + + +def _get_activation_fn(activation): + """Return an activation function given a string""" + if activation == "relu": + return F.relu + if activation == "gelu": + return F.gelu + if activation == "glu": + return F.glu + raise RuntimeError(F"activation should be relu/gelu, not {activation}.") diff --git a/demo/act/detr/utils.py b/demo/act/detr/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..9aa4749ac5f4bba9bb6ddf476ac4fa6519ee821a --- /dev/null +++ b/demo/act/detr/utils.py @@ -0,0 +1,161 @@ +from torch.utils.data.sampler import Sampler +import numpy as np +import torch +import torch.distributed as dist +from torch import Tensor +from h5py import File, Group, Dataset +from typing import Optional + + +class NestedTensor(object): + def __init__(self, tensors, mask: Optional[Tensor]): + self.tensors = tensors + self.mask = mask + + def to(self, device): + # type: (Device) -> NestedTensor # noqa + cast_tensor = self.tensors.to(device) + mask = self.mask + if mask is not None: + assert mask is not None + cast_mask = mask.to(device) + else: + cast_mask = None + return NestedTensor(cast_tensor, cast_mask) + + def decompose(self): + return self.tensors, self.mask + + def __repr__(self): + return str(self.tensors) + +def is_dist_avail_and_initialized(): + if not dist.is_available(): + return False + if not dist.is_initialized(): + return False + return True + +def get_rank(): + if not is_dist_avail_and_initialized(): + return 0 + return dist.get_rank() + +def is_main_process(): + return get_rank() == 0 + + +class IterationBasedBatchSampler(Sampler): + """Wraps a BatchSampler. + Resampling from it until a specified number of iterations have been sampled + References: + https://github.com/facebookresearch/maskrcnn-benchmark/blob/master/maskrcnn_benchmark/data/samplers/iteration_based_batch_sampler.py + """ + + def __init__(self, batch_sampler, num_iterations, start_iter=0): + self.batch_sampler = batch_sampler + self.num_iterations = num_iterations + self.start_iter = start_iter + + def __iter__(self): + iteration = self.start_iter + while iteration < self.num_iterations: + # if the underlying sampler has a set_epoch method, like + # DistributedSampler, used for making each process see + # a different split of the dataset, then set it + if hasattr(self.batch_sampler.sampler, "set_epoch"): + self.batch_sampler.sampler.set_epoch(iteration) + for batch in self.batch_sampler: + yield batch + iteration += 1 + if iteration >= self.num_iterations: + break + + def __len__(self): + return self.num_iterations - self.start_iter + + +def worker_init_fn(worker_id, base_seed=None): + """The function is designed for pytorch multi-process dataloader. + Note that we use the pytorch random generator to generate a base_seed. + Please try to be consistent. + References: + https://pytorch.org/docs/stable/notes/faq.html#dataloader-workers-random-seed + """ + if base_seed is None: + base_seed = torch.IntTensor(1).random_().item() + # print(worker_id, base_seed) + np.random.seed(base_seed + worker_id) + +TARGET_KEY_TO_SOURCE_KEY = { + 'states': 'env_states', + 'observations': 'obs', + 'success': 'success', + 'next_observations': 'obs', + # 'dones': 'dones', + # 'rewards': 'rewards', + 'actions': 'actions', +} +def load_content_from_h5_file(file): + if isinstance(file, (File, Group)): + return {key: load_content_from_h5_file(file[key]) for key in list(file.keys())} + elif isinstance(file, Dataset): + return file[()] + else: + raise NotImplementedError(f"Unspported h5 file type: {type(file)}") + +def load_hdf5(path, ): + print('Loading HDF5 file', path) + file = File(path, 'r') + ret = load_content_from_h5_file(file) + file.close() + print('Loaded') + return ret + +def load_traj_hdf5(path, num_traj=None): + print('Loading HDF5 file', path) + file = File(path, 'r') + keys = list(file.keys()) + if num_traj is not None: + assert num_traj <= len(keys), f"num_traj: {num_traj} > len(keys): {len(keys)}" + keys = sorted(keys, key=lambda x: int(x.split('_')[-1])) + keys = keys[:num_traj] + ret = { + key: load_content_from_h5_file(file[key]) for key in keys + } + file.close() + print('Loaded') + return ret +def load_demo_dataset(path, keys=['observations', 'actions'], num_traj=None, concat=True): + # assert num_traj is None + raw_data = load_traj_hdf5(path, num_traj) + # raw_data has keys like: ['traj_0', 'traj_1', ...] + # raw_data['traj_0'] has keys like: ['actions', 'dones', 'env_states', 'infos', ...] + _traj = raw_data['traj_0'] + for key in keys: + source_key = TARGET_KEY_TO_SOURCE_KEY[key] + assert source_key in _traj, f"key: {source_key} not in traj_0: {_traj.keys()}" + dataset = {} + for target_key in keys: + # if 'next' in target_key: + # raise NotImplementedError('Please carefully deal with the length of trajectory') + source_key = TARGET_KEY_TO_SOURCE_KEY[target_key] + dataset[target_key] = [ raw_data[idx][source_key] for idx in raw_data ] + if isinstance(dataset[target_key][0], np.ndarray) and concat: + if target_key in ['observations', 'states'] and \ + len(dataset[target_key][0]) > len(raw_data['traj_0']['actions']): + dataset[target_key] = np.concatenate([ + t[:-1] for t in dataset[target_key] + ], axis=0) + elif target_key in ['next_observations', 'next_states'] and \ + len(dataset[target_key][0]) > len(raw_data['traj_0']['actions']): + dataset[target_key] = np.concatenate([ + t[1:] for t in dataset[target_key] + ], axis=0) + else: + dataset[target_key] = np.concatenate(dataset[target_key], axis=0) + + print('Load', target_key, dataset[target_key].shape) + else: + print('Load', target_key, len(dataset[target_key]), type(dataset[target_key][0])) + return dataset \ No newline at end of file diff --git a/scripts/act/baseline.sh b/scripts/act/baseline.sh new file mode 100644 index 0000000000000000000000000000000000000000..892fe57229590f5e51a9f86310151bcb3c002c38 --- /dev/null +++ b/scripts/act/baseline.sh @@ -0,0 +1,27 @@ +seed=1 +SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" +demo_path="$SCRIPT_DIR/../../datasets/atec_task_e/trajectory_filtered.hdf5" + +echo "$demo_path" +total_iters=100000 +batch_size=256 +log_freq=1000 +save_freq=10000 +wandb_entity="" + + +# RGB based +for demos in 100; do + python train_task_e.py \ + --demo_path $demo_path \ + --num_demos $demos \ + --include_rgb \ + --total_iters $total_iters \ + --batch_size $batch_size \ + --log_freq $log_freq \ + --save_freq $save_freq \ + --seed $seed \ + --exp_name act-task-e-rgb-${demos}demos-seed${seed} \ + --wandb_entity $wandb_entity \ + --track +done \ No newline at end of file diff --git a/scripts/act/cli_args.py b/scripts/act/cli_args.py new file mode 100644 index 0000000000000000000000000000000000000000..0ed085155c8b99cdb0f0c487c804290f76cb2c6b --- /dev/null +++ b/scripts/act/cli_args.py @@ -0,0 +1,48 @@ +"""CLI argument definitions for Task E demo collection. +""" + + +def add_collect_demo_args(parser) -> None: + parser.add_argument( + "--num_demos", type=int, default=50, + help="Number of successful demos to collect.", + ) + parser.add_argument( + "--output_dir", type=str, default="./datasets/atec_task_e", + help="Directory to save trajectory.hdf5 and trajectory.json.", + ) + parser.add_argument( + "--pick_objects", type=int, nargs="+", default=[3, 2, 1], + metavar="N", + help="Which objects to pick, in execution order. Default clears near-to-far: 3 2 1.", + ) + parser.add_argument( + "--save_video", action="store_true", default=False, + help="Save an MP4 per demo for visualization " + "(requires: pip install imageio imageio-ffmpeg).", + ) + parser.add_argument( + "--video_dir", type=str, default=None, + help="Output directory for MP4 files. Defaults to /videos/.", + ) + parser.add_argument( + "--save_images", action="store_true", default=False, + help="Save raw RGB frames into HDF5 under traj_N/images/rgb (T,H,W,3) " + "for ACT RGBD training. Shares the camera with --save_video.", + ) + parser.add_argument( + "--only_success", action="store_true", default=False, + help="Discard demos where not all picked objects ended up in the basket.", + ) + parser.add_argument( + "--max_attempts", type=int, default=0, + help="Stop after this many attempts even if num_demos is not reached. 0 means unlimited.", + ) + parser.add_argument( + "--trace", action="store_true", default=False, + help="Print compact grasp/basket diagnostics for failed scripted demos.", + ) + parser.add_argument( + "--abort_failed_lift", action="store_true", default=False, + help="Abort an attempt as soon as the current object fails the post-LIFT height gate.", + ) diff --git a/scripts/act/collect_demos_task_e.py b/scripts/act/collect_demos_task_e.py new file mode 100644 index 0000000000000000000000000000000000000000..dc66c10368340cfa8f24c63a14cc94a92f93e14e --- /dev/null +++ b/scripts/act/collect_demos_task_e.py @@ -0,0 +1,229 @@ +"""Scripted oracle data collection for Task E (pick-and-place). + +Usage +----- +# NOTE: only for object 3 now, if you want to pick objects 1 and 2, please modify the distance accordingly. +python scripts/act/collect_demos_task_e.py --pick_objects 3 --num_demos 50 --headless + +""" + +import argparse +import os +import sys + +# sys.path.insert(0, os.path.dirname(__file__)) + +from isaaclab.app import AppLauncher +from cli_args import add_collect_demo_args + +parser = argparse.ArgumentParser(description="Collect Task E demonstrations for ACT.") +add_collect_demo_args(parser) +AppLauncher.add_app_launcher_args(parser) +args_cli = parser.parse_args() + +if args_cli.save_video or args_cli.save_images: + args_cli.enable_cameras = True + +app_launcher = AppLauncher(args_cli) +simulation_app = app_launcher.app + +import h5py +import json +import numpy as np + +from isaaclab.actuators import ImplicitActuatorCfg +from isaaclab.envs import ManagerBasedRLEnv +from isaaclab.sensors import CameraCfg +import isaaclab.sim as sim_utils + +from atec_rl_lab.tasks.task_e.env_cfg import TaskEEnvPiperCfg +from atec_rl_lab.utils import CartesianController + +from task_e.config import ( + EE_BODY_NAME, ARM_JOINT_NAMES, GRIPPER_JOINT_NAMES, + ACT_STIFFNESS, ACT_DAMPING, ACT_EFFORT_LIMIT, ACT_VEL_LIMIT, + CAM_H, CAM_W, CAM_POS, CAM_ROT, +) +from task_e.collector import basket_status_lines, check_objects_in_basket, collect_one_demo + + +def _trace_lines(data: dict | None, pick_objects: list[int]) -> list[str]: + if data is None or "trace" not in data: + return [] + lines = [] + for obj_idx in pick_objects: + tr = data["trace"].get(f"object_{obj_idx}", {}) + if not tr: + continue + states = tr.get("states", {}) + close = states.get("CLOSE", {}) + lift = states.get("LIFT", {}) + transport = states.get("TRANSPORT", {}) + def _vec(value): + if value is None: + return "none" + return "(" + ",".join(f"{float(v):+.3f}" for v in value[:3]) + ")" + lines.append( + f"object_{obj_idx}: z_gain={float(tr.get('z_gain', 0.0)):.3f} " + f"lifted={tr.get('lifted')} reward_lifted={tr.get('reward_lifted')} " + f"gap_close={float(close.get('min_gripper_gap', 999.0)):.3f} " + f"finger_close={float(close.get('min_finger_center_dist', 999.0)):.3f} " + f"finger_vec_close={_vec(close.get('min_finger_center_vec'))} " + f"gap_lift={float(lift.get('min_gripper_gap', 999.0)):.3f} " + f"finger_gap={float(lift.get('min_finger_body_gap', 999.0)):.3f} " + f"finger_lift={float(lift.get('min_finger_center_dist', 999.0)):.3f} " + f"finger_vec_lift={_vec(lift.get('min_finger_center_vec'))} " + f"finger_transport={float(transport.get('min_finger_center_dist', 999.0)):.3f} " + f"ee_vec_lift={_vec(lift.get('min_ee_vec'))} " + f"basket_inside={tr.get('basket_inside')}" + ) + return lines + + +def build_env(pick_objects: list[int], need_camera: bool) -> ManagerBasedRLEnv: + import time + cfg = TaskEEnvPiperCfg() + cfg.seed = int(time.time_ns() % (2**31)) # random seed each call + cfg.scene.num_envs = 1 + cfg.episode_length_s = 80.0 * len(pick_objects) + 30.0 + if not need_camera: + cfg.scene.video_cam = None + cfg.scene.ee_camera = None + cfg.scene.ee_dual_camera = None + cfg.scene.head_camera = None + cfg.observations.image = None + cfg.scene.robot.actuators["default"] = ImplicitActuatorCfg( + joint_names_expr=[".*"], + effort_limit=ACT_EFFORT_LIMIT, + velocity_limit=ACT_VEL_LIMIT, + stiffness=ACT_STIFFNESS, + damping=ACT_DAMPING, + ) + # if need_camera: + # cfg.scene.video_cam = CameraCfg( + # prim_path="{ENV_REGEX_NS}/video_cam", + # update_period=0.0, + # height=CAM_H, width=CAM_W, + # data_types=["rgb"], + # spawn=sim_utils.PinholeCameraCfg( + # focal_length=24.0, focus_distance=400.0, + # horizontal_aperture=20.955, clipping_range=(0.1, 100.0), + # ), + # offset=CameraCfg.OffsetCfg(pos=CAM_POS, rot=CAM_ROT, convention="world"), + # ) + return ManagerBasedRLEnv(cfg) + + +def init_output(output_dir: str) -> tuple[str, str]: + """Create output directory, wipe any existing trajectory.hdf5, write JSON metadata.""" + os.makedirs(output_dir, exist_ok=True) + traj_path = os.path.join(output_dir, "trajectory.hdf5") + json_path = os.path.join(output_dir, "trajectory.json") + with h5py.File(traj_path, "w"): # truncate / create fresh + pass + with open(json_path, "w") as fh: + json.dump({"env_info": {"env_kwargs": {"control_mode": "pd_joint_pos"}}}, fh) + return traj_path, json_path + + +def save_traj(traj_path: str, traj_idx: int, data: dict, + save_images: bool) -> None: + """Append one trajectory group to the consolidated HDF5.""" + with h5py.File(traj_path, "a") as f: + grp = f.create_group(f"traj_{traj_idx}") + grp.create_dataset("obs", data=data["qpos"], compression="gzip") + grp.create_dataset("actions", data=data["action"], compression="gzip") + grp.create_dataset("qvel", data=data["qvel"], compression="gzip") + grp.create_dataset("ee_pos", data=data["ee_pos"], compression="gzip") + grp.create_dataset("ee_quat", data=data["ee_quat"], compression="gzip") + if save_images and "frames" in data: + grp.create_group("images").create_dataset( + "rgb", data=data["frames"], compression="gzip" + ) + + +def main() -> None: + pick_objects = list(dict.fromkeys(args_cli.pick_objects)) + need_camera = args_cli.save_video or args_cli.save_images + + env = build_env(pick_objects, need_camera) + dev = env.unwrapped.device + camera = env.unwrapped.scene["video_cam"] if need_camera else None + + robot = env.unwrapped.scene.articulations["robot"] + arm_ids, _ = robot.find_joints(ARM_JOINT_NAMES) + gripper_ids, _ = robot.find_joints(GRIPPER_JOINT_NAMES) + ik_ctrl = CartesianController( + robot=robot, ee_body_name=EE_BODY_NAME, + arm_joint_names=ARM_JOINT_NAMES, + num_envs=1, device=dev, + command_type="pose", + lambda_val=0.05, + max_joint_delta=0.2, + ) + default_jpos = robot.data.default_joint_pos.clone() + + video_dir = None + imageio = None + if args_cli.save_video: + video_dir = args_cli.video_dir or os.path.join(args_cli.output_dir, "videos") + os.makedirs(video_dir, exist_ok=True) + import imageio as _io + imageio = _io + + traj_path, _ = init_output(args_cli.output_dir) + rng = np.random.default_rng() # unseeded → different positions every run + + n_ok = 0 + attempt = 0 + while n_ok < args_cli.num_demos: + attempt += 1 + if args_cli.max_attempts and attempt > args_cli.max_attempts: + print(f"\n[WARN] Reached --max_attempts={args_cli.max_attempts}; collected {n_ok} demos.") + break + print(f"\n[INFO] Demo {n_ok + 1}/{args_cli.num_demos} (attempt {attempt})") + + data = collect_one_demo( + env, robot, ik_ctrl, + arm_ids, gripper_ids, + pick_objects, dev, + default_jpos=default_jpos, + rng=rng, + camera=camera, + trace=args_cli.trace, + abort_failed_lift=args_cli.abort_failed_lift, + ) + if data is None: + print("[WARN] Early termination — skipping.") + continue + + if args_cli.only_success and not check_objects_in_basket(env, pick_objects): + print("[WARN] Objects not in basket — skipping (--only_success).") + for line in basket_status_lines(env, pick_objects): + print(f"[WARN] {line}") + for line in _trace_lines(data, pick_objects): + print(f"[TRACE] {line}") + continue + + for line in _trace_lines(data, pick_objects): + print(f"[TRACE] {line}") + save_traj(traj_path, n_ok, data, args_cli.save_images) + + T = len(data["qpos"]) + notes = [f"{T} steps"] + if args_cli.save_video and "frames" in data: + vp = os.path.join(video_dir, f"demo_{n_ok:04d}.mp4") + imageio.mimwrite(vp, data["frames"], fps=50, quality=7) + notes.append(f"video → {vp}") + if args_cli.save_images and "frames" in data: + notes.append("images saved") + print(f"[INFO] traj_{n_ok}: {', '.join(notes)}") + n_ok += 1 + + print(f"\n[INFO] Collected {n_ok} demos → {traj_path}") + env.close() + + +if __name__ == "__main__": + main() + simulation_app.close() diff --git a/scripts/act/eval_task_e_act.py b/scripts/act/eval_task_e_act.py new file mode 100644 index 0000000000000000000000000000000000000000..720bbbfe97d0e1d52450f781e91d7003c543fed8 --- /dev/null +++ b/scripts/act/eval_task_e_act.py @@ -0,0 +1,191 @@ +"""Rollout evaluation for the Task-E ACT policy checkpoint.""" + +import argparse +import os +import sys +import time +from datetime import datetime + +from isaaclab.app import AppLauncher + + +parser = argparse.ArgumentParser(description="Evaluate ACT checkpoint on ATEC Task E.") +parser.add_argument( + "--checkpoint", + type=str, + default="runs/act-task-e-rgb-100demos-seed1/checkpoints/best_loss.pt", + help="ACT checkpoint path.", +) +parser.add_argument("--task", type=str, default="ATEC-TaskE-Piper") +parser.add_argument("--episodes", type=int, default=3) +parser.add_argument("--max_steps", type=int, default=1500) +parser.add_argument("--video_path", type=str, default=None, help="Optional MP4 output path for episode 1.") +parser.add_argument("--video_interval", type=int, default=2, help="Record every N env steps.") +parser.add_argument("--video_fps", type=int, default=25) +parser.add_argument("--seed", type=int, default=None) +parser.add_argument("--disable_fabric", action="store_true", default=False) +parser.add_argument("--debug", action="store_true", default=False) +parser.add_argument( + "--solution_module", + type=str, + default="solution_act", + help="Module under demo/ that provides AlgSolution, e.g. solution_act or solution_pca.", +) +AppLauncher.add_app_launcher_args(parser) +args_cli = parser.parse_args() +args_cli.enable_cameras = True + +repo_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..")) +checkpoint = os.path.abspath(args_cli.checkpoint) +os.environ["ATEC_ACT_POLICY_PATH"] = checkpoint + +app_launcher = AppLauncher(args_cli) +simulation_app = app_launcher.app + +import gymnasium as gym # noqa: E402 +import torch # noqa: E402 + +from isaaclab.envs import DirectMARLEnv, multi_agent_to_single_agent # noqa: E402 +from isaaclab_tasks.utils import parse_env_cfg # noqa: E402 + +import atec_rl_lab.tasks # noqa: F401, E402 + +demo_dir = os.path.join(repo_root, "demo") +if repo_root not in sys.path: + sys.path.insert(0, repo_root) +if demo_dir not in sys.path: + sys.path.insert(0, demo_dir) +from scripts.act.task_e.collector import basket_status_lines # noqa: E402 +import importlib # noqa: E402 + +AlgSolution = importlib.import_module(args_cli.solution_module).AlgSolution + + +def _frame_from_obs(obs) -> object: + rgb = obs["image"]["video_rgb"] + if isinstance(rgb, torch.Tensor): + frame = rgb[0].detach().cpu() + if frame.ndim == 3 and frame.shape[0] in (3, 4): + frame = frame.permute(1, 2, 0) + if frame.shape[-1] == 4: + frame = frame[..., :3] + if frame.dtype != torch.uint8: + frame = (frame.float() * 255.0).clamp(0, 255).to(torch.uint8) + return frame.numpy() + return rgb[0] + + +def _resolve_video_path() -> str | None: + if args_cli.video_path is None: + return None + if args_cli.video_path: + return os.path.abspath(args_cli.video_path) + stamp = datetime.now().strftime("%Y%m%d_%H%M%S") + return os.path.join(repo_root, "logs", "videos", "task_e_act_eval", f"eval_{stamp}.mp4") + + +def evaluate() -> list[dict[str, float]]: + if not os.path.exists(checkpoint): + raise FileNotFoundError(f"Checkpoint not found: {checkpoint}") + + env_cfg = parse_env_cfg( + args_cli.task, + device=args_cli.device, + num_envs=1, + use_fabric=not args_cli.disable_fabric, + ) + if args_cli.seed is not None: + env_cfg.seed = args_cli.seed + env = gym.make(args_cli.task, cfg=env_cfg) + if isinstance(env.unwrapped, DirectMARLEnv): + env = multi_agent_to_single_agent(env) + + policy = AlgSolution() + video_path = _resolve_video_path() + writer = None + if video_path is not None: + import imageio.v2 as imageio + + os.makedirs(os.path.dirname(video_path), exist_ok=True) + writer = imageio.get_writer(video_path, fps=args_cli.video_fps, quality=7) + print(f"[INFO] Recording episode 1 video to: {video_path}") + + results = [] + try: + for episode in range(args_cli.episodes): + reset_kwargs = {"seed": args_cli.seed + episode} if args_cli.seed is not None else {} + obs, _ = env.reset(**reset_kwargs) + policy.reset_episode() + total_reward = 0.0 + elapsed_time = 0.0 + steps = 0 + done = False + start_wall = time.time() + if writer is not None and episode == 0: + writer.append_data(_frame_from_obs(obs)) + + while simulation_app.is_running() and steps < args_cli.max_steps: + with torch.inference_mode(): + resp = policy.predicts(obs, total_reward) + if resp["giveup"]: + break + action = torch.as_tensor(resp["action"], dtype=torch.float32, device=args_cli.device).view(1, -1) + obs, reward, terminated, truncated, info = env.step(action) + + sim_dt = info["Step_dt"] + total_reward += reward.mean().item() / sim_dt if isinstance(reward, torch.Tensor) else float(reward) / sim_dt + if isinstance(info, dict) and "Elapsed_Time" in info: + elapsed = info["Elapsed_Time"] + elapsed_time = elapsed.item() if hasattr(elapsed, "item") else float(elapsed) + else: + elapsed_time += env.unwrapped.step_dt + + done = bool(terminated.item() or truncated.item()) + steps += 1 + if writer is not None and episode == 0 and steps % max(1, args_cli.video_interval) == 0: + writer.append_data(_frame_from_obs(obs)) + if args_cli.debug and steps % 100 == 0: + print(f"[DEBUG] episode={episode + 1} step={steps} score={total_reward:.2f}") + if done: + break + + result = { + "episode": episode + 1, + "score": float(total_reward), + "elapsed_time": float(elapsed_time), + "steps": float(steps), + "done": float(done), + "wall_time": time.time() - start_wall, + } + results.append(result) + try: + for line in basket_status_lines(env, [1, 2, 3]): + print(f"[BASKET] episode={episode + 1} {line}") + except Exception as exc: + if args_cli.debug: + print(f"[DEBUG] basket status unavailable: {exc}") + print( + "[RESULT] " + f"episode={result['episode']:.0f} " + f"score={result['score']:.2f} " + f"elapsed_time={result['elapsed_time']:.2f} " + f"steps={result['steps']:.0f} " + f"done={bool(result['done'])} " + f"wall_time={result['wall_time']:.1f}s" + ) + finally: + if writer is not None: + writer.close() + env.close() + + return results + + +if __name__ == "__main__": + try: + results = evaluate() + if results: + scores = torch.tensor([r["score"] for r in results], dtype=torch.float32) + print(f"[SUMMARY] episodes={len(results)} mean_score={scores.mean().item():.2f} best_score={scores.max().item():.2f}") + finally: + simulation_app.close() diff --git a/scripts/act/filter_demos.py b/scripts/act/filter_demos.py new file mode 100644 index 0000000000000000000000000000000000000000..39a24953207ff32186345e6f00431eba96f02e8f --- /dev/null +++ b/scripts/act/filter_demos.py @@ -0,0 +1,99 @@ +"""Filter HDF5 trajectory data: remove timesteps where the robot is not moving. + +Uses consecutive action differences: steps where max|action[t] - action[t-1]| < threshold +are considered stationary and removed. + +Usage: + python scripts/act/filter_demos.py \ + --input datasets/atec_task_e/trajectory.hdf5 \ + --output datasets/atec_task_e/trajectory_filtered.hdf5 \ + --threshold 0.001 +""" + +import argparse +import h5py +import numpy as np + + +def compute_moving_mask(actions, threshold): + """Return a boolean mask (length T) marking steps where the robot is moving. + + A step is 'moving' if max|action[t] - action[t-1]| >= threshold. + """ + delta = np.zeros_like(actions) + delta[1:] = np.abs(actions[1:] - actions[:-1]) + return delta.max(axis=1) >= threshold + + +def main(): + parser = argparse.ArgumentParser(description="Filter stationary steps from demo HDF5.") + parser.add_argument("--input", type=str, required=True, help="Input HDF5 path") + parser.add_argument("--output", type=str, required=True, help="Output HDF5 path") + parser.add_argument("--threshold", type=float, default=0.001, + help="Steps with max|action_delta| < threshold are removed (default: 0.001)") + parser.add_argument("--dry_run", action="store_true", + help="Only print statistics, don't write output") + args = parser.parse_args() + + total_before = 0 + total_after = 0 + + with h5py.File(args.input, "r") as fin: + traj_keys = sorted(fin.keys(), key=lambda k: int(k.split("_")[1])) + + if args.dry_run: + print(f"{'traj':>10s} {'before':>7s} {'after':>7s} {'removed':>7s} {'removed%':>8s}") + for key in traj_keys: + actions = fin[key]["actions"][:] + mask = compute_moving_mask(actions, args.threshold) + n_before = len(actions) + n_after = mask.sum() + total_before += n_before + total_after += n_after + print(f"{key:>10s} {n_before:7d} {n_after:7d} " + f"{n_before - n_after:7d} {(1 - n_after/n_before)*100:7.1f}%") + print(f"\nTotal: {total_before} → {total_after} " + f"(removed {total_before - total_after}, " + f"{(1 - total_after/total_before)*100:.1f}%)") + return + + with h5py.File(args.output, "w") as fout: + for key in traj_keys: + grp_in = fin[key] + actions = grp_in["actions"][:] + mask = compute_moving_mask(actions, args.threshold) + + n_before = len(actions) + n_after = mask.sum() + total_before += n_before + total_after += n_after + + grp_out = fout.create_group(key) + + # Filter all (T, ...) datasets with the same mask + for ds_name in grp_in.keys(): + if ds_name == "images": + # Handle nested image group + img_grp = grp_out.create_group("images") + for img_key in grp_in["images"].keys(): + data = grp_in[f"images/{img_key}"][:] + img_grp.create_dataset(img_key, data=data[mask], compression="gzip") + elif isinstance(grp_in[ds_name], h5py.Dataset): + data = grp_in[ds_name][:] + if data.shape[0] == n_before: + grp_out.create_dataset(ds_name, data=data[mask], compression="gzip") + else: + # Non-temporal dataset, copy as-is + grp_out.create_dataset(ds_name, data=data, compression="gzip") + + print(f" {key}: {n_before} → {n_after} steps " + f"(removed {n_before - n_after})") + + print(f"\nTotal: {total_before} → {total_after} " + f"(removed {total_before - total_after}, " + f"{(1 - total_after/total_before)*100:.1f}%)") + print(f"Saved to: {args.output}") + + +if __name__ == "__main__": + main() diff --git a/scripts/act/run_task_e_pipeline.sh b/scripts/act/run_task_e_pipeline.sh new file mode 100644 index 0000000000000000000000000000000000000000..f09fa553326290515fabbbde846304726a8e692c --- /dev/null +++ b/scripts/act/run_task_e_pipeline.sh @@ -0,0 +1,83 @@ +#!/usr/bin/env bash +set -euo pipefail + +ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)" +PYTHON="${PYTHON:-/home/ubuntu/envs/genmanip-isaac5-py311/bin/python}" +ISAACLAB_SITE="/home/ubuntu/envs/genmanip-isaac5-py311/lib/python3.11/site-packages/isaaclab/source" + +export OMNI_KIT_ACCEPT_EULA=YES +export PYTHONUNBUFFERED=1 +export CUDA_VISIBLE_DEVICES="${CUDA_VISIBLE_DEVICES:-0}" +export PYTHONPATH="${ISAACLAB_SITE}/isaaclab:${ISAACLAB_SITE}/isaaclab_tasks:${ISAACLAB_SITE}/isaaclab_assets:${ISAACLAB_SITE}/isaaclab_rl:${ISAACLAB_SITE}/isaaclab_mimic:${ROOT_DIR}/source/atec_rl_lab:${ROOT_DIR}/scripts/act:${PYTHONPATH:-}" + +cd "$ROOT_DIR" + +DATA_DIR="${DATA_DIR:-datasets/atec_task_e}" +NUM_DEMOS="${NUM_DEMOS:-100}" +PICK_OBJECTS="${PICK_OBJECTS:-3 2 1}" +read -r -a PICK_OBJECTS_ARGS <<< "$PICK_OBJECTS" +MAX_ATTEMPTS="${MAX_ATTEMPTS:-0}" +TOTAL_ITERS="${TOTAL_ITERS:-100000}" +BATCH_SIZE="${BATCH_SIZE:-512}" +SEED="${SEED:-1}" +LOG_FREQ="${LOG_FREQ:-100}" +SAVE_FREQ="${SAVE_FREQ:-5000}" +RUN_NAME="${RUN_NAME:-act-task-e-rgb-${NUM_DEMOS}demos-seed${SEED}}" +RESUME_CHECKPOINT="${RESUME_CHECKPOINT:-}" +RESUME_ITER="${RESUME_ITER:-}" + +RAW_DATA="${DATA_DIR}/trajectory.hdf5" +FILTERED_DATA="${DATA_DIR}/trajectory_filtered.hdf5" + +mkdir -p "$DATA_DIR" logs + +echo "[ATEC Task E] root: $ROOT_DIR" +echo "[ATEC Task E] python: $PYTHON" +echo "[ATEC Task E] data: $DATA_DIR" +echo "[ATEC Task E] demos: $NUM_DEMOS, pick_objects: ${PICK_OBJECTS_ARGS[*]}, batch: $BATCH_SIZE, iters: $TOTAL_ITERS" + +if [[ ! -f "$RAW_DATA" ]]; then + "$PYTHON" -u scripts/act/collect_demos_task_e.py \ + --pick_objects "${PICK_OBJECTS_ARGS[@]}" \ + --num_demos "$NUM_DEMOS" \ + --headless \ + --enable_cameras \ + --save_images \ + --only_success \ + --trace \ + --abort_failed_lift \ + --max_attempts "$MAX_ATTEMPTS" \ + --output_dir "$DATA_DIR" +else + echo "[ATEC Task E] Found $RAW_DATA, skip collection." +fi + +if [[ ! -f "$FILTERED_DATA" ]]; then + "$PYTHON" -u scripts/act/filter_demos.py \ + --input "$RAW_DATA" \ + --output "$FILTERED_DATA" \ + --threshold 0.001 +else + echo "[ATEC Task E] Found $FILTERED_DATA, skip filtering." +fi + +TRAIN_ARGS=( + --demo_path "$FILTERED_DATA" + --num_demos "$NUM_DEMOS" + --include_rgb + --total_iters "$TOTAL_ITERS" + --batch_size "$BATCH_SIZE" + --log_freq "$LOG_FREQ" + --save_freq "$SAVE_FREQ" + --seed "$SEED" + --exp_name "$RUN_NAME" +) + +if [[ -n "$RESUME_CHECKPOINT" ]]; then + TRAIN_ARGS+=(--resume_checkpoint "$RESUME_CHECKPOINT") +fi +if [[ -n "$RESUME_ITER" ]]; then + TRAIN_ARGS+=(--resume_iter "$RESUME_ITER") +fi + +"$PYTHON" -u scripts/act/train_task_e.py "${TRAIN_ARGS[@]}" diff --git a/scripts/act/search_task_e_grasps.py b/scripts/act/search_task_e_grasps.py new file mode 100644 index 0000000000000000000000000000000000000000..d7d48fb087f2ec29d756bbf896cf69c9b7202309 --- /dev/null +++ b/scripts/act/search_task_e_grasps.py @@ -0,0 +1,761 @@ +"""Search per-object scripted grasp parameters for Task E. + +This is a fast physics-only diagnostic: it disables cameras, runs candidate +grasp offsets/heights/yaw corrections in one Isaac process, and reports the +first successful candidates. +""" + +import argparse +import math +import os + +from isaaclab.app import AppLauncher + + +parser = argparse.ArgumentParser(description="Search Task-E grasp candidates.") +parser.add_argument("--objects", type=int, nargs="+", default=[1, 2]) +parser.add_argument("--trials", type=int, default=1) +parser.add_argument("--max_candidates", type=int, default=40) +parser.add_argument("--start_candidate", type=int, default=1, + help="1-based candidate index to start from; useful for resuming long searches.") +parser.add_argument("--max_joint_delta", type=float, default=0.2, + help="Per-step IK joint target limit. Lower values make contact pushes gentler.") +AppLauncher.add_app_launcher_args(parser) +args_cli = parser.parse_args() + +app_launcher = AppLauncher(args_cli) +simulation_app = app_launcher.app + +import numpy as np +import torch +from isaaclab.actuators import ImplicitActuatorCfg +from isaaclab.envs import ManagerBasedRLEnv + +from atec_rl_lab.tasks.task_e.env_cfg import TaskEEnvPiperCfg +from atec_rl_lab.utils import CartesianController + +from task_e import config as grasp_cfg +from task_e.collector import ( + basket_status_lines, + check_objects_in_basket, + collect_one_demo, +) +from task_e.config import ( + ACT_DAMPING, + ACT_EFFORT_LIMIT, + ACT_STIFFNESS, + ACT_VEL_LIMIT, + ARM_JOINT_NAMES, + EE_BODY_NAME, + GRIPPER_JOINT_NAMES, + STEPS, +) + +BASE_STATE_STEP_OVERRIDES = { + obj_idx: steps.copy() + for obj_idx, steps in grasp_cfg.OBJ_STATE_STEP_OVERRIDES.items() +} + + +def _candidate_dict( + dx: float, + dy: float, + z: float, + carry_z: float, + target_x: float, + target_y: float, + transport_gripper: str, + yaw: float, + push_y: float | None = None, + *, + push_x: float = 0.0, + push_z: float = 0.0, + transport_steps: int | None = None, + place_steps: int | None = None, + open_steps: int | None = None, + close_steps: int | None = None, + lift_steps: int | None = None, + close_z: float | None = None, + finger_target_z: float | None = None, + finger_max_z: float | None = None, + mode: str = "pick", + push_x_gain: float | None = None, + push_max_x: float | None = None, + push_min_behind: float | None = None, +) -> dict[str, float]: + return { + "mode": mode, + "dx": dx, + "dy": dy, + "z": z, + "carry_z": carry_z, + "place_z": min(carry_z, grasp_cfg.TABLE_TOP_Z + 0.15), + "target_x": target_x, + "target_y": target_y, + "transport_gripper": transport_gripper, + "yaw": yaw, + "push_x": push_x, + "push_y": push_y, + "push_z": push_z, + "transport_steps": transport_steps, + "place_steps": place_steps, + "open_steps": open_steps, + "close_steps": close_steps, + "lift_steps": lift_steps, + "close_z": close_z, + "finger_target_z": finger_target_z, + "finger_max_z": finger_max_z, + "push_x_gain": push_x_gain, + "push_max_x": push_max_x, + "push_min_behind": push_min_behind, + } + + +def _normalize_candidate(item: tuple | dict) -> dict[str, float]: + if isinstance(item, dict): + cand = item.copy() + cand.setdefault("mode", "pick") + cand.setdefault("place_z", min(cand["carry_z"], grasp_cfg.TABLE_TOP_Z + 0.15)) + cand.setdefault("push_x", 0.0) + cand.setdefault("push_y", None) + cand.setdefault("push_z", 0.0) + cand.setdefault("transport_steps", None) + cand.setdefault("place_steps", None) + cand.setdefault("open_steps", None) + cand.setdefault("close_steps", None) + cand.setdefault("lift_steps", None) + cand.setdefault("close_z", None) + cand.setdefault("finger_target_z", None) + cand.setdefault("finger_max_z", None) + cand.setdefault("push_x_gain", None) + cand.setdefault("push_max_x", None) + cand.setdefault("push_min_behind", None) + return cand + if len(item) == 8: + dx, dy, z, carry_z, target_x, target_y, transport_gripper, yaw = item + return _candidate_dict(dx, dy, z, carry_z, target_x, target_y, transport_gripper, yaw) + dx, dy, z, carry_z, target_x, target_y, transport_gripper, yaw, push_y = item + return _candidate_dict(dx, dy, z, carry_z, target_x, target_y, transport_gripper, yaw, push_y) + + +def build_env() -> ManagerBasedRLEnv: + cfg = TaskEEnvPiperCfg() + cfg.seed = 123 + cfg.scene.num_envs = 1 + cfg.scene.video_cam = None + cfg.scene.ee_camera = None + cfg.scene.ee_dual_camera = None + cfg.scene.head_camera = None + cfg.observations.image = None + cfg.scene.robot.actuators["default"] = ImplicitActuatorCfg( + joint_names_expr=[".*"], + effort_limit=ACT_EFFORT_LIMIT, + velocity_limit=ACT_VEL_LIMIT, + stiffness=ACT_STIFFNESS, + damping=ACT_DAMPING, + ) + return ManagerBasedRLEnv(cfg) + + +def candidates_for(obj_idx: int) -> list[dict[str, float]]: + priority = [] + if obj_idx == 1: + # Sugar box has an off-centre USD root. Try real top-down pinch + # grasps around the measured visible bbox centre first; keep push-like + # sweeps only as a fallback diagnostic. + priority = [ + _candidate_dict(0.025, 0.000, 0.072, grasp_cfg.CARRY_Z, + 0.00, 0.000, "close", 0.0, + close_z=0.020, finger_target_z=-0.025, finger_max_z=0.050, + transport_steps=2200, place_steps=300, open_steps=80), + _candidate_dict(0.025, 0.000, 0.072, grasp_cfg.CARRY_Z, + 0.00, 0.000, "close", 0.0, + close_z=0.015, finger_target_z=-0.030, finger_max_z=0.060, + transport_steps=2200, place_steps=300, open_steps=80), + _candidate_dict(0.025, 0.000, 0.072, grasp_cfg.CARRY_Z, + 0.00, 0.000, "close", 0.0, + close_z=0.025, finger_target_z=-0.020, finger_max_z=0.045, + transport_steps=2200, place_steps=300, open_steps=80), + _candidate_dict(0.015, 0.000, 0.072, grasp_cfg.CARRY_Z, + 0.00, 0.000, "close", 0.0, + close_z=0.020, finger_target_z=-0.025, finger_max_z=0.050, + transport_steps=2200, place_steps=300, open_steps=80), + _candidate_dict(0.035, 0.000, 0.072, grasp_cfg.CARRY_Z, + 0.00, 0.000, "close", 0.0, + close_z=0.020, finger_target_z=-0.025, finger_max_z=0.050, + transport_steps=2200, place_steps=300, open_steps=80), + _candidate_dict(0.025, 0.010, 0.072, grasp_cfg.CARRY_Z, + 0.00, 0.000, "close", 0.0, + close_z=0.020, finger_target_z=-0.025, finger_max_z=0.050, + transport_steps=2200, place_steps=300, open_steps=80), + _candidate_dict(0.025, -0.010, 0.072, grasp_cfg.CARRY_Z, + 0.00, 0.000, "close", 0.0, + close_z=0.020, finger_target_z=-0.025, finger_max_z=0.050, + transport_steps=2200, place_steps=300, open_steps=80), + _candidate_dict(0.040, 0.180, 0.000, grasp_cfg.TABLE_TOP_Z + 0.055, + 0.00, 0.000, "close", 0.0, + transport_steps=1450, place_steps=320, open_steps=80, + mode="push", push_x_gain=0.55, push_max_x=0.12, + push_min_behind=0.035), + _candidate_dict(0.000, 0.180, 0.000, grasp_cfg.TABLE_TOP_Z + 0.055, + 0.00, 0.000, "close", 0.0, + transport_steps=1450, place_steps=320, open_steps=80, + mode="push", push_x_gain=0.55, push_max_x=0.12, + push_min_behind=0.035), + _candidate_dict(-0.040, 0.180, 0.000, grasp_cfg.TABLE_TOP_Z + 0.055, + 0.00, 0.000, "close", 0.0, + transport_steps=1450, place_steps=320, open_steps=80, + mode="push", push_x_gain=0.60, push_max_x=0.14, + push_min_behind=0.035), + _candidate_dict(0.040, 0.220, 0.000, grasp_cfg.TABLE_TOP_Z + 0.055, + 0.00, 0.000, "close", 0.0, + transport_steps=1550, place_steps=360, open_steps=80, + mode="push", push_x_gain=0.55, push_max_x=0.12, + push_min_behind=0.040), + _candidate_dict(0.000, 0.220, 0.000, grasp_cfg.TABLE_TOP_Z + 0.055, + 0.00, 0.000, "close", 0.0, + transport_steps=1550, place_steps=360, open_steps=80, + mode="push", push_x_gain=0.55, push_max_x=0.12, + push_min_behind=0.040), + # Push-slide primitive: approach from +Y and drive the object + # centre into the basket. This tests the contact-rich route + # before more top-down pinch candidates. + _candidate_dict(0.040, 0.150, 0.000, grasp_cfg.TABLE_TOP_Z + 0.060, + 0.00, 0.000, "close", 0.0, + transport_steps=850, place_steps=140, open_steps=80, + mode="push", push_x_gain=0.65, push_max_x=0.10), + _candidate_dict(0.000, 0.150, 0.000, grasp_cfg.TABLE_TOP_Z + 0.060, + 0.00, 0.000, "close", 0.0, + transport_steps=850, place_steps=140, open_steps=80, + mode="push", push_x_gain=0.65, push_max_x=0.10), + _candidate_dict(-0.040, 0.150, 0.000, grasp_cfg.TABLE_TOP_Z + 0.060, + 0.00, 0.000, "close", 0.0, + transport_steps=850, place_steps=140, open_steps=80, + mode="push", push_x_gain=0.70, push_max_x=0.12), + _candidate_dict(0.040, 0.190, 0.000, grasp_cfg.TABLE_TOP_Z + 0.060, + 0.00, 0.000, "close", 0.0, + transport_steps=950, place_steps=140, open_steps=80, + mode="push", push_x_gain=0.65, push_max_x=0.10), + _candidate_dict(0.000, 0.190, 0.000, grasp_cfg.TABLE_TOP_Z + 0.060, + 0.00, 0.000, "close", 0.0, + transport_steps=950, place_steps=140, open_steps=80, + mode="push", push_x_gain=0.65, push_max_x=0.10), + _candidate_dict(0.040, 0.150, 0.000, grasp_cfg.TABLE_TOP_Z + 0.050, + 0.00, 0.000, "open", 0.0, + transport_steps=950, place_steps=140, open_steps=80, + mode="push", push_x_gain=0.65, push_max_x=0.10), + _candidate_dict(0.040, 0.150, 0.000, grasp_cfg.TABLE_TOP_Z + 0.070, + 0.00, 0.000, "close", math.pi / 2, + transport_steps=850, place_steps=140, open_steps=80, + mode="push", push_x_gain=0.65, push_max_x=0.10), + _candidate_dict(0.040, 0.150, 0.000, grasp_cfg.TABLE_TOP_Z + 0.070, + 0.00, 0.000, "close", -math.pi / 2, + transport_steps=850, place_steps=140, open_steps=80, + mode="push", push_x_gain=0.65, push_max_x=0.10), + # Focused timing sweep after candidates 025-034 proved real + # contact/lift but missed the basket. Keep the end effector low, + # hold contact longer, then release near the basket plane. + _candidate_dict(0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025, + -0.17, 0.000, "close", 0.0, -0.160, + transport_steps=1000, place_steps=30, open_steps=80), + _candidate_dict(0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025, + -0.17, 0.000, "close", 0.0, -0.180, + transport_steps=900, place_steps=30, open_steps=80), + _candidate_dict(0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025, + -0.17, 0.000, "close", 0.0, -0.140, + transport_steps=1200, place_steps=30, open_steps=80), + _candidate_dict(0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025, + -0.17, 0.000, "close", 0.0, -0.200, + transport_steps=750, place_steps=30, open_steps=80), + _candidate_dict(0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.015, + -0.17, 0.000, "close", 0.0, -0.180, + transport_steps=900, place_steps=30, open_steps=80), + _candidate_dict(0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025, + -0.17, 0.000, "open", 0.0, -0.180, + transport_steps=1000, place_steps=30, open_steps=80), + _candidate_dict(0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025, + -0.17, 0.000, "open", 0.0, -0.250, + transport_steps=850, place_steps=30, open_steps=80), + _candidate_dict(0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025, + -0.17, 0.000, "close", 0.0, -0.180, + push_x=-0.040, transport_steps=900, place_steps=30, open_steps=80), + _candidate_dict(0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025, + -0.17, 0.000, "close", 0.0, -0.180, + push_x=0.040, transport_steps=900, place_steps=30, open_steps=80), + _candidate_dict(0.040, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025, + -0.17, 0.000, "close", 0.0, -0.180, + transport_steps=900, place_steps=30, open_steps=80), + (-0.205, 0.104, 0.025, grasp_cfg.TABLE_TOP_Z + 0.140, 0.00, -0.240, "close", 0.0), + (-0.205, 0.104, 0.045, grasp_cfg.TABLE_TOP_Z + 0.160, 0.00, -0.240, "close", 0.0), + (-0.205, 0.104, 0.065, grasp_cfg.TABLE_TOP_Z + 0.180, 0.00, -0.240, "close", 0.0), + (-0.205, 0.104, 0.045, grasp_cfg.TABLE_TOP_Z + 0.160, 0.00, -0.240, "close", math.pi / 2), + (-0.205, 0.104, 0.045, grasp_cfg.TABLE_TOP_Z + 0.160, 0.00, -0.240, "close", -math.pi / 2), + (-0.180, 0.104, 0.045, grasp_cfg.TABLE_TOP_Z + 0.160, 0.00, -0.240, "close", 0.0), + (-0.230, 0.104, 0.045, grasp_cfg.TABLE_TOP_Z + 0.160, 0.00, -0.240, "close", 0.0), + (-0.205, 0.084, 0.045, grasp_cfg.TABLE_TOP_Z + 0.160, 0.00, -0.240, "close", 0.0), + (-0.205, 0.124, 0.045, grasp_cfg.TABLE_TOP_Z + 0.160, 0.00, -0.240, "close", 0.0), + (-0.180, 0.084, 0.045, grasp_cfg.TABLE_TOP_Z + 0.160, 0.00, -0.240, "close", 0.0), + (-0.230, 0.124, 0.045, grasp_cfg.TABLE_TOP_Z + 0.160, 0.00, -0.240, "close", 0.0), + (-0.205, 0.104, 0.085, grasp_cfg.TABLE_TOP_Z + 0.200, 0.00, -0.240, "close", 0.0), + (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.100), + (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.120), + (0.040, 0.120, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.100), + (0.040, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.100), + (0.040, 0.140, 0.000, grasp_cfg.TABLE_TOP_Z + 0.050, 0.00, -0.240, "close", 0.0, -0.100), + (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.140), + (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.180), + (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.220), + (0.040, 0.120, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.160), + (0.040, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.160), + (0.020, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.160), + (0.060, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.160), + # Focused refinement around candidate 019: it made real contact + # and lifted object_1, but released high and too far +X/+Y. + # Lower the sweep height and bias release toward basket centre/left. + (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025, -0.17, 0.000, "close", 0.0, -0.160), + (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025, -0.17, 0.000, "close", 0.0, -0.180), + (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025, -0.10, 0.000, "close", 0.0, -0.160), + (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025, -0.10, 0.000, "close", 0.0, -0.180), + (0.040, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025, -0.17, 0.000, "close", 0.0, -0.160), + (0.040, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025, -0.17, 0.000, "close", 0.0, -0.180), + (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025, -0.17, -0.100, "close", 0.0, -0.160), + (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.025, -0.17, -0.100, "close", 0.0, -0.180), + (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, -0.17, 0.000, "close", 0.0, -0.160), + (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, -0.17, 0.000, "close", 0.0, -0.180), + (0.040, 0.140, 0.000, grasp_cfg.TABLE_TOP_Z + 0.050, 0.00, -0.240, "close", 0.0, -0.160), + (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.300, "close", 0.0, -0.160), + (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.08, -0.240, "close", 0.0, -0.160), + (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.060), + (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.100), + (0.040, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.060), + (0.040, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.100), + (0.020, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.080), + (0.060, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.080), + (0.040, 0.120, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.080), + (0.040, 0.180, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.240, "close", 0.0, -0.080), + (0.040, 0.140, 0.000, grasp_cfg.TABLE_TOP_Z + 0.050, 0.00, -0.240, "close", 0.0, -0.080), + (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.300, "close", 0.0, -0.080), + (0.040, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.750, "close", 0.0), + (0.040, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.08, -0.750, "close", 0.0), + (0.040, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.600, "close", 0.0), + (0.040, 0.140, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.750, "close", 0.0), + (0.040, 0.120, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.750, "close", 0.0), + (0.060, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.750, "close", 0.0), + (0.020, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.750, "close", 0.0), + (0.040, 0.160, 0.000, grasp_cfg.TABLE_TOP_Z + 0.050, 0.00, -0.750, "close", 0.0), + (0.040, 0.140, 0.000, grasp_cfg.TABLE_TOP_Z + 0.050, 0.00, -0.750, "close", 0.0), + (0.040, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, 0.00, -0.750, "open", 0.0), + (-0.205, 0.104, 0.045, grasp_cfg.TABLE_TOP_Z + 0.120, 0.00, -0.240, "close", 0.0), + (-0.205, 0.104, 0.045, grasp_cfg.TABLE_TOP_Z + 0.120, 0.00, -0.240, "close", math.pi / 2), + (-0.205, 0.104, 0.045, grasp_cfg.TABLE_TOP_Z + 0.120, 0.00, -0.240, "close", -math.pi / 2), + (-0.205, 0.084, 0.045, grasp_cfg.TABLE_TOP_Z + 0.120, 0.00, -0.240, "close", 0.0), + (-0.180, 0.104, 0.045, grasp_cfg.TABLE_TOP_Z + 0.120, 0.00, -0.240, "close", 0.0), + (-0.230, 0.104, 0.045, grasp_cfg.TABLE_TOP_Z + 0.120, 0.00, -0.240, "close", 0.0), + (-0.205, 0.124, 0.045, grasp_cfg.TABLE_TOP_Z + 0.120, 0.00, -0.240, "close", 0.0), + (-0.205, 0.104, 0.065, grasp_cfg.TABLE_TOP_Z + 0.140, 0.00, -0.240, "close", 0.0), + (-0.205, 0.104, 0.025, grasp_cfg.TABLE_TOP_Z + 0.100, 0.00, -0.240, "close", 0.0), + (-0.205, 0.104, 0.045, grasp_cfg.TABLE_TOP_Z + 0.180, 0.00, -0.240, "close", 0.0), + (-0.205, 0.104, 0.045, grasp_cfg.TABLE_TOP_Z + 0.120, -0.10, -0.240, "close", 0.0), + (-0.205, 0.104, 0.045, grasp_cfg.TABLE_TOP_Z + 0.120, 0.00, -0.300, "close", 0.0), + (0.040, 0.200, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, -0.17, -0.60, "close", 0.0), + (0.040, 0.200, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, -0.10, -0.60, "close", 0.0), + (0.040, 0.160, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, -0.17, -0.60, "close", 0.0), + (0.080, 0.200, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, -0.17, -0.60, "close", 0.0), + (-0.040, 0.200, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, -0.17, -0.60, "close", 0.0), + (-0.096, 0.200, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, -0.17, -0.60, "close", 0.0), + (0.040, 0.240, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, -0.17, -0.60, "close", 0.0), + (0.040, 0.200, 0.000, grasp_cfg.TABLE_TOP_Z + 0.035, -0.17, -0.60, "close", 0.0), + (0.040, 0.200, -0.020, grasp_cfg.TABLE_TOP_Z + 0.050, -0.17, -0.60, "close", 0.0), + (0.040, 0.200, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, -0.17, -0.45, "close", 0.0), + (0.040, 0.200, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, -0.17, -0.75, "close", 0.0), + (0.040, 0.200, -0.020, grasp_cfg.TABLE_TOP_Z + 0.035, -0.17, -0.60, "open", 0.0), + ] + base_offsets = [ + (0.040, 0.140), + (0.040, 0.180), + (0.040, 0.220), + (0.080, 0.180), + (0.080, 0.220), + (-0.096, 0.140), + (-0.096, 0.180), + (-0.096, 0.220), + (-0.040, 0.140), + (-0.040, 0.180), + (-0.040, 0.220), + (0.000, 0.140), + (0.000, 0.180), + (0.000, 0.220), + (-0.160, 0.140), + (-0.200, 0.140), + (-0.117, -0.025), + (-0.096, 0.084), + (-0.096, 0.000), + (-0.060, 0.060), + (-0.040, 0.020), + (0.000, 0.040), + (-0.140, 0.040), + (-0.100, 0.000), + (-0.020, 0.080), + ] + z_values = [-0.020, -0.010, 0.000, 0.015, 0.025, 0.040, 0.060, 0.080, 0.110] + carry_values = [ + grasp_cfg.TABLE_TOP_Z + 0.025, + grasp_cfg.TABLE_TOP_Z + 0.035, + grasp_cfg.TABLE_TOP_Z + 0.050, + grasp_cfg.TABLE_TOP_Z + 0.075, + grasp_cfg.TABLE_TOP_Z + 0.10, + grasp_cfg.TABLE_TOP_Z + 0.12, + grasp_cfg.TABLE_TOP_Z + 0.16, + grasp_cfg.TABLE_TOP_Z + 0.22, + grasp_cfg.CARRY_Z, + ] + target_x_offsets = [-0.17, -0.10, 0.0, 0.08] + target_y_offsets = [-0.60, -0.45, -0.75, -0.36, -0.30, -0.24, -0.18, 0.0] + transport_gripper_cmds = ["close", "open"] + yaws = [0.0, math.pi / 2, -math.pi / 2] + elif obj_idx == 2: + priority = [ + _candidate_dict(0.000, 0.045, 0.000, grasp_cfg.TABLE_TOP_Z + 0.045, + 0.00, -0.140, "close", 0.0, + transport_steps=1500, place_steps=420, open_steps=80, + mode="push", push_x_gain=0.50, push_max_x=0.10, + push_min_behind=-0.015), + _candidate_dict(0.020, 0.045, 0.000, grasp_cfg.TABLE_TOP_Z + 0.045, + 0.00, -0.140, "close", 0.0, + transport_steps=1500, place_steps=420, open_steps=80, + mode="push", push_x_gain=0.50, push_max_x=0.10, + push_min_behind=-0.015), + _candidate_dict(-0.020, 0.045, 0.000, grasp_cfg.TABLE_TOP_Z + 0.045, + 0.00, -0.140, "close", 0.0, + transport_steps=1500, place_steps=420, open_steps=80, + mode="push", push_x_gain=0.55, push_max_x=0.12, + push_min_behind=-0.015), + _candidate_dict(0.000, 0.060, 0.000, grasp_cfg.TABLE_TOP_Z + 0.040, + 0.00, -0.180, "close", 0.0, + transport_steps=1600, place_steps=460, open_steps=80, + mode="push", push_x_gain=0.50, push_max_x=0.10, + push_min_behind=-0.020), + _candidate_dict(0.020, 0.060, 0.000, grasp_cfg.TABLE_TOP_Z + 0.040, + 0.00, -0.180, "close", 0.0, + transport_steps=1600, place_steps=460, open_steps=80, + mode="push", push_x_gain=0.50, push_max_x=0.10, + push_min_behind=-0.020), + _candidate_dict(-0.020, 0.060, 0.000, grasp_cfg.TABLE_TOP_Z + 0.040, + 0.00, -0.180, "close", 0.0, + transport_steps=1600, place_steps=460, open_steps=80, + mode="push", push_x_gain=0.55, push_max_x=0.12, + push_min_behind=-0.020), + _candidate_dict(0.000, 0.095, 0.000, grasp_cfg.TABLE_TOP_Z + 0.045, + 0.00, 0.000, "close", 0.0, + transport_steps=1250, place_steps=260, open_steps=80, + mode="push", push_x_gain=0.55, push_max_x=0.10, + push_min_behind=0.025), + _candidate_dict(0.020, 0.095, 0.000, grasp_cfg.TABLE_TOP_Z + 0.045, + 0.00, 0.000, "close", 0.0, + transport_steps=1250, place_steps=260, open_steps=80, + mode="push", push_x_gain=0.55, push_max_x=0.10, + push_min_behind=0.025), + _candidate_dict(-0.020, 0.095, 0.000, grasp_cfg.TABLE_TOP_Z + 0.045, + 0.00, 0.000, "close", 0.0, + transport_steps=1250, place_steps=260, open_steps=80, + mode="push", push_x_gain=0.60, push_max_x=0.12, + push_min_behind=0.025), + _candidate_dict(0.000, 0.125, 0.000, grasp_cfg.TABLE_TOP_Z + 0.045, + 0.00, 0.000, "close", 0.0, + transport_steps=1350, place_steps=300, open_steps=80, + mode="push", push_x_gain=0.55, push_max_x=0.10, + push_min_behind=0.030), + _candidate_dict(0.020, 0.125, 0.000, grasp_cfg.TABLE_TOP_Z + 0.045, + 0.00, 0.000, "close", 0.0, + transport_steps=1350, place_steps=300, open_steps=80, + mode="push", push_x_gain=0.55, push_max_x=0.10, + push_min_behind=0.030), + _candidate_dict(0.000, 0.095, 0.000, grasp_cfg.TABLE_TOP_Z + 0.040, + 0.00, 0.000, "close", 0.0, + transport_steps=1350, place_steps=300, open_steps=80, + mode="push", push_x_gain=0.55, push_max_x=0.10, + push_min_behind=0.020), + _candidate_dict(-0.040, 0.070, 0.000, grasp_cfg.TABLE_TOP_Z + 0.045, + 0.00, -0.140, "close", 0.0, + transport_steps=1000, place_steps=160, open_steps=80, + mode="push", push_x_gain=0.75, push_max_x=0.14), + _candidate_dict(0.000, 0.070, 0.000, grasp_cfg.TABLE_TOP_Z + 0.045, + 0.00, -0.140, "close", 0.0, + transport_steps=1000, place_steps=160, open_steps=80, + mode="push", push_x_gain=0.70, push_max_x=0.12), + _candidate_dict(0.040, 0.070, 0.000, grasp_cfg.TABLE_TOP_Z + 0.045, + 0.00, -0.140, "close", 0.0, + transport_steps=1000, place_steps=160, open_steps=80, + mode="push", push_x_gain=0.70, push_max_x=0.12), + _candidate_dict(-0.040, 0.050, 0.000, grasp_cfg.TABLE_TOP_Z + 0.040, + 0.00, -0.180, "close", 0.0, + transport_steps=1100, place_steps=180, open_steps=80, + mode="push", push_x_gain=0.75, push_max_x=0.14), + _candidate_dict(0.000, 0.050, 0.000, grasp_cfg.TABLE_TOP_Z + 0.040, + 0.00, -0.180, "close", 0.0, + transport_steps=1100, place_steps=180, open_steps=80, + mode="push", push_x_gain=0.70, push_max_x=0.12), + _candidate_dict(-0.040, 0.090, 0.000, grasp_cfg.TABLE_TOP_Z + 0.050, + 0.00, -0.220, "open", 0.0, + transport_steps=1100, place_steps=180, open_steps=80, + mode="push", push_x_gain=0.75, push_max_x=0.14), + _candidate_dict(0.000, 0.115, 0.000, grasp_cfg.TABLE_TOP_Z + 0.065, + 0.00, 0.000, "close", 0.0, + transport_steps=700, place_steps=120, open_steps=80, + mode="push", push_x_gain=0.65, push_max_x=0.10), + _candidate_dict(0.040, 0.115, 0.000, grasp_cfg.TABLE_TOP_Z + 0.065, + 0.00, 0.000, "close", 0.0, + transport_steps=700, place_steps=120, open_steps=80, + mode="push", push_x_gain=0.65, push_max_x=0.10), + _candidate_dict(-0.040, 0.115, 0.000, grasp_cfg.TABLE_TOP_Z + 0.065, + 0.00, 0.000, "close", 0.0, + transport_steps=700, place_steps=120, open_steps=80, + mode="push", push_x_gain=0.70, push_max_x=0.12), + _candidate_dict(0.000, 0.150, 0.000, grasp_cfg.TABLE_TOP_Z + 0.065, + 0.00, 0.000, "close", 0.0, + transport_steps=850, place_steps=120, open_steps=80, + mode="push", push_x_gain=0.65, push_max_x=0.10), + _candidate_dict(0.040, 0.150, 0.000, grasp_cfg.TABLE_TOP_Z + 0.065, + 0.00, 0.000, "close", -math.pi / 2, + transport_steps=850, place_steps=120, open_steps=80, + mode="push", push_x_gain=0.65, push_max_x=0.10), + _candidate_dict(0.000, 0.115, 0.000, grasp_cfg.TABLE_TOP_Z + 0.055, + 0.00, 0.000, "open", 0.0, + transport_steps=850, place_steps=120, open_steps=80, + mode="push", push_x_gain=0.65, push_max_x=0.10), + (0.006, 0.046, 0.045, grasp_cfg.TABLE_TOP_Z + 0.075, 0.00, -0.240, "close", -math.pi / 2), + ] + base_offsets = [ + (0.006, 0.046), + (0.030, 0.026), + (0.060, 0.000), + (0.100, 0.020), + (0.115, 0.026), + (-0.020, 0.050), + (0.040, 0.070), + (0.000, 0.000), + ] + z_values = [0.045, 0.065, 0.085, 0.110, 0.135, 0.160] + carry_values = [ + grasp_cfg.TABLE_TOP_Z + 0.075, + grasp_cfg.TABLE_TOP_Z + 0.10, + grasp_cfg.TABLE_TOP_Z + 0.12, + grasp_cfg.TABLE_TOP_Z + 0.14, + grasp_cfg.TABLE_TOP_Z + 0.18, + grasp_cfg.TABLE_TOP_Z + 0.24, + grasp_cfg.CARRY_Z, + ] + target_x_offsets = [0.0] + target_y_offsets = [-0.24, -0.18, -0.30, -0.12, 0.0] + transport_gripper_cmds = ["close"] + yaws = [0.0, math.pi / 2, -math.pi / 2] + else: + base_offsets = [(0.0, 0.0)] + z_values = [grasp_cfg.GRASP_Z_OFFSET] + carry_values = [grasp_cfg.CARRY_Z] + target_x_offsets = [0.0] + target_y_offsets = [0.0] + transport_gripper_cmds = ["close"] + yaws = [0.0] + + out = [] + for item in priority: + out.append(_normalize_candidate(item)) + for z in z_values: + for carry_z in carry_values: + for target_x in target_x_offsets: + for target_y in target_y_offsets: + for transport_gripper in transport_gripper_cmds: + for yaw in yaws: + for dx, dy in base_offsets: + out.append({ + "dx": dx, + "dy": dy, + "z": z, + "carry_z": carry_z, + "place_z": min(carry_z, grasp_cfg.TABLE_TOP_Z + 0.15), + "target_x": target_x, + "target_y": target_y, + "transport_gripper": transport_gripper, + "yaw": yaw, + "push_y": None, + }) + start = max(args_cli.start_candidate, 1) - 1 + return out[start : start + args_cli.max_candidates] + + +def apply_candidate(obj_idx: int, cand: dict[str, float]) -> None: + grasp_cfg.OBJ_MANIPULATION_MODES[obj_idx] = cand.get("mode", "pick") + grasp_cfg.OBJ_GRASP_CENTER_OFFSETS[obj_idx] = (cand["dx"], cand["dy"], 0.0) + grasp_cfg.OBJ_GRASP_Z_OFFSETS[obj_idx] = cand["z"] + if cand.get("close_z") is not None: + grasp_cfg.OBJ_CLOSE_Z_OFFSETS[obj_idx] = float(cand["close_z"]) + grasp_cfg.OBJ_GRASP_YAW_OFFSETS[obj_idx] = cand["yaw"] + grasp_cfg.OBJ_CARRY_Z[obj_idx] = cand["carry_z"] + grasp_cfg.OBJ_PLACE_HEIGHTS[obj_idx] = cand["place_z"] + grasp_cfg.OBJ_PLACE_XY_OFFSETS[obj_idx] = (cand["target_x"], cand["target_y"]) + grasp_cfg.OBJ_TRANSPORT_GRIPPER_CMDS[obj_idx] = cand["transport_gripper"] + grasp_cfg.OBJ_PUSH_GRIPPER_CMDS[obj_idx] = cand["transport_gripper"] + if cand.get("finger_target_z") is not None: + grasp_cfg.OBJ_FINGER_CENTER_SERVO_TARGET_Z[obj_idx] = float(cand["finger_target_z"]) + if cand.get("finger_max_z") is not None: + grasp_cfg.OBJ_FINGER_CENTER_SERVO_MAX_Z[obj_idx] = float(cand["finger_max_z"]) + if cand.get("push_x_gain") is not None: + grasp_cfg.OBJ_PUSH_X_GAINS[obj_idx] = float(cand["push_x_gain"]) + if cand.get("push_max_x") is not None: + grasp_cfg.OBJ_PUSH_MAX_X_CORRECTIONS[obj_idx] = float(cand["push_max_x"]) + if cand.get("push_min_behind") is not None: + grasp_cfg.OBJ_PUSH_MIN_BEHIND[obj_idx] = float(cand["push_min_behind"]) + grasp_cfg.OBJ_TRANSPORT_PUSH_BIASES[obj_idx] = ( + None if cand.get("push_y") is None + else (cand.get("push_x", 0.0), cand["push_y"], cand.get("push_z", 0.0)) + ) + step_overrides = BASE_STATE_STEP_OVERRIDES.get(obj_idx, {}).copy() + for cand_key, state_key in ( + ("close_steps", "CLOSE"), + ("lift_steps", "LIFT"), + ("transport_steps", "TRANSPORT"), + ("place_steps", "PLACE"), + ("open_steps", "OPEN"), + ): + if cand.get(cand_key) is not None: + step_overrides[state_key] = int(cand[cand_key]) + if step_overrides: + grasp_cfg.OBJ_STATE_STEP_OVERRIDES[obj_idx] = step_overrides + else: + grasp_cfg.OBJ_STATE_STEP_OVERRIDES.pop(obj_idx, None) + + +def format_trace(data: dict | None, obj_idx: int) -> str: + if data is None or "trace" not in data: + return "trace=none" + tr = data["trace"].get(f"object_{obj_idx}", {}) + states = tr.get("states", {}) + close = states.get("CLOSE", {}) + lift = states.get("LIFT", {}) + transport = states.get("TRANSPORT", {}) + def _fmt_vec(vec): + if vec is None: + return "none" + return "(" + ",".join(f"{float(v):+.3f}" for v in vec[:3]) + ")" + return ( + f"lifted={tr.get('lifted')} " + f"reward_lifted={tr.get('reward_lifted')} " + f"z_gain={float(tr.get('z_gain', 0.0)):.3f} " + f"gap_close={float(close.get('min_gripper_gap', 999.0)):.3f} " + f"gap_lift={float(lift.get('min_gripper_gap', 999.0)):.3f} " + f"ee_lift={float(lift.get('min_ee_dist', 999.0)):.3f} " + f"ee_transport={float(transport.get('min_ee_dist', 999.0)):.3f} " + f"finger_lift={float(lift.get('min_finger_center_dist', 999.0)):.3f} " + f"finger_gap={float(lift.get('min_finger_body_gap', 999.0)):.3f} " + f"finger_vec_transport={_fmt_vec(transport.get('min_finger_center_vec'))} " + f"ee_vec_transport={_fmt_vec(transport.get('min_ee_vec'))}" + ) + + +def score_candidate(env: ManagerBasedRLEnv, data: dict | None, obj_idx: int, ok: bool) -> float: + pos = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"].data.root_pos_w[0] + dx = abs(float(pos[0].item() - grasp_cfg.BASKET_CENTER_X)) + dy = abs(float(pos[1].item() - grasp_cfg.BASKET_CENTER_Y)) + xy_err = max(dx - grasp_cfg.BASKET_IN_X, 0.0) + max(dy - grasp_cfg.BASKET_IN_Y, 0.0) + z_gain = 0.0 + if data is not None and "trace" in data: + z_gain = float(data["trace"].get(f"object_{obj_idx}", {}).get("z_gain", 0.0)) + return (100.0 if ok else 0.0) + 2.0 * z_gain - xy_err + + +def main() -> None: + env = build_env() + dev = env.unwrapped.device + robot = env.unwrapped.scene.articulations["robot"] + arm_ids, _ = robot.find_joints(ARM_JOINT_NAMES) + gripper_ids, _ = robot.find_joints(GRIPPER_JOINT_NAMES) + ik_ctrl = CartesianController( + robot=robot, + ee_body_name=EE_BODY_NAME, + arm_joint_names=ARM_JOINT_NAMES, + num_envs=1, + device=dev, + command_type="pose", + lambda_val=0.05, + max_joint_delta=args_cli.max_joint_delta, + ) + default_jpos = robot.data.default_joint_pos.clone() + original_close = STEPS["CLOSE"] + STEPS["CLOSE"] = max(original_close, 100) + + try: + for obj_idx in args_cli.objects: + print(f"\n[SEARCH] object_{obj_idx}") + successes: list[dict[str, float]] = [] + best: tuple[float, int, dict[str, float], str] | None = None + for cand_idx, cand in enumerate(candidates_for(obj_idx), start=max(args_cli.start_candidate, 1)): + apply_candidate(obj_idx, cand) + ok_count = 0 + last_status = "" + last_score = -1e9 + for trial in range(args_cli.trials): + # Keep trial seeds independent of candidate index so every + # candidate is evaluated on the same object placements. + rng = np.random.default_rng(1000 + obj_idx * 100 + trial) + data = collect_one_demo( + env, + robot, + ik_ctrl, + arm_ids, + gripper_ids, + [obj_idx], + dev, + default_jpos=default_jpos, + rng=rng, + camera=None, + trace=True, + ) + ok = data is not None and check_objects_in_basket(env, [obj_idx]) + ok_count += int(ok) + last_score = score_candidate(env, data, obj_idx, ok) + last_status = ( + "; ".join(basket_status_lines(env, [obj_idx])) + + " | " + + format_trace(data, obj_idx) + ) + if not ok: + break + if best is None or last_score > best[0]: + best = (last_score, cand_idx, cand.copy(), last_status) + result = f"{ok_count}/{args_cli.trials}" + print( + f"[CAND {cand_idx:03d}] mode={cand.get('mode', 'pick')} result={result} " + f"dx={cand['dx']:+.3f} dy={cand['dy']:+.3f} " + f"z={cand['z']:.3f} close_z={cand.get('close_z')} " + f"finger_z={cand.get('finger_target_z')} carry={cand['carry_z']:.3f} " + f"target_x={cand['target_x']:+.3f} " + f"target_y={cand['target_y']:+.3f} " + f"push=({cand.get('push_x', 0.0):+.3f},{cand.get('push_y')},{cand.get('push_z', 0.0):+.3f}) " + f"behind={cand.get('push_min_behind')} " + f"steps=({cand.get('transport_steps')},{cand.get('place_steps')},{cand.get('open_steps')}) " + f"transport_gripper={cand['transport_gripper']} " + f"yaw={cand['yaw']:+.3f} | {last_status}", + flush=True, + ) + if ok_count == args_cli.trials: + successes.append(cand.copy()) + print(f"[SUCCESS] object_{obj_idx}: {cand}", flush=True) + break + if not successes: + print(f"[FAIL] object_{obj_idx}: no successful candidate in first {args_cli.max_candidates}") + if best is not None: + best_score, best_idx, best_cand, best_status = best + print( + f"[BEST] object_{obj_idx}: cand={best_idx:03d} score={best_score:.3f} " + f"{best_cand} | {best_status}", + flush=True, + ) + finally: + STEPS["CLOSE"] = original_close + env.close() + + +if __name__ == "__main__": + main() + simulation_app.close() diff --git a/scripts/act/task_e/__init__.py b/scripts/act/task_e/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/scripts/act/task_e/collector.py b/scripts/act/task_e/collector.py new file mode 100644 index 0000000000000000000000000000000000000000..9e600dc0f1d8aa7b23a40dbadbfb0d530c75f2c0 --- /dev/null +++ b/scripts/act/task_e/collector.py @@ -0,0 +1,399 @@ +"""Single-episode demo collection and success checking for Task E.""" + +import numpy as np +import torch +from isaaclab.envs import ManagerBasedRLEnv +from atec_rl_lab.utils import CartesianController +from atec_rl_lab.tasks.task_e.env_cfg import ( + TABLE_CENTER_X, TABLE_CENTER_Y, TABLE_TOP_Z, + BASKET_CENTER_X, BASKET_CENTER_Y, +) + +from .config import ( + ACTION_SCALE, + EE_BODY_NAME, + GRIPPER_OPEN_POS, GRIPPER_CLOSE_POS, + OBJ_GRIPPER_CLOSE_POS, + RETRACT_POS_X, RETRACT_POS_Y, CARRY_Z, + DEFAULT_PLACE_QUAT_W, + BASKET_IN_X, BASKET_IN_Y, + OBJ_SPAWN_X_MIN, OBJ_SPAWN_X_MAX, OBJ_SPAWN_Z, OBJ_SPAWN_Y_BANDS, + OBJ_HALF_EXTENTS, OBJ_BBOX_MARGIN, OBJ_GRASP_CENTER_OFFSETS, + OBJ_FINGER_CENTER_SERVO_STATES, OBJ_FINGER_CENTER_SERVO_GAIN, + OBJ_FINGER_CENTER_SERVO_MAX_XY, OBJ_FINGER_CENTER_SERVO_TARGET_Z, + OBJ_FINGER_CENTER_SERVO_MAX_Z, + WARMUP_STEPS, SETTLE_STEPS, +) +from .state_machine import PickPlaceStateMachine + + +def _rerandomize_objects(env: ManagerBasedRLEnv, rng: np.random.Generator) -> None: + """Place each object randomly with AABB-based overlap rejection.""" + placed: dict[int, tuple[float, float]] = {} # obj_idx -> (x, y) + + for obj_idx in [1, 2, 3]: + obj = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"] + y_min, y_max = OBJ_SPAWN_Y_BANDS[obj_idx] + hx, hy = OBJ_HALF_EXTENTS[obj_idx] + + x = y = None + for _ in range(200): + cx = float(rng.uniform(OBJ_SPAWN_X_MIN, OBJ_SPAWN_X_MAX)) + cy = float(rng.uniform(y_min, y_max)) + # AABB overlap check against all already-placed objects + ok = all( + abs(cx - px) >= hx + OBJ_HALF_EXTENTS[pi][0] + OBJ_BBOX_MARGIN or + abs(cy - py) >= hy + OBJ_HALF_EXTENTS[pi][1] + OBJ_BBOX_MARGIN + for pi, (px, py) in placed.items() + ) + if ok: + x, y = cx, cy + break + + if x is None: # fallback: band centre + x = (OBJ_SPAWN_X_MIN + OBJ_SPAWN_X_MAX) / 2.0 + y = (y_min + y_max) / 2.0 + + placed[obj_idx] = (x, y) + state = obj.data.default_root_state[0:1].clone() + state[0, 0] = x + state[0, 1] = y + state[0, 2] = OBJ_SPAWN_Z + state[0, 7:] = 0.0 # zero velocities + obj.write_root_state_to_sim(state) + + env.unwrapped.scene.write_data_to_sim() + env.unwrapped.sim.forward() + + +_BASKET_MAX_Z = TABLE_TOP_Z + 0.15 # keep aligned with Task-E reward/termination bounds + +def check_objects_in_basket(env: ManagerBasedRLEnv, pick_objects: list[int]) -> bool: + """Return True only if every picked object is inside the basket region and settled.""" + for obj_idx in pick_objects: + pos = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"].data.root_pos_w[0] + if (abs(pos[0].item() - BASKET_CENTER_X) > BASKET_IN_X or + abs(pos[1].item() - BASKET_CENTER_Y) > BASKET_IN_Y or + pos[2].item() > _BASKET_MAX_Z): + return False + return True + + +def basket_status_lines(env: ManagerBasedRLEnv, pick_objects: list[int]) -> list[str]: + """Return compact debug lines for picked objects against basket bounds.""" + lines = [] + for obj_idx in pick_objects: + pos = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"].data.root_pos_w[0] + dx = pos[0].item() - BASKET_CENTER_X + dy = pos[1].item() - BASKET_CENTER_Y + z = pos[2].item() + inside = abs(dx) <= BASKET_IN_X and abs(dy) <= BASKET_IN_Y and TABLE_TOP_Z <= z <= _BASKET_MAX_Z + lines.append( + f"object_{obj_idx}: pos=({pos[0].item():.3f},{pos[1].item():.3f},{z:.3f}) " + f"d=({dx:+.3f},{dy:+.3f}) inside={inside}" + ) + return lines + + +def collect_one_demo( + env: ManagerBasedRLEnv, + robot, + ik_ctrl: CartesianController, + arm_ids: list[int], + gripper_ids: list[int], + pick_objects: list[int], + device: str, + default_jpos: torch.Tensor, + rng: np.random.Generator, + camera=None, + trace: bool = False, + abort_failed_lift: bool = False, +) -> dict | None: + """Run one full episode and return recorded data, or None on early termination. + + Returns a dict with keys: + qpos (T, 8) absolute joint positions + qvel (T, 8) joint velocities + ee_pos (T, 3) end-effector position (world frame) + ee_quat (T, 4) end-effector quaternion (w,x,y,z) + action (T, 8) env action = (joint_target - default_jpos) / ACTION_SCALE + frames (T, H, W, 3) RGB uint8 — only present when camera is given + """ + env.reset() + robot.write_joint_state_to_sim( + robot.data.default_joint_pos, + torch.zeros_like(robot.data.default_joint_vel), + ) + + _rerandomize_objects(env, rng) # write new object positions to sim + sim.forward() + default_jpos = robot.data.default_joint_pos.clone() + + ee_home = torch.tensor([[RETRACT_POS_X, RETRACT_POS_Y, CARRY_Z]], + dtype=torch.float32, device=device) + eq_home = torch.tensor([DEFAULT_PLACE_QUAT_W], dtype=torch.float32, device=device) + g_open = torch.tensor([GRIPPER_OPEN_POS], dtype=torch.float32, device=device) + + robot.update(dt=env.unwrapped.physics_dt) + ik_ctrl.reset() + + # Warm-up: drive arm to HOME position (not recorded) + for _ in range(WARMUP_STEPS): + _step_to(env, robot, ik_ctrl, arm_ids, gripper_ids, + ee_home, eq_home, g_open, default_jpos) + + # Pre-compute grasp quaternions from actual object orientations after reset + sm = PickPlaceStateMachine(pick_objects, device) + for obj_idx in pick_objects: + obj_quat = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"] \ + .data.root_state_w[0, 3:7] + sm.set_grasp_quat(obj_idx, obj_quat) + + # Settle + for _ in range(SETTLE_STEPS): + _step_to(env, robot, ik_ctrl, arm_ids, gripper_ids, + ee_home, eq_home, g_open, default_jpos) + + ik_ctrl.reset() + + # ---- Recording loop ---- # + qpos_buf, qvel_buf, ee_pos_buf, ee_quat_buf, action_buf = [], [], [], [], [] + frames_buf = [] if camera is not None else None + trace_stats: dict[str, dict] | None = {} if trace else None + ee_body_idx = None + finger_body_indices: tuple[int, int] | None = None + ee_body_ids, _ = robot.find_bodies(EE_BODY_NAME) + if len(ee_body_ids) > 0: + ee_body_idx = int(ee_body_ids[0]) + link7_ids, _ = robot.find_bodies("link7") + link8_ids, _ = robot.find_bodies("link8") + if len(link7_ids) > 0 and len(link8_ids) > 0: + finger_body_indices = (int(link7_ids[0]), int(link8_ids[0])) + + def _finger_center() -> torch.Tensor | None: + if finger_body_indices is None: + return None + f0 = robot.data.body_pos_w[0, finger_body_indices[0], :3].detach() + f1 = robot.data.body_pos_w[0, finger_body_indices[1], :3].detach() + return 0.5 * (f0 + f1) + + def _servo_target_to_fingers( + state_name: str, + obj_key: str, + obj_pos: torch.Tensor, + ee_pos_des: torch.Tensor, + ) -> torch.Tensor: + obj_idx = int(obj_key.rsplit("_", 1)[1]) + if state_name not in OBJ_FINGER_CENTER_SERVO_STATES.get(obj_idx, ()): + return ee_pos_des + finger_center = _finger_center() + if finger_center is None: + return ee_pos_des + grasp_offset = torch.tensor( + OBJ_GRASP_CENTER_OFFSETS.get(obj_idx, (0.0, 0.0, 0.0)), + dtype=torch.float32, + device=device, + ) + grasp_center = obj_pos + grasp_offset if obj_idx == 1 else obj_pos + xy_error = finger_center[:2] - grasp_center[:2] + err_norm = torch.linalg.norm(xy_error) + if err_norm.item() > 0.18: + return ee_pos_des + gain = OBJ_FINGER_CENTER_SERVO_GAIN.get(obj_idx, 0.85) + correction = -xy_error * gain + max_xy = OBJ_FINGER_CENTER_SERVO_MAX_XY.get(obj_idx, 0.08) + corr_norm = torch.linalg.norm(correction).clamp(min=1e-6) + if corr_norm.item() > max_xy: + correction = correction / corr_norm * max_xy + ee_pos_des = ee_pos_des.clone() + ee_pos_des[:2] = ee_pos_des[:2] + correction + if state_name in ("REACH", "CLOSE") and obj_idx in OBJ_FINGER_CENTER_SERVO_TARGET_Z: + target_rel_z = OBJ_FINGER_CENTER_SERVO_TARGET_Z[obj_idx] + z_error = target_rel_z - float((finger_center[2] - obj_pos[2]).item()) + max_z = OBJ_FINGER_CENTER_SERVO_MAX_Z.get(obj_idx, 0.02) + z_correction = min(0.0, max(-max_z, z_error * gain)) + ee_pos_des[2] = ee_pos_des[2] + z_correction + return ee_pos_des + + def _update_trace(state_name: str, obj_key: str, obj_pos: torch.Tensor) -> None: + if trace_stats is None: + return + obj_idx = int(obj_key.rsplit("_", 1)[1]) + grasp_offset = torch.tensor( + OBJ_GRASP_CENTER_OFFSETS.get(obj_idx, (0.0, 0.0, 0.0)), + dtype=torch.float32, + device=device, + ) + grasp_center = obj_pos + grasp_offset if obj_idx == 1 else obj_pos + if ee_body_idx is not None: + ee_pos = robot.data.body_pos_w[0, ee_body_idx, :3].detach() + else: + ee_pos = ik_ctrl.ee_pos_w[0].detach() + finger_center_dist = None + finger_body_gap = None + if finger_body_indices is not None: + f0 = robot.data.body_pos_w[0, finger_body_indices[0], :3].detach() + f1 = robot.data.body_pos_w[0, finger_body_indices[1], :3].detach() + finger_center = 0.5 * (f0 + f1) + finger_center_dist = float(torch.linalg.norm(grasp_center - finger_center).item()) + finger_body_gap = float(torch.linalg.norm(f0 - f1).item()) + finger_center_vec = [float(v) for v in (finger_center - grasp_center).detach().cpu().tolist()] + else: + finger_center_vec = None + gripper_jpos = robot.data.joint_pos[0, gripper_ids].detach() + gripper_gap = abs(float(gripper_jpos[0].item() - gripper_jpos[1].item())) + ee_dist = float(torch.linalg.norm(obj_pos - ee_pos).item()) + ee_vec = [float(v) for v in (ee_pos - obj_pos).detach().cpu().tolist()] + obj_pos_cpu = [float(v) for v in obj_pos.detach().cpu().tolist()] + obj_stats = trace_stats.setdefault( + obj_key, + { + "initial_pos": obj_pos_cpu, + "final_pos": obj_pos_cpu, + "max_z": obj_pos_cpu[2], + "min_ee_dist": ee_dist, + "min_ee_vec": ee_vec, + "min_gripper_gap": gripper_gap, + "min_finger_center_dist": finger_center_dist if finger_center_dist is not None else 999.0, + "min_finger_center_vec": finger_center_vec if finger_center_vec is not None else None, + "min_finger_body_gap": finger_body_gap if finger_body_gap is not None else 999.0, + "states": {}, + }, + ) + obj_stats["final_pos"] = obj_pos_cpu + obj_stats["max_z"] = max(float(obj_stats["max_z"]), obj_pos_cpu[2]) + if ee_dist < float(obj_stats["min_ee_dist"]): + obj_stats["min_ee_dist"] = ee_dist + obj_stats["min_ee_vec"] = ee_vec + obj_stats["min_gripper_gap"] = min(float(obj_stats["min_gripper_gap"]), gripper_gap) + if finger_center_dist is not None: + if finger_center_dist < float(obj_stats["min_finger_center_dist"]): + obj_stats["min_finger_center_dist"] = finger_center_dist + obj_stats["min_finger_center_vec"] = finger_center_vec + if finger_body_gap is not None: + obj_stats["min_finger_body_gap"] = min(float(obj_stats["min_finger_body_gap"]), finger_body_gap) + st = obj_stats["states"].setdefault( + state_name, + { + "steps": 0, + "start_pos": obj_pos_cpu, + "end_pos": obj_pos_cpu, + "max_z": obj_pos_cpu[2], + "min_ee_dist": ee_dist, + "min_ee_vec": ee_vec, + "min_gripper_gap": gripper_gap, + "min_finger_center_dist": finger_center_dist if finger_center_dist is not None else 999.0, + "min_finger_center_vec": finger_center_vec if finger_center_vec is not None else None, + "min_finger_body_gap": finger_body_gap if finger_body_gap is not None else 999.0, + }, + ) + st["steps"] += 1 + st["end_pos"] = obj_pos_cpu + st["max_z"] = max(float(st["max_z"]), obj_pos_cpu[2]) + if ee_dist < float(st["min_ee_dist"]): + st["min_ee_dist"] = ee_dist + st["min_ee_vec"] = ee_vec + st["min_gripper_gap"] = min(float(st["min_gripper_gap"]), gripper_gap) + if finger_center_dist is not None: + if finger_center_dist < float(st["min_finger_center_dist"]): + st["min_finger_center_dist"] = finger_center_dist + st["min_finger_center_vec"] = finger_center_vec + if finger_body_gap is not None: + st["min_finger_body_gap"] = min(float(st["min_finger_body_gap"]), finger_body_gap) + + def _gripper_target_values(obj_key: str, gripper_cmd: str) -> list[float]: + if gripper_cmd == "open": + return GRIPPER_OPEN_POS + obj_idx = int(obj_key.rsplit("_", 1)[1]) + return OBJ_GRIPPER_CLOSE_POS.get(obj_idx, GRIPPER_CLOSE_POS) + + while not sm.done: + state_name = sm.state + obj_key = sm.current_object_key + obj_pos_w = env.unwrapped.scene.rigid_objects[sm.current_object_key] \ + .data.root_pos_w[0].clone() + ee_pos_des, ee_quat_des, gripper_cmd = sm.tick(obj_pos_w) + ee_pos_des = _servo_target_to_fingers(state_name, obj_key, obj_pos_w, ee_pos_des) + + arm_jpos_des = ik_ctrl.compute(ee_pos_des.unsqueeze(0), ee_quat_des.unsqueeze(0)) + gripper_vals = _gripper_target_values(obj_key, gripper_cmd) + gripper_target = torch.tensor([gripper_vals], dtype=torch.float32, device=device) + + full_target = robot.data.joint_pos.clone() + full_target[:, arm_ids] = arm_jpos_des + full_target[:, gripper_ids] = gripper_target + env_action = (full_target - default_jpos) / ACTION_SCALE + + # Record BEFORE stepping (obs at time t, action at time t) + qpos_buf.append(robot.data.joint_pos[0].cpu().numpy()) + qvel_buf.append(robot.data.joint_vel[0].cpu().numpy()) + ee_pos_buf.append(ik_ctrl.ee_pos_w[0].cpu().numpy()) + ee_quat_buf.append(ik_ctrl.ee_quat_w[0].cpu().numpy()) + action_buf.append(env_action[0].cpu().numpy()) + if frames_buf is not None: + rgba = camera.data.output["rgb"][0].cpu().numpy() + frames_buf.append(rgba[:, :, :3]) + + _update_trace(state_name, obj_key, obj_pos_w) + _, _, terminated, truncated, _ = env.step(env_action) + + if abort_failed_lift and state_name == "LIFT" and sm.state != "LIFT": + final_obj_pos = env.unwrapped.scene.rigid_objects[obj_key].data.root_pos_w[0] + lift_gain = float((final_obj_pos[2] - obj_pos_w[2]).item()) + trace_gain = None + if trace_stats is not None and obj_key in trace_stats: + obj_stats = trace_stats[obj_key] + trace_gain = float(obj_stats["max_z"] - obj_stats["initial_pos"][2]) + effective_gain = max(lift_gain, trace_gain if trace_gain is not None else lift_gain) + if effective_gain < 0.035: + print( + f"[WARN] {obj_key} failed lift gate " + f"(z_gain={effective_gain:.3f}) - aborting attempt." + ) + return None + + if terminated.any() or truncated.any(): + if check_objects_in_basket(env, pick_objects): + print("[INFO] Episode ended after basket success; keeping demo.") + break + print("[WARN] Episode ended early — skipping demo.") + return None + + result = { + "qpos": np.stack(qpos_buf), + "qvel": np.stack(qvel_buf), + "ee_pos": np.stack(ee_pos_buf), + "ee_quat": np.stack(ee_quat_buf), + "action": np.stack(action_buf), + } + if frames_buf is not None: + result["frames"] = np.stack(frames_buf) + if trace_stats is not None: + for obj_idx in pick_objects: + obj_key = f"object_{obj_idx}" + if obj_key not in trace_stats: + continue + final_pos = env.unwrapped.scene.rigid_objects[obj_key].data.root_pos_w[0] + final_pos_cpu = [float(v) for v in final_pos.detach().cpu().tolist()] + obj_stats = trace_stats[obj_key] + obj_stats["final_pos"] = final_pos_cpu + obj_stats["z_gain"] = float(obj_stats["max_z"] - obj_stats["initial_pos"][2]) + obj_stats["lifted"] = bool(obj_stats["z_gain"] >= 0.035) + obj_stats["reward_lifted"] = bool(obj_stats["max_z"] >= TABLE_TOP_Z + 0.15) + obj_stats["basket_inside"] = check_objects_in_basket(env, [obj_idx]) + result["trace"] = trace_stats + return result + + +# ------------------------------------------------------------------ # +# Internal helper +# ------------------------------------------------------------------ # + +def _step_to(env, robot, ik_ctrl, arm_ids, gripper_ids, + ee_pos, ee_quat, gripper_target, default_jpos): + """Single IK step toward a target pose (utility used during warm-up/settle).""" + arm_des = ik_ctrl.compute(ee_pos, ee_quat) + tgt = robot.data.joint_pos.clone() + tgt[:, arm_ids] = arm_des + tgt[:, gripper_ids] = gripper_target + env.step((tgt - default_jpos) / ACTION_SCALE) + robot.update(dt=env.unwrapped.physics_dt) diff --git a/scripts/act/task_e/config.py b/scripts/act/task_e/config.py new file mode 100644 index 0000000000000000000000000000000000000000..3e3f705f6ac217cd1b40bdcebb6de0f645d38a96 --- /dev/null +++ b/scripts/act/task_e/config.py @@ -0,0 +1,295 @@ +"""Task E demo-collection constants. +""" + +from atec_rl_lab.tasks.task_e.env_cfg import ( + BASKET_CENTER_X, BASKET_CENTER_Y, + TABLE_CENTER_X, TABLE_CENTER_Y, TABLE_TOP_Z, TABLE_HALF_X, + BASKET_EXCL_HALF_X, BASKET_EXCL_HALF_Y, +) + +__all__ = [ + "BASKET_CENTER_X", "BASKET_CENTER_Y", + "TABLE_CENTER_X", "TABLE_CENTER_Y", "TABLE_TOP_Z", "TABLE_HALF_X", + "BASKET_EXCL_HALF_X", "BASKET_EXCL_HALF_Y", + # robot + "EE_BODY_NAME", "ARM_JOINT_NAMES", "GRIPPER_JOINT_NAMES", + "GRIPPER_OPEN_POS", "GRIPPER_CLOSE_POS", "OBJ_GRIPPER_CLOSE_POS", + "ACTION_SCALE", + # state machine + "STEPS", "STATE_ORDER", "OBJ_STATE_STEP_OVERRIDES", + # geometry + "PRE_GRASP_CLEARANCE", "GRASP_Z_OFFSET", "OBJ_GRASP_Z_OFFSETS", + "OBJ_CLOSE_Z_OFFSETS", + "OBJ_GRASP_YAW_OFFSETS", "OBJ_CARRY_Z", "OBJ_PLACE_HEIGHTS", + "OBJ_PLACE_XY_OFFSETS", "OBJ_TRANSPORT_GRIPPER_CMDS", + "OBJ_KEEP_GRASP_QUAT_STATES", "OBJ_TRANSPORT_PUSH_BIASES", + "OBJ_MANIPULATION_MODES", "OBJ_PUSH_GRIPPER_CMDS", + "OBJ_PUSH_APPROACH_CLEARANCE", + "OBJ_PUSH_X_GAINS", "OBJ_PUSH_MAX_X_CORRECTIONS", + "OBJ_PUSH_Y_GAINS", "OBJ_PUSH_MAX_Y_CORRECTIONS", + "OBJ_PUSH_MIN_BEHIND", + "OBJ_SERVO_TO_BASKET_STATES", "OBJ_SERVO_XY_GAINS", "OBJ_SERVO_MAX_XY", + "OBJ_SERVO_HOLD_STATES", "OBJ_SERVO_EXTRA_STEPS", + "OBJ_FINGER_CENTER_SERVO_STATES", "OBJ_FINGER_CENTER_SERVO_GAIN", + "OBJ_FINGER_CENTER_SERVO_MAX_XY", "OBJ_FINGER_CENTER_SERVO_TARGET_Z", + "OBJ_FINGER_CENTER_SERVO_MAX_Z", + "CARRY_Z", "PLACE_HEIGHT", + "RETRACT_POS_X", "RETRACT_POS_Y", + "DEFAULT_PLACE_QUAT_W", + # success check + "BASKET_IN_X", "BASKET_IN_Y", + # spawn regions + "OBJ_SPAWN_X_MIN", "OBJ_SPAWN_X_MAX", "OBJ_SPAWN_Z", "OBJ_SPAWN_Y_BANDS", + "OBJ_HALF_EXTENTS", "OBJ_BBOX_MARGIN", "OBJ_GRASP_CENTER_OFFSETS", + # camera + "CAM_POS", "CAM_ROT", "CAM_H", "CAM_W", + # actuator + "ACT_STIFFNESS", "ACT_DAMPING", "ACT_EFFORT_LIMIT", "ACT_VEL_LIMIT", + # warm-up + "WARMUP_STEPS", "SETTLE_STEPS", +] + +# ------------------------------------------------------------------ # +# Robot +# ------------------------------------------------------------------ # +EE_BODY_NAME = "gripper_base" +ARM_JOINT_NAMES = ["joint1", "joint2", "joint3", "joint4", "joint5", "joint6"] +GRIPPER_JOINT_NAMES = ["joint7", "joint8"] +GRIPPER_OPEN_POS = [0.035, -0.035] # joint7, joint8 +GRIPPER_CLOSE_POS = [0.0, 0.0] # joint limits: joint7 >= 0, joint8 <= 0 +OBJ_GRIPPER_CLOSE_POS: dict[int, list[float]] = {} + +# Must match ActionsCfg: scale=0.5, use_default_offset=True +# env_action = (joint_target - default_joint_pos) / ACTION_SCALE +ACTION_SCALE = 0.5 + +# ------------------------------------------------------------------ # +# State-machine +# ------------------------------------------------------------------ # +STEPS: dict[str, int] = { + "INIT": 100, + "PRE_GRASP": 220, + "REACH": 150, + "CLOSE": 80, + "LIFT": 170, + "TRANSPORT": 240, + "PLACE": 90, + "OPEN": 70, + "LIFT_RETRACT": 80, + "RETRACT": 80, +} +STATE_ORDER = ["INIT", "PRE_GRASP", "REACH", "CLOSE", "LIFT", + "TRANSPORT", "PLACE", "OPEN", "LIFT_RETRACT", "RETRACT"] +OBJ_STATE_STEP_OVERRIDES: dict[int, dict[str, int]] = { + 1: { + "TRANSPORT": 2200, + "PLACE": 300, + }, + 2: { + "TRANSPORT": 2200, + "PLACE": 300, + }, +} + +# ------------------------------------------------------------------ # +# Geometry +# ------------------------------------------------------------------ # +PRE_GRASP_CLEARANCE = 0.12 # metres above object before descent +GRASP_Z_OFFSET = 0.09 # metres: gripper approach height above object centre + +CARRY_Z = TABLE_TOP_Z + 0.40 # safe carry height +PLACE_HEIGHT = TABLE_TOP_Z + 0.15 # height at which to release into basket + +RETRACT_POS_X = TABLE_CENTER_X + TABLE_HALF_X - 0.05 +RETRACT_POS_Y = TABLE_CENTER_Y +DEFAULT_PLACE_QUAT_W = [0.0, 1.0, 0.0, 0.0] # top-down orientation (w,x,y,z) + +# ------------------------------------------------------------------ # +# Object spawn regions +# +# object_1 Y ∈ [0.25, 0.29] (top band) +# object_2 Y ∈ [0.14, 0.20] (middle band) +# object_3 Y ∈ [0.03, 0.09] (bottom band, closest to basket) +# ------------------------------------------------------------------ # +OBJ_SPAWN_X_MIN = TABLE_CENTER_X - 0.10 +OBJ_SPAWN_X_MAX = TABLE_CENTER_X + 0.10 +OBJ_SPAWN_Z = TABLE_TOP_Z + 0.05 + +# Per-object Y-bands: {object_idx: (y_min, y_max)} +OBJ_SPAWN_Y_BANDS = { + 1: (TABLE_CENTER_Y + 0.25, TABLE_CENTER_Y + 0.29), + 2: (TABLE_CENTER_Y + 0.14, TABLE_CENTER_Y + 0.20), + 3: (TABLE_CENTER_Y + 0.03, TABLE_CENTER_Y + 0.09), +} + +# Per-object 2-D bounding-box half-extents (metres, world XY plane, scale=1). +# Used for AABB overlap rejection during randomisation. +OBJ_HALF_EXTENTS: dict[int, tuple[float, float]] = { + 1: (0.050, 0.044), # Sugar box (half_x, half_y) + 2: (0.050, 0.030), # Mustard bottle + 3: (0.100, 0.040), # Banana +} +OBJ_BBOX_MARGIN = 0.015 # extra clearance between object bounding boxes + +# The object USD roots are centered on the visible geometry. Keep the XY target +# on the root/contact point; compensate the Piper TCP primarily in Z through +# OBJ_GRASP_Z_OFFSETS. +OBJ_GRASP_CENTER_OFFSETS: dict[int, tuple[float, float, float]] = { + 1: (0.025, 0.0, 0.0), # Sugar box: compensate Piper fingertip centre offset + 2: (0.060, 0.0, 0.0), # Mustard bottle: grasp a narrower side section + 3: (0.0, 0.0, 0.0), # Banana already works from its root pose +} +OBJ_GRASP_Z_OFFSETS: dict[int, float] = { + 1: 0.072, + 2: 0.135, + 3: GRASP_Z_OFFSET, +} +OBJ_CLOSE_Z_OFFSETS: dict[int, float] = { + 1: 0.020, +} +OBJ_GRASP_YAW_OFFSETS: dict[int, float] = { + 1: 0.0, + 2: 0.0, + 3: 0.0, +} +OBJ_CARRY_Z: dict[int, float] = { + 1: CARRY_Z, + 2: CARRY_Z, + 3: CARRY_Z, +} +OBJ_PLACE_HEIGHTS: dict[int, float] = { + 1: PLACE_HEIGHT, + 2: PLACE_HEIGHT, + 3: PLACE_HEIGHT, +} +OBJ_PLACE_XY_OFFSETS: dict[int, tuple[float, float]] = { + 1: (0.0, 0.0), + 2: (0.0, 0.0), + 3: (0.040, 0.050), +} +OBJ_TRANSPORT_GRIPPER_CMDS: dict[int, str] = { + 1: "close", + 2: "close", + 3: "close", +} +OBJ_KEEP_GRASP_QUAT_STATES: dict[int, tuple[str, ...]] = { + 1: ("REACH", "CLOSE", "LIFT", "TRANSPORT", "PLACE", "OPEN"), + 2: ("REACH", "CLOSE", "LIFT", "TRANSPORT", "PLACE", "OPEN"), + 3: ("REACH", "CLOSE", "LIFT"), +} +OBJ_TRANSPORT_PUSH_BIASES: dict[int, tuple[float, float, float] | None] = { + 1: None, + 2: None, + 3: None, +} + +# Optional manipulation mode used by the candidate search. "pick" keeps the +# normal top-down grasp. "push" turns the same state machine into a low, +# table-contact pusher that drives the object centre to the basket. +OBJ_MANIPULATION_MODES: dict[int, str] = { + 1: "pick", + 2: "pick", + 3: "pick", +} +OBJ_PUSH_GRIPPER_CMDS: dict[int, str] = { + 1: "close", + 2: "close", +} +OBJ_PUSH_APPROACH_CLEARANCE: dict[int, float] = { + 1: 0.14, + 2: 0.14, +} +OBJ_PUSH_X_GAINS: dict[int, float] = { + 1: 0.55, + 2: 0.55, +} +OBJ_PUSH_MAX_X_CORRECTIONS: dict[int, float] = { + 1: 0.08, + 2: 0.08, +} +OBJ_PUSH_Y_GAINS: dict[int, float] = { + 1: 0.85, + 2: 0.85, +} +OBJ_PUSH_MAX_Y_CORRECTIONS: dict[int, float] = { + 1: 0.22, + 2: 0.22, +} +OBJ_PUSH_MIN_BEHIND: dict[int, float] = { + 1: 0.035, + 2: 0.030, +} + +# For the hard objects, keep the arm target coupled to the measured object +# position during carry/release. This compensates for Piper gripper_base/TCP +# offsets and small slips: the EE target is nudged in the direction that would +# move the object centre into the basket. +OBJ_SERVO_TO_BASKET_STATES: dict[int, tuple[str, ...]] = { + 1: ("TRANSPORT", "PLACE", "OPEN"), + 2: (), +} +OBJ_SERVO_XY_GAINS: dict[int, float] = { + 1: 0.85, + 2: 0.85, +} +OBJ_SERVO_MAX_XY: dict[int, float] = { + 1: 0.28, + 2: 0.24, +} +OBJ_SERVO_HOLD_STATES: dict[int, tuple[str, ...]] = { + 1: ("PLACE",), + 2: ("PLACE",), +} +OBJ_SERVO_EXTRA_STEPS: dict[int, int] = { + 1: 500, + 2: 500, +} + +# Closed-loop correction used during scripted data generation. The target pose +# is nudged so the measured finger centre stays on the selected object centre, +# which absorbs IK/tracking variation across random object positions. +OBJ_FINGER_CENTER_SERVO_STATES: dict[int, tuple[str, ...]] = { + 1: ("REACH", "CLOSE", "LIFT", "TRANSPORT", "PLACE"), + 2: ("REACH", "CLOSE", "LIFT", "TRANSPORT", "PLACE"), +} +OBJ_FINGER_CENTER_SERVO_GAIN: dict[int, float] = { + 1: 1.0, + 2: 1.0, +} +OBJ_FINGER_CENTER_SERVO_MAX_XY: dict[int, float] = { + 1: 0.12, + 2: 0.12, +} +OBJ_FINGER_CENTER_SERVO_TARGET_Z: dict[int, float] = { + 1: -0.025, +} +OBJ_FINGER_CENTER_SERVO_MAX_Z: dict[int, float] = { + 1: 0.050, +} + +# ------------------------------------------------------------------ # +# Success / basket bounds +# ------------------------------------------------------------------ # +BASKET_IN_X = 0.20 # ± metres in X around BASKET_CENTER_X +BASKET_IN_Y = 0.11 # ± metres in Y around BASKET_CENTER_Y + +# ------------------------------------------------------------------ # +# Camera (for --save_video / --save_images) +# ------------------------------------------------------------------ # +CAM_H, CAM_W = 480, 640 +CAM_POS = (TABLE_CENTER_X - 1.2, TABLE_CENTER_Y, TABLE_TOP_Z + 0.8) +CAM_ROT = (0.957, 0.0, 0.290, 0.0) # ~34° around +Y → looks forward-down + +# ------------------------------------------------------------------ # +# Actuator overrides for data collection (high stiffness for fast tracking) +# ------------------------------------------------------------------ # +ACT_STIFFNESS = 800.0 +ACT_DAMPING = 80.0 +ACT_EFFORT_LIMIT = 100.0 +ACT_VEL_LIMIT = 100.0 + +# ------------------------------------------------------------------ # +# Warm-up / settle steps before recording starts +# ------------------------------------------------------------------ # +WARMUP_STEPS = 150 +SETTLE_STEPS = 30 diff --git a/scripts/act/task_e/state_machine.py b/scripts/act/task_e/state_machine.py new file mode 100644 index 0000000000000000000000000000000000000000..427b0f72f1ba47799ead7d85587047ba3f140fec --- /dev/null +++ b/scripts/act/task_e/state_machine.py @@ -0,0 +1,439 @@ +"""Pick-place state machine and grasp-quaternion solver for Task E.""" + +import torch +from isaaclab.utils.math import matrix_from_quat, quat_from_matrix + +from .config import ( + STEPS, STATE_ORDER, OBJ_STATE_STEP_OVERRIDES, + CARRY_Z, PLACE_HEIGHT, + RETRACT_POS_X, RETRACT_POS_Y, + GRASP_Z_OFFSET, OBJ_GRASP_Z_OFFSETS, OBJ_CLOSE_Z_OFFSETS, + OBJ_GRASP_YAW_OFFSETS, + BASKET_CENTER_X, BASKET_CENTER_Y, + DEFAULT_PLACE_QUAT_W, + OBJ_GRASP_CENTER_OFFSETS, + OBJ_CARRY_Z, OBJ_PLACE_HEIGHTS, OBJ_PLACE_XY_OFFSETS, + OBJ_TRANSPORT_GRIPPER_CMDS, OBJ_KEEP_GRASP_QUAT_STATES, + OBJ_TRANSPORT_PUSH_BIASES, + OBJ_MANIPULATION_MODES, OBJ_PUSH_GRIPPER_CMDS, + OBJ_PUSH_APPROACH_CLEARANCE, + OBJ_PUSH_X_GAINS, OBJ_PUSH_MAX_X_CORRECTIONS, + OBJ_PUSH_Y_GAINS, OBJ_PUSH_MAX_Y_CORRECTIONS, + OBJ_PUSH_MIN_BEHIND, + OBJ_SERVO_TO_BASKET_STATES, OBJ_SERVO_XY_GAINS, OBJ_SERVO_MAX_XY, + OBJ_SERVO_HOLD_STATES, OBJ_SERVO_EXTRA_STEPS, + BASKET_IN_X, BASKET_IN_Y, +) + + +def _build_grasp_matrix(long_axis: torch.Tensor, grip_z: torch.Tensor) -> torch.Tensor: + """Build a right-handed gripper rotation matrix given the object's long axis. + + The Piper gripper jaw opens along its LOCAL Y axis, so local Y must be + perpendicular to the object's long axis. + + Frame layout (columns of R_grip): + col 0 (local X) = align_dir ∥ long_axis + col 1 (local Y) = jaw_dir ⊥ long_axis ← jaw opening direction + col 2 (local Z) = grip_z pointing down + + Right-hand check: col0 × col1 = align_dir × jaw_dir = grip_z ✓ + """ + jaw_dir = torch.linalg.cross(long_axis, grip_z) # ⊥ long_axis, in XY plane + jaw_dir = jaw_dir / jaw_dir.norm().clamp(min=1e-6) + align_dir = torch.linalg.cross(jaw_dir, grip_z) # ∥ long_axis + align_dir = align_dir / align_dir.norm().clamp(min=1e-6) + return torch.stack([align_dir, jaw_dir, grip_z], dim=1) # (3, 3) + + +def compute_grasp_quat(obj_quat_w: torch.Tensor, device: str) -> torch.Tensor: + """Compute a top-down grasp quaternion for the object. + + Finds the object axis most aligned with the world XY-plane (the long axis), + builds a gripper frame where the jaw (local Y) is perpendicular to that axis, + then picks the candidate orientation closest to the default top-down pose. + + Parameters + ---------- + obj_quat_w : (4,) tensor, (w, x, y, z) + device : torch device string + + Returns + ------- + grasp_quat : (4,) tensor, (w, x, y, z) + """ + R_obj = matrix_from_quat(obj_quat_w.unsqueeze(0)).squeeze(0) # (3, 3) + grip_z = torch.tensor([0.0, 0.0, -1.0], device=device) + default_quat = torch.tensor(DEFAULT_PLACE_QUAT_W, dtype=torch.float32, device=device) + + # Project each object column-axis onto XY plane; keep the most horizontal one(s) + norms, axes_xy = [], [] + for col in range(3): + ax = torch.tensor([R_obj[0, col].item(), R_obj[1, col].item(), 0.0], device=device) + norms.append(ax.norm().item()) + axes_xy.append(ax) + + best_norm = max(norms) + candidates = [ + axes_xy[c] / max(norms[c], 1e-6) + for c in range(3) + if norms[c] >= best_norm - 1e-3 + ] + + # Among candidates, pick the one whose grasp frame is closest to the default orientation + best_cos = -2.0 + long_axis = candidates[0] + for cand in candidates: + q_cand = quat_from_matrix(_build_grasp_matrix(cand, grip_z).unsqueeze(0)).squeeze(0) + cos_sim = torch.abs((q_cand * default_quat).sum()).item() + if cos_sim > best_cos: + best_cos = cos_sim + long_axis = cand + + R_grip = _build_grasp_matrix(long_axis, grip_z) # (3, 3) + return quat_from_matrix(R_grip.unsqueeze(0)).squeeze(0) # (4,) w,x,y,z + + +def _quat_mul(q1: torch.Tensor, q2: torch.Tensor) -> torch.Tensor: + w1, x1, y1, z1 = q1.unbind() + w2, x2, y2, z2 = q2.unbind() + return torch.stack([ + w1 * w2 - x1 * x2 - y1 * y2 - z1 * z2, + w1 * x2 + x1 * w2 + y1 * z2 - z1 * y2, + w1 * y2 - x1 * z2 + y1 * w2 + z1 * x2, + w1 * z2 + x1 * y2 - y1 * x2 + z1 * w2, + ]) + + +class PickPlaceStateMachine: + """Finite state machine that sequences pick-and-place for multiple objects. + + States (in order): INIT → PRE_GRASP → REACH → CLOSE → LIFT → + TRANSPORT → PLACE → OPEN → RETRACT → (next object or done) + """ + + def __init__(self, object_indices: list[int], device: str): + self._obj_indices = object_indices + self._device = device + self._grasp_quat_cache: dict[int, torch.Tensor] = {} + self.reset() + + def reset(self) -> None: + self._ptr = 0 + self._state_idx = 0 + self._count = 0 + self.done = False + self._cached_obj_pos: torch.Tensor | None = None + self._servo_extra_counts: dict[tuple[int, str], int] = {} + self._grasp_quat_cache.clear() + + def set_grasp_quat(self, obj_idx: int, obj_quat_w: torch.Tensor) -> None: + """Pre-compute and cache the grasp quaternion for one object.""" + grasp_quat = compute_grasp_quat(obj_quat_w, self._device) + yaw = OBJ_GRASP_YAW_OFFSETS.get(obj_idx, 0.0) + if abs(yaw) > 1e-6: + half = torch.tensor(0.5 * yaw, dtype=torch.float32, device=self._device) + yaw_quat = torch.stack([ + torch.cos(half), + torch.tensor(0.0, dtype=torch.float32, device=self._device), + torch.tensor(0.0, dtype=torch.float32, device=self._device), + torch.sin(half), + ]) + grasp_quat = _quat_mul(yaw_quat, grasp_quat) + grasp_quat = grasp_quat / grasp_quat.norm().clamp(min=1e-6) + self._grasp_quat_cache[obj_idx] = grasp_quat + + def tick(self, obj_pos: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor, str]: + """Advance the state machine by one step. + + Parameters + ---------- + obj_pos : (3,) tensor — current object position in world frame + + Returns + ------- + ee_pos_des : (3,) target EE position + ee_quat_des : (4,) target EE orientation (w,x,y,z) + gripper_cmd : "open" | "close" + """ + s = self.state + d = self._device + + # Freeze object position at start of PRE_GRASP to avoid drift during descent + if s == "PRE_GRASP" and self._count == 0: + self._cached_obj_pos = obj_pos.clone() + if s in ("REACH", "CLOSE", "LIFT") and self._cached_obj_pos is not None: + obj_pos = self._cached_obj_pos + + ee_pos, gripper = self._get_target_pos_gripper(s, obj_pos, d) + ee_quat = self._get_target_quat(s, d) + + self._count += 1 + if self._count >= self._get_state_steps(s): + if self._should_hold_servo_state(s, obj_pos): + self._count = self._get_state_steps(s) - 1 + return ee_pos, ee_quat, gripper + self._count = 0 + if s == "RETRACT": + self._ptr += 1 + self._cached_obj_pos = None + if self._ptr >= len(self._obj_indices): + self.done = True + return ee_pos, ee_quat, gripper + self._state_idx = STATE_ORDER.index("PRE_GRASP") + else: + self._state_idx += 1 + + return ee_pos, ee_quat, gripper + + # ------------------------------------------------------------------ # + # Properties + # ------------------------------------------------------------------ # + + @property + def state(self) -> str: + return STATE_ORDER[self._state_idx] + + @property + def current_object_key(self) -> str: + return f"object_{self._obj_indices[self._ptr]}" + + # ------------------------------------------------------------------ # + # Private helpers + # ------------------------------------------------------------------ # + + def _get_target_pos_gripper( + self, s: str, obj_pos: torch.Tensor, d: str + ) -> tuple[torch.Tensor, str]: + if self._is_push_mode(): + return self._get_push_target_pos_gripper(s, obj_pos, d) + + grasp_pos = self._get_grasp_pos(obj_pos, d) + if s == "INIT": + return torch.tensor([RETRACT_POS_X, RETRACT_POS_Y, CARRY_Z], device=d), "open" + elif s == "PRE_GRASP": + p = grasp_pos.clone(); p[2] = CARRY_Z + return p, "open" + elif s == "REACH": + p = grasp_pos.clone(); p[2] += self._get_grasp_z_offset() + return p, "open" + elif s == "CLOSE": + p = grasp_pos.clone(); p[2] += self._get_close_z_offset() + return p, "close" + elif s == "LIFT": + p = grasp_pos.clone(); p[2] = self._get_carry_z() + return p, self._get_transport_gripper_cmd() + elif s == "TRANSPORT": + servo = self._get_object_servo_target(s, obj_pos, grasp_pos, self._get_carry_z(), d) + if servo is not None: + return servo, self._get_transport_gripper_cmd() + x, y = self._get_place_xy() + return torch.tensor([x, y, self._get_carry_z()], device=d), self._get_transport_gripper_cmd() + elif s == "PLACE": + servo = self._get_object_servo_target(s, obj_pos, grasp_pos, self._get_place_height(), d) + if servo is not None: + return servo, self._get_transport_gripper_cmd() + x, y = self._get_place_xy() + return torch.tensor([x, y, self._get_place_height()], device=d), self._get_transport_gripper_cmd() + elif s == "OPEN": + servo = self._get_object_servo_target(s, obj_pos, grasp_pos, self._get_place_height(), d) + if servo is not None: + return servo, "open" + x, y = self._get_place_xy() + return torch.tensor([x, y, self._get_place_height()], device=d), "open" + elif s == "LIFT_RETRACT": + return torch.tensor([BASKET_CENTER_X, BASKET_CENTER_Y, CARRY_Z], device=d), "open" + elif s == "RETRACT": + return torch.tensor([RETRACT_POS_X, RETRACT_POS_Y, CARRY_Z], device=d), "open" + else: + raise ValueError(f"Unknown state: {s}") + + def _get_grasp_pos(self, obj_pos: torch.Tensor, d: str) -> torch.Tensor: + cur_idx = self._obj_indices[min(self._ptr, len(self._obj_indices) - 1)] + offset = OBJ_GRASP_CENTER_OFFSETS.get(cur_idx, (0.0, 0.0, 0.0)) + return obj_pos + torch.tensor(offset, dtype=torch.float32, device=d) + + def _get_current_obj_idx(self) -> int: + return self._obj_indices[min(self._ptr, len(self._obj_indices) - 1)] + + def _is_push_mode(self) -> bool: + return OBJ_MANIPULATION_MODES.get(self._get_current_obj_idx(), "pick") == "push" + + def _get_push_gripper_cmd(self) -> str: + cur_idx = self._get_current_obj_idx() + return OBJ_PUSH_GRIPPER_CMDS.get(cur_idx, self._get_transport_gripper_cmd()) + + def _get_push_target_pos_gripper( + self, s: str, obj_pos: torch.Tensor, d: str + ) -> tuple[torch.Tensor, str]: + """Low table-contact pushing primitive for objects that do not pinch reliably.""" + cur_idx = self._get_current_obj_idx() + contact_obj_pos = self._cached_obj_pos if self._cached_obj_pos is not None else obj_pos + start = self._get_grasp_pos(contact_obj_pos, d) + z_low = self._get_place_height() + + if s == "INIT": + return torch.tensor([RETRACT_POS_X, RETRACT_POS_Y, CARRY_Z], device=d), "open" + if s == "PRE_GRASP": + p = start.clone() + p[2] = z_low + OBJ_PUSH_APPROACH_CLEARANCE.get(cur_idx, 0.14) + return p, "open" + if s in ("REACH", "CLOSE", "LIFT"): + p = start.clone() + p[2] = z_low + return p, self._get_push_gripper_cmd() + if s in ("TRANSPORT", "PLACE"): + place_x, place_y = self._get_place_xy() + target_xy = torch.tensor([place_x, place_y], dtype=torch.float32, device=d) + start_xy = contact_obj_pos[:2] + + x_err = place_x - obj_pos[0] + x_gain = OBJ_PUSH_X_GAINS.get(cur_idx, 0.55) + x_max = OBJ_PUSH_MAX_X_CORRECTIONS.get(cur_idx, 0.08) + x_corr = torch.clamp(x_err * x_gain, min=-x_max, max=x_max) + + progress = 1.0 + if s == "TRANSPORT": + progress = min((self._count + 1) / max(self._get_state_steps(s), 1), 1.0) + progress = min(progress * 1.35, 1.0) + ref_xy = start_xy + (target_xy - start_xy) * progress + p_live = torch.cat([ + ref_xy, + torch.tensor([z_low], dtype=torch.float32, device=d), + ]) + offset = torch.tensor( + OBJ_GRASP_CENTER_OFFSETS.get(cur_idx, (0.0, 0.0, 0.0)), + dtype=torch.float32, + device=d, + ) + p_live = p_live + offset + p_live[0] = p_live[0] + x_corr + + # Keep the pusher on the rear side of the object. If the reference + # sweep gets ahead of a lagging object, contact is lost or the object + # is knocked sideways instead of being driven into the basket. + min_behind = OBJ_PUSH_MIN_BEHIND.get(cur_idx, 0.03) + p_live[1] = torch.maximum( + p_live[1], + obj_pos[1] + torch.tensor(min_behind, dtype=torch.float32, device=d), + ) + + # During the hold phase, apply a bounded inward preload without + # allowing the pusher centre to cross in front of the object. + y_err = place_y - obj_pos[1] + y_gain = OBJ_PUSH_Y_GAINS.get(cur_idx, 0.85) + y_max = OBJ_PUSH_MAX_Y_CORRECTIONS.get(cur_idx, 0.22) + inward = torch.clamp(y_err * y_gain, min=-y_max, max=0.0) + p_live[1] = torch.maximum(p_live[1] + inward, obj_pos[1] + min_behind) + p_live[2] = z_low + + if s == "TRANSPORT": + p = start + (p_live - start) * min(progress * 3.0, 1.0) + else: + p = p_live + return p, self._get_push_gripper_cmd() + if s == "OPEN": + p = self._get_grasp_pos(obj_pos, d) + p[2] = z_low + return p, "open" + if s == "LIFT_RETRACT": + x, y = self._get_place_xy() + return torch.tensor([x, y, CARRY_Z], device=d), "open" + if s == "RETRACT": + return torch.tensor([RETRACT_POS_X, RETRACT_POS_Y, CARRY_Z], device=d), "open" + raise ValueError(f"Unknown state: {s}") + + def _get_grasp_z_offset(self) -> float: + cur_idx = self._get_current_obj_idx() + return OBJ_GRASP_Z_OFFSETS.get(cur_idx, GRASP_Z_OFFSET) + + def _get_close_z_offset(self) -> float: + cur_idx = self._get_current_obj_idx() + return OBJ_CLOSE_Z_OFFSETS.get(cur_idx, self._get_grasp_z_offset()) + + def _get_carry_z(self) -> float: + cur_idx = self._get_current_obj_idx() + return OBJ_CARRY_Z.get(cur_idx, CARRY_Z) + + def _get_place_height(self) -> float: + cur_idx = self._get_current_obj_idx() + return OBJ_PLACE_HEIGHTS.get(cur_idx, PLACE_HEIGHT) + + def _get_place_xy(self) -> tuple[float, float]: + cur_idx = self._get_current_obj_idx() + dx, dy = OBJ_PLACE_XY_OFFSETS.get(cur_idx, (0.0, 0.0)) + return BASKET_CENTER_X + dx, BASKET_CENTER_Y + dy + + def _get_transport_gripper_cmd(self) -> str: + cur_idx = self._get_current_obj_idx() + return OBJ_TRANSPORT_GRIPPER_CMDS.get(cur_idx, "close") + + def _get_state_steps(self, s: str) -> int: + cur_idx = self._get_current_obj_idx() + return OBJ_STATE_STEP_OVERRIDES.get(cur_idx, {}).get(s, STEPS[s]) + + def _get_transport_push_bias(self) -> tuple[float, float, float] | None: + cur_idx = self._get_current_obj_idx() + return OBJ_TRANSPORT_PUSH_BIASES.get(cur_idx) + + def _get_object_servo_target( + self, + s: str, + obj_pos: torch.Tensor, + grasp_pos: torch.Tensor, + z: float, + d: str, + ) -> torch.Tensor | None: + cur_idx = self._get_current_obj_idx() + if s not in OBJ_SERVO_TO_BASKET_STATES.get(cur_idx, ()): + push_bias = self._get_transport_push_bias() + if push_bias is None: + return None + p = grasp_pos + torch.tensor(push_bias, dtype=torch.float32, device=d) + p[2] = z + return p + + x, y = self._get_place_xy() + target_xy = torch.tensor([x, y], dtype=torch.float32, device=d) + xy_error = target_xy - obj_pos[:2] + gain = OBJ_SERVO_XY_GAINS.get(cur_idx, 1.0) + max_xy = OBJ_SERVO_MAX_XY.get(cur_idx, 0.25) + correction = xy_error * gain + norm = torch.linalg.norm(correction).clamp(min=1e-6) + if norm.item() > max_xy: + correction = correction / norm * max_xy + if s == "TRANSPORT": + progress = min((self._count + 1) / max(self._get_state_steps(s), 1), 1.0) + correction = correction * max(0.15, progress) + + p = grasp_pos.clone() + p[:2] = p[:2] + correction + push_bias = self._get_transport_push_bias() + if push_bias is not None: + p = p + torch.tensor(push_bias, dtype=torch.float32, device=d) + p[2] = z + return p + + def _should_hold_servo_state(self, s: str, obj_pos: torch.Tensor) -> bool: + cur_idx = self._get_current_obj_idx() + if s not in OBJ_SERVO_HOLD_STATES.get(cur_idx, ()): + return False + dx = abs(float(obj_pos[0].item() - BASKET_CENTER_X)) + dy = abs(float(obj_pos[1].item() - BASKET_CENTER_Y)) + if dx <= BASKET_IN_X * 0.85 and dy <= BASKET_IN_Y * 0.85: + return False + key = (cur_idx, s) + count = self._servo_extra_counts.get(key, 0) + if count >= OBJ_SERVO_EXTRA_STEPS.get(cur_idx, 0): + return False + self._servo_extra_counts[key] = count + 1 + return True + + def _get_target_quat(self, s: str, d: str) -> torch.Tensor: + default_quat = torch.tensor(DEFAULT_PLACE_QUAT_W, dtype=torch.float32, device=d) + cur_idx = self._get_current_obj_idx() + if self._is_push_mode() and s in ("REACH", "CLOSE", "LIFT", "TRANSPORT", "PLACE", "OPEN"): + return self._grasp_quat_cache.get(cur_idx, default_quat) + if s in OBJ_KEEP_GRASP_QUAT_STATES.get(cur_idx, ("REACH", "CLOSE", "LIFT")): + return self._grasp_quat_cache.get(cur_idx, default_quat) + return default_quat diff --git a/scripts/act/trace_task_e_policy.py b/scripts/act/trace_task_e_policy.py new file mode 100644 index 0000000000000000000000000000000000000000..961e2e10f2654cfc675e2834290e206d15f2213d --- /dev/null +++ b/scripts/act/trace_task_e_policy.py @@ -0,0 +1,84 @@ +"""Trace Task-E policy rollout with object positions at fixed intervals.""" + +import argparse +import os +import sys + +from isaaclab.app import AppLauncher + + +parser = argparse.ArgumentParser() +parser.add_argument("--checkpoint", required=True) +parser.add_argument("--solution_module", default="solution_act") +parser.add_argument("--task", default="ATEC-TaskE-Piper") +parser.add_argument("--seed", type=int, default=11) +parser.add_argument("--max_steps", type=int, default=1800) +parser.add_argument("--interval", type=int, default=100) +AppLauncher.add_app_launcher_args(parser) +args_cli = parser.parse_args() +args_cli.enable_cameras = True + +repo_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..")) +demo_dir = os.path.join(repo_root, "demo") +if repo_root not in sys.path: + sys.path.insert(0, repo_root) +if demo_dir not in sys.path: + sys.path.insert(0, demo_dir) +os.environ["ATEC_ACT_POLICY_PATH"] = os.path.abspath(args_cli.checkpoint) + +app_launcher = AppLauncher(args_cli) +simulation_app = app_launcher.app + +import importlib # noqa: E402 + +import gymnasium as gym # noqa: E402 +import torch # noqa: E402 +from isaaclab.envs import DirectMARLEnv, multi_agent_to_single_agent # noqa: E402 +from isaaclab_tasks.utils import parse_env_cfg # noqa: E402 + +import atec_rl_lab.tasks # noqa: F401,E402 +from scripts.act.task_e.collector import basket_status_lines # noqa: E402 + + +def _object_summary(env) -> str: + return " | ".join(basket_status_lines(env, [1, 2, 3])) + + +def main() -> None: + env_cfg = parse_env_cfg(args_cli.task, device=args_cli.device, num_envs=1) + env_cfg.seed = args_cli.seed + env = gym.make(args_cli.task, cfg=env_cfg) + if isinstance(env.unwrapped, DirectMARLEnv): + env = multi_agent_to_single_agent(env) + + policy = importlib.import_module(args_cli.solution_module).AlgSolution() + obs, _ = env.reset(seed=args_cli.seed) + policy.reset_episode() + total_reward = 0.0 + + try: + print(f"[TRACE_STEP] step=0 score=0.00 {_object_summary(env)}", flush=True) + for step in range(1, args_cli.max_steps + 1): + with torch.inference_mode(): + resp = policy.predicts(obs, total_reward) + action = torch.as_tensor(resp["action"], dtype=torch.float32, device=args_cli.device).view(1, -1) + obs, reward, terminated, truncated, info = env.step(action) + sim_dt = info["Step_dt"] + total_reward += reward.mean().item() / sim_dt if isinstance(reward, torch.Tensor) else float(reward) / sim_dt + if step % args_cli.interval == 0 or bool(terminated.item() or truncated.item()): + print( + f"[TRACE_STEP] step={step} score={total_reward:.2f} {_object_summary(env)}", + flush=True, + ) + if bool(terminated.item() or truncated.item()): + break + print(f"[RESULT] score={total_reward:.2f} steps={step}", flush=True) + finally: + env.close() + + +if __name__ == "__main__": + try: + main() + finally: + simulation_app.close() diff --git a/scripts/act/train_task_e.py b/scripts/act/train_task_e.py new file mode 100644 index 0000000000000000000000000000000000000000..ff87e0d224c887f737d4ca12ba5565b814bbba53 --- /dev/null +++ b/scripts/act/train_task_e.py @@ -0,0 +1,442 @@ +ALGO_NAME = 'BC_ACT' + +import os +import random +import time +from collections import defaultdict +from dataclasses import dataclass +from typing import Optional + +import h5py +import numpy as np +import torch +import torch.nn as nn +import torch.optim as optim +import torch.nn.functional as F +import torchvision.transforms as T +from torch.utils.data.dataset import Dataset +from torch.utils.data.sampler import RandomSampler, BatchSampler +from torch.utils.data.dataloader import DataLoader +from torch.utils.tensorboard import SummaryWriter +from diffusers.training_utils import EMAModel + +from atec_rl_lab.train.act.act.detr.backbone import build_backbone +from atec_rl_lab.train.act.act.detr.transformer import build_transformer +from atec_rl_lab.train.act.act.detr.detr_vae import build_encoder, DETRVAE +from atec_rl_lab.train.act.act.utils import IterationBasedBatchSampler, worker_init_fn +import tyro + + +@dataclass +class Args: + exp_name: Optional[str] = None + """the name of this experiment""" + seed: int = 1 + """seed of the experiment""" + torch_deterministic: bool = True + """if toggled, `torch.backends.cudnn.deterministic=False`""" + cuda: bool = True + """if toggled, cuda will be enabled by default""" + track: bool = False + """if toggled, this experiment will be tracked with Weights and Biases""" + wandb_project_name: str = "ATEC2026" + """the wandb's project name""" + wandb_entity: Optional[str] = None + """the entity (team) of wandb's project""" + + demo_path: str = './datasets/atec_task_e/trajectory.hdf5' + """path to the HDF5 demo dataset produced by collect_demos_task_e.py""" + num_demos: Optional[int] = None + """number of trajectories to load (None = all)""" + total_iters: int = 1_000_000 + """total training iterations""" + batch_size: int = 256 + """batch size""" + + # ACT specific + lr: float = 1e-4 + """learning rate""" + kl_weight: float = 10 + """weight for the KL loss term""" + temporal_agg: bool = True + """if toggled, temporal ensembling will be performed at inference""" + + # Backbone + position_embedding: str = 'sine' + backbone: str = 'resnet18' + lr_backbone: float = 1e-5 + masks: bool = False + dilation: bool = False + include_depth: bool = False + """always False — depth not collected; kept for backbone API compatibility""" + include_rgb: bool = True + """use RGB images as input (requires --save_images during collection)""" + + # Transformer + enc_layers: int = 2 + dec_layers: int = 4 + dim_feedforward: int = 512 + hidden_dim: int = 256 + dropout: float = 0.1 + nheads: int = 8 + num_queries: int = 30 + pre_norm: bool = False + use_xsa: bool = False + """replace transformer self-attention/FFN blocks with the local XSA variant""" + + log_freq: int = 1000 + """frequency of logging training metrics""" + save_freq: int = 5000 + """frequency of saving model checkpoints""" + num_dataload_workers: int = 0 + """number of DataLoader worker processes""" + resume_checkpoint: Optional[str] = None + """optional checkpoint to continue training from""" + resume_iter: Optional[int] = None + """absolute iteration for a legacy checkpoint that does not store train_iter""" + + +class DemoDataset_ACT(Dataset): + """Load IsaacLab Task-E HDF5 demos into memory. + + HDF5 structure (produced by collect_demos_task_e.py): + traj_N/obs (T, 8) joint positions (qpos) + traj_N/actions (T, 8) env actions + traj_N/images/rgb (T, H, W, 3) uint8 RGB — optional + """ + + def __init__(self, data_path: str, num_queries: int, + num_traj: Optional[int] = None, include_rgb: bool = True): + self.num_queries = num_queries + self.include_rgb = include_rgb + self.transforms = T.Resize((224, 224), antialias=True) + + # load raw data + states_list: list[torch.Tensor] = [] + actions_list: list[torch.Tensor] = [] + rgb_list: list[torch.Tensor] = [] # only when include_rgb is True + has_images = None + + with h5py.File(data_path, 'r') as f: + traj_keys = sorted(f.keys(), key=lambda k: int(k.split('_')[1])) + if num_traj is not None: + traj_keys = traj_keys[:num_traj] + + for key in traj_keys: + grp = f[key] + states_list.append(torch.from_numpy(grp['obs'][:].astype(np.float32))) + actions_list.append(torch.from_numpy(grp['actions'][:].astype(np.float32))) + + if include_rgb: + if has_images is None: + has_images = 'images' in grp + if has_images and 'images' in grp: + rgb_arr = grp['images/rgb'][:] # (T, H, W, 3) uint8 + rgb_t = torch.from_numpy(rgb_arr) # uint8 + # (T, 3, H, W) → resize → (T, 3, 224, 224) + rgb_t = self.transforms(rgb_t.permute(0, 3, 1, 2)) + # add camera dim → (T, 1, 3, 224, 224) + rgb_list.append(rgb_t.unsqueeze(1)) + + if has_images is None: + has_images = False + self.has_images = has_images and include_rgb and len(rgb_list) > 0 + + if include_rgb and not self.has_images: + print('[WARN] include_rgb=True but no images found in dataset. ' + 'Re-collect with --save_images, or set include_rgb=False.') + + self.num_traj = len(states_list) + self.states = states_list # list of (T, 8) + self.actions = actions_list # list of (T, 8) + self.rgb = rgb_list # list of (T, 1, 3, 224, 224) or empty + + # state/action dims + self.state_dim = self.states[0].shape[1] + self.act_dim = self.actions[0].shape[1] + + # index slices: (traj_idx, timestep) + self.slices = [ + (i, t) + for i, acts in enumerate(self.actions) + for t in range(acts.shape[0]) + ] + print(f'Loaded {self.num_traj} trajectories, {len(self.slices)} timesteps. ' + f'state_dim={self.state_dim}, act_dim={self.act_dim}, ' + f'has_images={self.has_images}') + + # normalisation stats (pd_joint_pos = absolute actions → normalise) + self.norm_stats = self._compute_norm_stats() + + # ------------------------------------------------------------------ + + def _pad_action(self, act_seq: torch.Tensor) -> torch.Tensor: + """Pad a short action chunk by repeating the last action.""" + shortage = self.num_queries - act_seq.shape[0] + if shortage > 0: + act_seq = torch.cat([act_seq, act_seq[-1:].repeat(shortage, 1)], dim=0) + return act_seq + + def _compute_norm_stats(self) -> dict: + # Vectorised: stack each full trajectory then slice — avoids 110k tiny ops + all_states = torch.cat(self.states, dim=0) # (total_T, state_dim) + all_actions = torch.cat(self.actions, dim=0) # (total_T, act_dim) + + state_mean = all_states.mean(0, keepdim=True) + state_std = all_states.std(0, keepdim=True).clamp(1e-2) + act_mean = all_actions.mean(0, keepdim=True) + act_std = all_actions.std(0, keepdim=True).clamp(1e-2) + + return dict(state_mean=state_mean, state_std=state_std, + action_mean=act_mean, action_std=act_std) + + def __len__(self): + return len(self.slices) + + def __getitem__(self, index): + traj_idx, ts = self.slices[index] + + state = self.states[traj_idx][ts] + act_seq = self._pad_action(self.actions[traj_idx][ts:ts + self.num_queries]) + + # normalise + state = (state - self.norm_stats['state_mean'][0]) / self.norm_stats['state_std'][0] + act_seq = (act_seq - self.norm_stats['action_mean']) / self.norm_stats['action_std'] + + obs = dict(state=state) + if self.has_images: + obs['rgb'] = self.rgb[traj_idx][ts] # (1, 3, 224, 224) uint8 + + return {'observations': obs, 'actions': act_seq} + + + +class Agent(nn.Module): + def __init__(self, state_dim: int, act_dim: int, args: Args): + super().__init__() + self.state_dim = state_dim + self.act_dim = act_dim + self.kl_weight = args.kl_weight + self.normalize = T.Normalize(mean=[0.485, 0.456, 0.406], + std=[0.229, 0.224, 0.225]) + self.include_rgb = args.include_rgb + + # CNN backbone — None for state-only mode (DETRVAE handles both paths) + backbones = [build_backbone(args)] if args.include_rgb else None + + # CVAE decoder + transformer = build_transformer(args) + + # CVAE encoder + encoder = build_encoder(args) + + # ACT ( CVAE encoder + (CNN backbones + CVAE decoder) ) + self.model = DETRVAE( + backbones, + transformer, + encoder, + state_dim=state_dim, + action_dim=act_dim, + num_queries=args.num_queries, + ) + + def _preprocess_rgb(self, obs: dict) -> None: + if self.include_rgb and 'rgb' in obs: + obs['rgb'] = obs['rgb'].float() / 255.0 + # obs['rgb']: (B, num_cams, 3, 224, 224) + B, N, C, H, W = obs['rgb'].shape + obs['rgb'] = self.normalize(obs['rgb'].view(B * N, C, H, W)).view(B, N, C, H, W) + + def _model_input(self, obs: dict): + # DETRVAE state-only path expects the state tensor directly, not a dict + return obs if self.include_rgb else obs['state'] + + def compute_loss(self, obs: dict, action_seq: torch.Tensor) -> dict: + self._preprocess_rgb(obs) + a_hat, (mu, logvar) = self.model(self._model_input(obs), action_seq) + + total_kld, _, _ = kl_divergence(mu, logvar) + l1 = F.l1_loss(action_seq, a_hat) + + return dict(l1=l1, kl=total_kld[0], + loss=l1 + total_kld[0] * self.kl_weight) + + def get_action(self, obs: dict) -> torch.Tensor: + self._preprocess_rgb(obs) + a_hat, _ = self.model(self._model_input(obs)) + return a_hat + + +def kl_divergence(mu, logvar): + if mu.data.ndimension() == 4: + mu = mu.view(mu.size(0), mu.size(1)) + logvar = logvar.view(logvar.size(0), logvar.size(1)) + klds = -0.5 * (1 + logvar - mu.pow(2) - logvar.exp()) + total_kld = klds.sum(1).mean(0, True) + dim_kld = klds.mean(0) + mean_kld = klds.mean(1).mean(0, True) + return total_kld, dim_kld, mean_kld + + +def save_ckpt(run_name: str, tag: str, train_iter: int) -> None: + os.makedirs(f'runs/{run_name}/checkpoints', exist_ok=True) + ema.copy_to(ema_agent.parameters()) + ckpt = { + 'norm_stats': dataset.norm_stats, + 'model_args': vars(args), + 'train_iter': train_iter, + 'agent': agent.state_dict(), + 'ema_agent': ema_agent.state_dict(), + 'optimizer': optimizer.state_dict(), + 'lr_scheduler': lr_scheduler.state_dict(), + } + if hasattr(ema, 'state_dict'): + ckpt['ema'] = ema.state_dict() + torch.save(ckpt, f'runs/{run_name}/checkpoints/{tag}.pt') + print(f'[INFO] Saved checkpoint: runs/{run_name}/checkpoints/{tag}.pt') + +if __name__ == '__main__': + args = tyro.cli(Args) + + if args.exp_name is None: + args.exp_name = os.path.basename(__file__)[:-len('.py')] + run_name = f"{args.exp_name}__{args.seed}__{int(time.time())}" + else: + run_name = args.exp_name + + # seeding + random.seed(args.seed) + np.random.seed(args.seed) + torch.manual_seed(args.seed) + torch.backends.cudnn.deterministic = args.torch_deterministic + + device = torch.device('cuda' if torch.cuda.is_available() and args.cuda else 'cpu') + + # dataset & dataloader + dataset = DemoDataset_ACT( + args.demo_path, + num_queries=args.num_queries, + num_traj=args.num_demos, + include_rgb=args.include_rgb, + ) + if args.num_demos is None: + args.num_demos = dataset.num_traj + + sampler = RandomSampler(dataset, replacement=False) + batch_sampler = BatchSampler(sampler, batch_size=args.batch_size, drop_last=True) + start_iter = 0 + batch_sampler = IterationBasedBatchSampler(batch_sampler, args.total_iters) + train_dataloader = DataLoader( + dataset, + batch_sampler=batch_sampler, + num_workers=args.num_dataload_workers, + worker_init_fn=lambda wid: worker_init_fn(wid, base_seed=args.seed), + ) + + # logging + if args.track: + import wandb + wandb.init( + project=args.wandb_project_name, + entity=args.wandb_entity, + sync_tensorboard=True, + config=vars(args), + name=run_name, + save_code=True, + group='ACT', + tags=['act'], + ) + writer = SummaryWriter(f'runs/{run_name}') + writer.add_text( + 'hyperparameters', + '|param|value|\n|-|-|\n' + + '\n'.join(f'|{k}|{v}|' for k, v in vars(args).items()), + ) + + # agent + agent = Agent(dataset.state_dim, dataset.act_dim, args).to(device) + ema_agent = Agent(dataset.state_dim, dataset.act_dim, args).to(device) + + param_dicts = [ + {'params': [p for n, p in agent.named_parameters() + if 'backbone' not in n and p.requires_grad]}, + {'params': [p for n, p in agent.named_parameters() + if 'backbone' in n and p.requires_grad], + 'lr': args.lr_backbone}, + ] + optimizer = optim.AdamW(param_dicts, lr=args.lr, weight_decay=1e-4) + lr_drop = max(int(2 / 3 * args.total_iters), 1) + lr_scheduler = optim.lr_scheduler.StepLR(optimizer, lr_drop) + ema = EMAModel(parameters=agent.parameters(), power=0.75) + + if args.resume_checkpoint: + ckpt = torch.load(args.resume_checkpoint, map_location=device, weights_only=False) + weight_key = 'agent' + if weight_key not in ckpt: + raise KeyError(f"Checkpoint {args.resume_checkpoint} has no '{weight_key}' weights") + agent.load_state_dict(ckpt[weight_key]) + if 'ema_agent' in ckpt: + ema_agent.load_state_dict(ckpt['ema_agent']) + if 'optimizer' in ckpt: + optimizer.load_state_dict(ckpt['optimizer']) + if 'lr_scheduler' in ckpt: + lr_scheduler.load_state_dict(ckpt['lr_scheduler']) + if 'ema' in ckpt and hasattr(ema, 'load_state_dict'): + ema.load_state_dict(ckpt['ema']) + start_iter = int(ckpt.get('train_iter') or args.resume_iter or 0) + if start_iter >= args.total_iters: + raise ValueError( + f"resume start_iter={start_iter} is >= total_iters={args.total_iters}; " + "increase --total_iters or choose an earlier checkpoint" + ) + print(f'[INFO] Resumed checkpoint {args.resume_checkpoint} at iter {start_iter}') + + # training loop + agent.train() + best_loss = float('inf') + timings = defaultdict(float) + + for local_iter, data_batch in enumerate(train_dataloader): + cur_iter = start_iter + local_iter + if cur_iter >= args.total_iters: + break + last_tick = time.time() + + obs_batch = {k: v.to(device, non_blocking=True) + for k, v in data_batch['observations'].items()} + act_batch = data_batch['actions'].to(device, non_blocking=True) + + loss_dict = agent.compute_loss(obs=obs_batch, action_seq=act_batch) + total_loss = loss_dict['loss'] + + optimizer.zero_grad() + total_loss.backward() + optimizer.step() + lr_scheduler.step() + ema.step(agent.parameters()) + + timings['update'] += time.time() - last_tick + + if cur_iter % args.log_freq == 0: + loss_val = total_loss.item() + print(f'Iter {cur_iter:7d} loss={loss_val:.4f} ' + f'l1={loss_dict["l1"].item():.4f} ' + f'kl={loss_dict["kl"].item():.4f}') + writer.add_scalar('charts/lr', optimizer.param_groups[0]['lr'], cur_iter) + writer.add_scalar('charts/lr_backbone', optimizer.param_groups[1]['lr'], cur_iter) + writer.add_scalar('losses/total', loss_val, cur_iter) + writer.add_scalar('losses/l1', loss_dict['l1'].item(), cur_iter) + writer.add_scalar('losses/kl', loss_dict['kl'].item(), cur_iter) + for k, v in timings.items(): + writer.add_scalar(f'time/{k}', v, cur_iter) + + if loss_val < best_loss: + best_loss = loss_val + save_ckpt(run_name, 'best_loss', cur_iter) + + if args.save_freq > 0 and cur_iter % args.save_freq == 0 and cur_iter > 0: + save_ckpt(run_name, str(cur_iter), cur_iter) + + save_ckpt(run_name, 'final', min(args.total_iters, cur_iter + 1)) + writer.close() + print(f'[INFO] Training done. Run: runs/{run_name}') diff --git a/scripts/graspnet_task_e/__init__.py b/scripts/graspnet_task_e/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9007990049cedd6403c3f8f6159c607c2dd5e15 --- /dev/null +++ b/scripts/graspnet_task_e/__init__.py @@ -0,0 +1,2 @@ +"""GraspNet adapters for ATEC Task E.""" + diff --git a/scripts/graspnet_task_e/anygrasp_adapter.py b/scripts/graspnet_task_e/anygrasp_adapter.py new file mode 100644 index 0000000000000000000000000000000000000000..bbc54a3f58df2009492f3e92f2c4307cf7f4e28d --- /dev/null +++ b/scripts/graspnet_task_e/anygrasp_adapter.py @@ -0,0 +1,228 @@ +"""AnyGrasp SDK bridge for ATEC Task E. + +AnyGrasp predicts grasp candidates from RGB-D point clouds in the camera frame. +For Task E we keep the same execution contract as the TunTun/GraspNet adapter: +use the model for contact centre, jaw yaw, score and width, then hand a +top-down-friendly world-frame ``TaskEGrasp`` to the existing Piper primitive. +""" + +from __future__ import annotations + +from functools import lru_cache +from pathlib import Path +import ctypes +import os +import sys + +import numpy as np +from scipy.spatial.transform import Rotation + +from scripts.graspnet_task_e.tuntun_adapter import TaskEGrasp, camera_arrays + + +REPO_ROOT = Path(__file__).resolve().parents[2] +ANYGRASP_ROOT = REPO_ROOT / "third_party" / "anygrasp_sdk" +DETECTION_ROOT = ANYGRASP_ROOT / "grasp_detection" +CHECKPOINT_PATH = DETECTION_ROOT / "log" / "checkpoint_detection.tar" +SSL11_DIR = Path( + "/home/ubuntu/projects/manipdojo2026/micromamba/envs/genmanip-sim/lib/python3.10/site-packages/" + "isaacsim/exts/omni.isaac.ros2_bridge/humble/lib" +) +TOOLS_DIR = REPO_ROOT / "tools" / "anygrasp" + + +def _ensure_anygrasp_paths() -> None: + det = str(DETECTION_ROOT) + if det not in sys.path: + sys.path.insert(0, det) + tools = str(TOOLS_DIR) + old_path = os.environ.get("PATH", "") + if TOOLS_DIR.exists() and tools not in old_path.split(":"): + os.environ["PATH"] = f"{tools}:{old_path}" if old_path else tools + ssl = str(SSL11_DIR) + old_ld = os.environ.get("LD_LIBRARY_PATH", "") + if SSL11_DIR.exists() and ssl not in old_ld.split(":"): + os.environ["LD_LIBRARY_PATH"] = f"{ssl}:{old_ld}" if old_ld else ssl + # lib_cxx.so is linked against OpenSSL 1.1. In long-running Isaac Python + # processes, changing LD_LIBRARY_PATH after startup is not enough, so load + # the exact libraries by absolute path before importing gsnet/lib_cxx. + for name in ("libcrypto.so.1.1", "libssl.so.1.1"): + path = SSL11_DIR / name + if path.exists(): + ctypes.CDLL(str(path), mode=ctypes.RTLD_GLOBAL) + + +def _check_anygrasp_files() -> None: + missing = [] + for path in [ + DETECTION_ROOT / "gsnet.so", + DETECTION_ROOT / "lib_cxx.so", + DETECTION_ROOT / "license" / "licenseCfg.json", + CHECKPOINT_PATH, + ]: + if not path.exists(): + missing.append(str(path)) + if missing: + raise FileNotFoundError("AnyGrasp SDK is not fully installed:\n" + "\n".join(missing)) + + +@lru_cache(maxsize=1) +def _load_anygrasp_detector(): + _ensure_anygrasp_paths() + _check_anygrasp_files() + from argparse import Namespace + from gsnet import AnyGrasp + + cfg = Namespace( + checkpoint_path=str(CHECKPOINT_PATH), + max_gripper_width=0.085, + gripper_height=0.03, + top_down_grasp=True, + debug=False, + ) + detector = AnyGrasp(cfg) + detector.load_net() + return detector + + +def _points_from_rgbd( + rgb: np.ndarray, + depth: np.ndarray, + mask: np.ndarray, + K: np.ndarray, + *, + expand_px: int = 0, +) -> tuple[np.ndarray, np.ndarray, np.ndarray]: + use_mask = mask > 0 + if expand_px > 0 and np.any(use_mask): + ys0, xs0 = np.where(use_mask) + y1 = max(int(ys0.min()) - expand_px, 0) + y2 = min(int(ys0.max()) + expand_px + 1, mask.shape[0]) + x1 = max(int(xs0.min()) - expand_px, 0) + x2 = min(int(xs0.max()) + expand_px + 1, mask.shape[1]) + use_mask = np.zeros_like(use_mask, dtype=bool) + use_mask[y1:y2, x1:x2] = True + valid = use_mask & np.isfinite(depth) & (depth > 0.0) & (depth < 6.0) + ys, xs = np.where(valid) + if len(xs) == 0: + raise RuntimeError("No valid masked depth points for AnyGrasp.") + + z = depth[ys, xs].astype(np.float32) + x = (xs.astype(np.float32) - float(K[0, 2])) / float(K[0, 0]) * z + y = (ys.astype(np.float32) - float(K[1, 2])) / float(K[1, 1]) * z + points = np.stack([x, y, z], axis=1).astype(np.float32) + colors = (rgb[ys, xs, :3].astype(np.float32) / 255.0).astype(np.float32) + return points, colors, np.stack([ys, xs], axis=1) + + +def _lims_for_points(points: np.ndarray, pad: float = 0.04) -> list[float]: + lo = points.min(axis=0) + hi = points.max(axis=0) + return [ + float(lo[0] - pad), + float(hi[0] + pad), + float(lo[1] - pad), + float(hi[1] + pad), + float(max(0.0, lo[2] - pad)), + float(hi[2] + pad), + ] + + +def _select_anygrasp_candidate(gg, points_cam: np.ndarray): + if gg is None or len(gg) == 0: + raise RuntimeError("AnyGrasp returned no grasps after filtering.") + gg = gg.nms().sort_by_score() + grasps = list(gg) + if not grasps: + raise RuntimeError("AnyGrasp returned no grasps after filtering.") + + center = np.median(points_cam, axis=0) + spread = float(np.linalg.norm(np.percentile(points_cam, 90, axis=0) - np.percentile(points_cam, 10, axis=0))) + spread = max(spread, 1e-3) + + def rank(g) -> float: + dist = float(np.linalg.norm(np.asarray(g.translation, dtype=np.float64) - center)) + # Keep score dominant, but reject edge candidates that are far from the + # segmented object core. This mirrors the proven GraspNet selector. + return float(g.score) * 0.65 + max(0.0, 1.0 - dist / spread) * 0.35 + + return max(grasps[:128], key=rank) + + +def infer_anygrasp_from_camera(camera, mask: np.ndarray) -> TaskEGrasp: + """Run AnyGrasp SDK and convert the selected grasp to Task-E world pose.""" + rgb, depth, K, pos_w, quat_wxyz_ros = camera_arrays(camera) + detector = _load_anygrasp_detector() + attempts = [ + (0, 0.04, True, False, True), + (0, 0.08, False, False, False), + (24, 0.08, False, False, False), + ] + last_error: Exception | None = None + points_cam = colors = None + grasp = None + for expand_px, lim_pad, apply_object_mask, dense_grasp, collision_detection in attempts: + try: + points_cam, colors, _pixels = _points_from_rgbd(rgb, depth, mask, K, expand_px=expand_px) + if len(points_cam) < 64: + raise RuntimeError(f"Too few masked points for AnyGrasp: {len(points_cam)}") + lims = _lims_for_points(points_cam, pad=lim_pad) + print( + "[ANYGRASP] " + f"points={len(points_cam)} expand_px={expand_px} lim_pad={lim_pad:.3f} " + f"object_mask={apply_object_mask} dense={dense_grasp} collision={collision_detection}", + flush=True, + ) + gg, _cloud = detector.get_grasp( + points_cam, + colors, + lims=lims, + apply_object_mask=apply_object_mask, + dense_grasp=dense_grasp, + collision_detection=collision_detection, + ) + grasp = _select_anygrasp_candidate(gg, points_cam) + break + except Exception as exc: + last_error = exc + print(f"[ANYGRASP] attempt failed: {exc}", flush=True) + if grasp is None or points_cam is None: + raise RuntimeError(f"AnyGrasp failed for all attempts: {last_error}") + + rot_w_cam = Rotation.from_quat( + [quat_wxyz_ros[1], quat_wxyz_ros[2], quat_wxyz_ros[3], quat_wxyz_ros[0]] + ).as_matrix() + t_cam = np.asarray(grasp.translation, dtype=np.float64) + t_w = rot_w_cam @ t_cam + pos_w + + pts_w = (rot_w_cam @ points_cam.astype(np.float64).T).T + pos_w + z_gate = float(np.percentile(pts_w[:, 2], 70)) + upper = pts_w[pts_w[:, 2] >= z_gate] + if len(upper) > 16: + t_w[:2] = np.median(upper[:, :2], axis=0) + else: + t_w[:2] = np.median(pts_w[:, :2], axis=0) + t_w[2] = float(np.percentile(pts_w[:, 2], 85)) + + R_cam_grasp = np.asarray(grasp.rotation_matrix, dtype=np.float64) + jaw_hint_w = rot_w_cam @ R_cam_grasp[:, 1] + jaw_xy = np.array([jaw_hint_w[0], jaw_hint_w[1], 0.0], dtype=np.float64) + if np.linalg.norm(jaw_xy) < 1e-6: + jaw_xy = np.array([0.0, 1.0, 0.0], dtype=np.float64) + jaw_xy = jaw_xy / np.linalg.norm(jaw_xy) + grip_z = np.array([0.0, 0.0, -1.0], dtype=np.float64) + align_x = np.cross(jaw_xy, grip_z) + align_x = align_x / max(np.linalg.norm(align_x), 1e-6) + jaw_y = np.cross(grip_z, align_x) + jaw_y = jaw_y / max(np.linalg.norm(jaw_y), 1e-6) + R_w_tool = np.stack([align_x, jaw_y, grip_z], axis=1) + quat_xyzw = Rotation.from_matrix(R_w_tool).as_quat() + quat_wxyz = np.array([quat_xyzw[3], quat_xyzw[0], quat_xyzw[1], quat_xyzw[2]], dtype=np.float64) + + return TaskEGrasp( + translation_w=t_w.astype(np.float64), + quat_wxyz_w=quat_wxyz, + score=float(grasp.score), + width=float(grasp.width), + raw_translation_cam=t_cam, + ) diff --git a/scripts/graspnet_task_e/debug_solution_pca_execution.py b/scripts/graspnet_task_e/debug_solution_pca_execution.py new file mode 100644 index 0000000000000000000000000000000000000000..dd3b3e01939140aa6f73cf2ece4cb02a7ec44874 --- /dev/null +++ b/scripts/graspnet_task_e/debug_solution_pca_execution.py @@ -0,0 +1,178 @@ +"""Measure execution error for demo.solution_pca in Task E. + +Uses simulator internals only for debugging: object root, gripper_base, link7, +and link8 positions. The submission policy still only receives observations. +""" + +from __future__ import annotations + +import argparse +import os +import sys +import time + +from isaaclab.app import AppLauncher + + +parser = argparse.ArgumentParser() +parser.add_argument("--task", type=str, default="ATEC-TaskE-Piper") +parser.add_argument("--seed", type=int, default=12) +parser.add_argument("--object", type=int, default=3) +parser.add_argument("--max_steps", type=int, default=2500) +parser.add_argument("--solution_module", type=str, default="solution_pca") +AppLauncher.add_app_launcher_args(parser) +args_cli = parser.parse_args() +args_cli.enable_cameras = True + +repo_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..")) +demo_dir = os.path.join(repo_root, "demo") +if repo_root not in sys.path: + sys.path.insert(0, repo_root) +if demo_dir not in sys.path: + sys.path.insert(0, demo_dir) + +app_launcher = AppLauncher(args_cli) +simulation_app = app_launcher.app + +import gymnasium as gym # noqa: E402 +import importlib # noqa: E402 +import numpy as np # noqa: E402 +import torch # noqa: E402 +from isaaclab.envs import DirectMARLEnv, multi_agent_to_single_agent # noqa: E402 +from isaaclab_tasks.utils import parse_env_cfg # noqa: E402 + +import atec_rl_lab.tasks # noqa: F401,E402 + + +def main() -> None: + env_cfg = parse_env_cfg(args_cli.task, device=args_cli.device, num_envs=1) + env_cfg.seed = args_cli.seed + env = gym.make(args_cli.task, cfg=env_cfg) + if isinstance(env.unwrapped, DirectMARLEnv): + env = multi_agent_to_single_agent(env) + + module = importlib.import_module(args_cli.solution_module) + AlgSolution = module.AlgSolution + policy = AlgSolution() + try: + obs, _ = env.reset(seed=args_cli.seed) + policy.reset_episode() + robot = env.unwrapped.scene.articulations["robot"] + obj = env.unwrapped.scene.rigid_objects[f"object_{args_cli.object}"] + gb_id = int(robot.find_bodies("gripper_base")[0][0]) + link7_id = int(robot.find_bodies("link7")[0][0]) + link8_id = int(robot.find_bodies("link8")[0][0]) + obj_initial = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64) + + best = { + "finger_dist": (999.0, None, 0, None), + "gb_dist": (999.0, None, 0, None), + "max_z_gain": (-999.0, None, 0, None), + "pin_finger_err": (999.0, None, 0, None), + "pin_gb_err": (999.0, None, 0, None), + } + stage_best = {} + pin_err_sum = {"finger": 0.0, "gb": 0.0} + pin_err_n = 0 + total_reward = 0.0 + start = time.time() + for step in range(args_cli.max_steps): + with torch.inference_mode(): + resp = policy.predicts(obs, total_reward) + action = torch.as_tensor(resp["action"], dtype=torch.float32, device=args_cli.device).view(1, -1) + obs, reward, terminated, truncated, info = env.step(action) + sim_dt = info["Step_dt"] + total_reward += reward.mean().item() / sim_dt if isinstance(reward, torch.Tensor) else float(reward) / sim_dt + + obj_pos = obj.data.root_pos_w[0, :3].detach().cpu().numpy().astype(np.float64) + gb = robot.data.body_pos_w[0, gb_id, :3].detach().cpu().numpy().astype(np.float64) + f7 = robot.data.body_pos_w[0, link7_id, :3].detach().cpu().numpy().astype(np.float64) + f8 = robot.data.body_pos_w[0, link8_id, :3].detach().cpu().numpy().astype(np.float64) + finger = 0.5 * (f7 + f8) + qpos = policy._obs_qpos(obs) + pin_finger = policy.ik.finger_center_world(qpos) + pin_gb_b, _ = policy.ik.fk_base(qpos[:6]) + pin_gb = module.BASE_POS_W + module.R_W_B @ pin_gb_b + gap = float(np.linalg.norm(f7 - f8)) + fd = float(np.linalg.norm(finger - obj_pos)) + gd = float(np.linalg.norm(gb - obj_pos)) + pfe = float(np.linalg.norm(pin_finger - finger)) + pge = float(np.linalg.norm(pin_gb - gb)) + pin_err_sum["finger"] += pfe + pin_err_sum["gb"] += pge + pin_err_n += 1 + zg = float(obj_pos[2] - obj_initial[2]) + plan_idx = getattr(policy, "plan_idx", -1) + target_step = getattr(policy, "step_in_target", -1) + label = "none" + plan = getattr(policy, "plan", None) + if isinstance(plan, list) and 0 <= plan_idx < len(plan): + label = getattr(plan[plan_idx], "label", str(plan_idx)) + stage = stage_best.setdefault( + label, + { + "min_finger": (999.0, None, 0, None), + "max_z_gain": (-999.0, None, 0, None), + "min_gap": (999.0, 0), + "last": None, + }, + ) + if fd < stage["min_finger"][0]: + stage["min_finger"] = (fd, finger - obj_pos, step, (plan_idx, target_step, gap, qpos[6], qpos[7])) + if zg > stage["max_z_gain"][0]: + stage["max_z_gain"] = (zg, obj_pos.copy(), step, (plan_idx, target_step, gap, qpos[6], qpos[7])) + if gap < stage["min_gap"][0]: + stage["min_gap"] = (gap, step) + stage["last"] = (finger - obj_pos, obj_pos.copy(), gap, qpos[6], qpos[7], step) + if fd < best["finger_dist"][0]: + best["finger_dist"] = (fd, finger - obj_pos, step, (plan_idx, target_step, gap)) + if gd < best["gb_dist"][0]: + best["gb_dist"] = (gd, gb - obj_pos, step, (plan_idx, target_step, gap)) + if zg > best["max_z_gain"][0]: + best["max_z_gain"] = (zg, obj_pos.copy(), step, (plan_idx, target_step, gap)) + if pfe < best["pin_finger_err"][0]: + best["pin_finger_err"] = (pfe, pin_finger - finger, step, (plan_idx, target_step, gap)) + if pge < best["pin_gb_err"][0]: + best["pin_gb_err"] = (pge, pin_gb - gb, step, (plan_idx, target_step, gap)) + if bool(terminated.item() or truncated.item()): + break + + final = obj.data.root_pos_w[0, :3].detach().cpu().numpy().astype(np.float64) + print(f"[EXEC_DEBUG] seed={args_cli.seed} obj={args_cli.object} score={total_reward:.2f} wall={time.time()-start:.1f}s") + print(f"[EXEC_DEBUG] initial=({obj_initial[0]:.4f},{obj_initial[1]:.4f},{obj_initial[2]:.4f}) final=({final[0]:.4f},{final[1]:.4f},{final[2]:.4f})") + if pin_err_n: + print(f"[EXEC_DEBUG] pin_mean_err finger={pin_err_sum['finger']/pin_err_n:.4f} gb={pin_err_sum['gb']/pin_err_n:.4f}") + for key, (value, vec, step, meta) in best.items(): + if vec is None: + print(f"[EXEC_DEBUG] {key}=none") + elif key == "max_z_gain": + print(f"[EXEC_DEBUG] {key}={value:.4f} obj=({vec[0]:.4f},{vec[1]:.4f},{vec[2]:.4f}) step={step} meta={meta}") + else: + print(f"[EXEC_DEBUG] {key}={value:.4f} vec=({vec[0]:+.4f},{vec[1]:+.4f},{vec[2]:+.4f}) step={step} meta={meta}") + for label, stats in stage_best.items(): + if not any(k in label for k in ("reach", "insert", "close", "lift", "mid", "release")): + continue + fd, fvec, fstep, fmeta = stats["min_finger"] + zg, zobj, zstep, zmeta = stats["max_z_gain"] + last = stats["last"] + if fvec is None or zobj is None or last is None: + continue + lvec, lobj, lgap, lq7, lq8, lstep = last + print( + f"[STAGE_DEBUG] label={label} min_fd={fd:.4f} " + f"min_vec=({fvec[0]:+.4f},{fvec[1]:+.4f},{fvec[2]:+.4f}) " + f"min_meta={fmeta} max_z_gain={zg:.4f} " + f"z_obj=({zobj[0]:.4f},{zobj[1]:.4f},{zobj[2]:.4f}) z_meta={zmeta} " + f"last_vec=({lvec[0]:+.4f},{lvec[1]:+.4f},{lvec[2]:+.4f}) " + f"last_obj=({lobj[0]:.4f},{lobj[1]:.4f},{lobj[2]:.4f}) " + f"last_gap={lgap:.4f} last_q=({lq7:.4f},{lq8:.4f}) last_step={lstep}" + ) + finally: + env.close() + + +if __name__ == "__main__": + try: + main() + finally: + simulation_app.close() diff --git a/scripts/graspnet_task_e/debug_solution_pca_perception.py b/scripts/graspnet_task_e/debug_solution_pca_perception.py new file mode 100644 index 0000000000000000000000000000000000000000..59afffaa9cf753335d5c61aea0fafd4c7246f04f --- /dev/null +++ b/scripts/graspnet_task_e/debug_solution_pca_perception.py @@ -0,0 +1,84 @@ +"""Compare submit-style RGB-D PCA estimates against Task-E simulator truth. + +This script uses simulator object roots only for debugging/calibration. It is +not part of the submission policy. +""" + +from __future__ import annotations + +import argparse +import os +import sys + +from isaaclab.app import AppLauncher + + +parser = argparse.ArgumentParser() +parser.add_argument("--task", type=str, default="ATEC-TaskE-Piper") +parser.add_argument("--seed", type=int, default=12) +parser.add_argument("--settle_steps", type=int, default=5) +AppLauncher.add_app_launcher_args(parser) +args_cli = parser.parse_args() +args_cli.enable_cameras = True + +repo_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..")) +demo_dir = os.path.join(repo_root, "demo") +if repo_root not in sys.path: + sys.path.insert(0, repo_root) +if demo_dir not in sys.path: + sys.path.insert(0, demo_dir) + +app_launcher = AppLauncher(args_cli) +simulation_app = app_launcher.app + +import gymnasium as gym # noqa: E402 +import numpy as np # noqa: E402 +import torch # noqa: E402 +from isaaclab.envs import DirectMARLEnv, multi_agent_to_single_agent # noqa: E402 +from isaaclab_tasks.utils import parse_env_cfg # noqa: E402 + +import atec_rl_lab.tasks # noqa: F401,E402 +import solution_pca # noqa: E402 + + +def main() -> None: + env_cfg = parse_env_cfg(args_cli.task, device=args_cli.device, num_envs=1) + env_cfg.seed = args_cli.seed + env = gym.make(args_cli.task, cfg=env_cfg) + if isinstance(env.unwrapped, DirectMARLEnv): + env = multi_agent_to_single_agent(env) + + policy = solution_pca.AlgSolution() + try: + obs, _ = env.reset(seed=args_cli.seed) + zero = torch.zeros((1, 8), dtype=torch.float32, device=args_cli.device) + for _ in range(max(0, args_cli.settle_steps)): + obs, *_ = env.step(zero) + + rgb, depth = policy._video_rgb_depth(obs) + print(f"[PERCEPTION_DEBUG] seed={args_cli.seed} settle_steps={args_cli.settle_steps}") + for obj_idx in (1, 2, 3): + est, rot = policy._estimate_grasp(rgb, depth, obj_idx) + pick_xy = est[:2] + solution_pca.OBJ_GRASP_CENTER_OFFSETS[obj_idx] + obj = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"] + truth = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64) + delta = est - truth + pick_delta = np.r_[pick_xy - truth[:2], est[2] - truth[2]] + jaw_yaw = float(np.arctan2(rot[1, 1], rot[0, 1])) + print( + "[PERCEPTION_DEBUG] " + f"obj={obj_idx} truth=({truth[0]:.4f},{truth[1]:.4f},{truth[2]:.4f}) " + f"est=({est[0]:.4f},{est[1]:.4f},{est[2]:.4f}) " + f"delta=({delta[0]:+.4f},{delta[1]:+.4f},{delta[2]:+.4f}) " + f"pick_delta=({pick_delta[0]:+.4f},{pick_delta[1]:+.4f},{pick_delta[2]:+.4f}) " + f"jaw_yaw={jaw_yaw:+.3f}" + ) + finally: + env.close() + + +if __name__ == "__main__": + try: + main() + finally: + simulation_app.close() diff --git a/scripts/graspnet_task_e/pca_aabb_adapter.py b/scripts/graspnet_task_e/pca_aabb_adapter.py new file mode 100644 index 0000000000000000000000000000000000000000..e19d0ff2911d6cbe18c7956bdfcc2e907e3ede41 --- /dev/null +++ b/scripts/graspnet_task_e/pca_aabb_adapter.py @@ -0,0 +1,114 @@ +"""GraspGen-style PCA/AABB grasp prior for ATEC Task E. + +This mirrors the core idea used by the PiPER GraspGen demo: reconstruct the +segmented RGB-D points, run PCA, build an oriented AABB, and use its center as a +geometric grasp prior. The Task-E runner may still override orientation with +the calibrated Piper quaternion. +""" + +from __future__ import annotations + +import numpy as np +from scipy.spatial.transform import Rotation + +from scripts.graspnet_task_e.tuntun_adapter import TaskEGrasp, camera_arrays + + +def _masked_world_points(camera, mask: np.ndarray) -> np.ndarray: + _rgb, depth, K, pos_w, quat_wxyz_ros = camera_arrays(camera) + valid = (mask > 0) & np.isfinite(depth) & (depth > 0.0) & (depth < 6.0) + if not np.any(valid): + raise RuntimeError("No valid masked depth points for PCA/AABB grasp.") + ys, xs = np.where(valid) + z = depth[ys, xs].astype(np.float64) + x = (xs.astype(np.float64) - float(K[0, 2])) / float(K[0, 0]) * z + y = (ys.astype(np.float64) - float(K[1, 2])) / float(K[1, 1]) * z + pts_cam = np.stack([x, y, z], axis=1) + rot_w_cam = Rotation.from_quat( + [quat_wxyz_ros[1], quat_wxyz_ros[2], quat_wxyz_ros[3], quat_wxyz_ros[0]] + ).as_matrix() + return (rot_w_cam @ pts_cam.T).T + pos_w + + +def _pca_aabb(points_w: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray, int]: + pts = np.asarray(points_w, dtype=np.float64) + if pts.shape[0] < 4: + raise RuntimeError("Too few points for PCA/AABB grasp.") + + centroid = np.mean(pts, axis=0) + centered = pts - centroid + covariance = (centered.T @ centered) / max(centered.shape[0] - 1, 1) + eigen_values, eigen_vectors = np.linalg.eigh(covariance) + + ev = eigen_vectors.copy() + ev[:, 2] = np.cross(ev[:, 0], ev[:, 1]) + ev[:, 1] = np.cross(ev[:, 2], ev[:, 0]) + ev[:, 0] = np.cross(ev[:, 1], ev[:, 2]) + for i in range(3): + norm = np.linalg.norm(ev[:, i]) + if norm > 1e-10: + ev[:, i] /= norm + + order = np.argsort(eigen_values)[::-1] + R = ev[:, order].copy() + if np.linalg.det(R) < 0: + R[:, 2] = -R[:, 2] + + local = (R.T @ (pts - centroid).T).T + min_pt = np.min(local, axis=0) + max_pt = np.max(local, axis=0) + extents = max_pt - min_pt + center_local = (min_pt + max_pt) * 0.5 + center_w = R @ center_local + centroid + grasp_axis = int(np.argmin(extents)) + return center_w.astype(np.float64), R.astype(np.float64), extents.astype(np.float64), grasp_axis + + +def infer_pca_aabb_from_camera(camera, mask: np.ndarray, object_index: int | None = None) -> TaskEGrasp: + """Return a GraspGen-style geometric grasp prior from segmented RGB-D.""" + pts_w = _masked_world_points(camera, mask) + + # Use the visible object body. Box/bottle masks are most stable with the + # upper visible surface median, while the banana's curved mask is less + # stable there and works better from the oriented AABB center. + center_w, R_pca, extents, grasp_axis = _pca_aabb(pts_w) + z_gate = float(np.percentile(pts_w[:, 2], 70)) + upper = pts_w[pts_w[:, 2] >= z_gate] + exec_center = center_w.copy() + if object_index != 3 and len(upper) > 16: + exec_center[:2] = np.median(upper[:, :2], axis=0) + exec_center[2] = float(np.percentile(pts_w[:, 2], 85)) + + if grasp_axis == 0: + jaw_hint_w = R_pca[:, 1] + elif grasp_axis == 1: + jaw_hint_w = R_pca[:, 0] + else: + jaw_hint_w = R_pca[:, 0] + + jaw_xy = np.array([jaw_hint_w[0], jaw_hint_w[1], 0.0], dtype=np.float64) + if np.linalg.norm(jaw_xy) < 1e-6: + jaw_xy = np.array([0.0, 1.0, 0.0], dtype=np.float64) + jaw_xy /= np.linalg.norm(jaw_xy) + grip_z = np.array([0.0, 0.0, -1.0], dtype=np.float64) + align_x = np.cross(jaw_xy, grip_z) + align_x /= max(np.linalg.norm(align_x), 1e-6) + jaw_y = np.cross(grip_z, align_x) + jaw_y /= max(np.linalg.norm(jaw_y), 1e-6) + R_w_tool = np.stack([align_x, jaw_y, grip_z], axis=1) + quat_xyzw = Rotation.from_matrix(R_w_tool).as_quat() + quat_wxyz = np.array([quat_xyzw[3], quat_xyzw[0], quat_xyzw[1], quat_xyzw[2]], dtype=np.float64) + + width = float(extents[grasp_axis]) + score = 1.0 / (1.0 + float(np.linalg.norm(extents))) + print( + f"[PCA_AABB] points={len(pts_w)} extents=({extents[0]:.3f},{extents[1]:.3f},{extents[2]:.3f}) " + f"axis={grasp_axis} width={width:.3f}" + ) + return TaskEGrasp( + translation_w=exec_center.astype(np.float64), + quat_wxyz_w=quat_wxyz, + score=score, + width=width, + raw_translation_cam=np.zeros(3, dtype=np.float64), + ) diff --git a/scripts/graspnet_task_e/run_anygrasp_pick.sh b/scripts/graspnet_task_e/run_anygrasp_pick.sh new file mode 100644 index 0000000000000000000000000000000000000000..41a0aa3998e003de5b7c84f8e1bb38ff8d7dd754 --- /dev/null +++ b/scripts/graspnet_task_e/run_anygrasp_pick.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash +set -euo pipefail + +REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)" +PYTHON_BIN="${PYTHON_BIN:-/home/ubuntu/envs/genmanip-isaac5-py311/bin/python}" + +OBJ="${1:-3}" +if (( $# > 0 )); then + shift +fi +SEED="${1:-11}" +if (( $# > 0 )); then + shift +fi +MASK_PROVIDER="${MASK_PROVIDER:-oracle}" +VIDEO_PATH="${VIDEO_PATH:-logs/videos/task_e_anygrasp/anygrasp_obj${OBJ}_seed${SEED}.mp4}" +DEBUG_NPZ="${DEBUG_NPZ:-logs/anygrasp_task_e/obj${OBJ}_seed${SEED}_debug.npz}" + +cd "${REPO_ROOT}" + +exec env OMNI_KIT_ACCEPT_EULA=YES PYTHONUNBUFFERED=1 "${PYTHON_BIN}" \ + scripts/graspnet_task_e/run_graspnet_pick.py \ + --grasp_provider anygrasp \ + --object "${OBJ}" \ + --seed "${SEED}" \ + --mask_provider "${MASK_PROVIDER}" \ + --use_task_quat \ + --tcp_z_offset 0.040 \ + --close_z_offset -0.020 \ + --close_steps 160 \ + --move_steps 200 \ + --transport_steps 1400 \ + --place_steps 260 \ + --video_path "${VIDEO_PATH}" \ + --save_debug_npz "${DEBUG_NPZ}" \ + --headless \ + "$@" diff --git a/scripts/graspnet_task_e/run_graspnet_pick.py b/scripts/graspnet_task_e/run_graspnet_pick.py new file mode 100644 index 0000000000000000000000000000000000000000..1e7fd5e25b8ba5fa0948afe35af583b8fb8af002 --- /dev/null +++ b/scripts/graspnet_task_e/run_graspnet_pick.py @@ -0,0 +1,844 @@ +"""Smoke-test a GraspNet-guided Task-E pick-and-place primitive. + +This is intentionally separate from ACT training. It tests whether TunTunClaw +GraspNet can produce a usable grasp centre/yaw from Task-E RGB-D observations. +""" + +from __future__ import annotations + +import argparse +import os +import subprocess +import sys +from pathlib import Path +import json + + +REPO_ROOT = Path(__file__).resolve().parents[2] +if str(REPO_ROOT) not in sys.path: + sys.path.insert(0, str(REPO_ROOT)) + +from isaaclab.app import AppLauncher + + +parser = argparse.ArgumentParser(description="Run one Task-E grasp-guided pick trial.") +parser.add_argument("--grasp_provider", choices=["graspnet", "anygrasp", "pca"], default="graspnet") +parser.add_argument("--object", type=int, default=1, choices=[1, 2, 3]) +parser.add_argument("--seed", type=int, default=7) +parser.add_argument("--video_path", default="logs/videos/task_e_graspnet/graspnet_pick_obj1.mp4") +parser.add_argument("--tcp_z_offset", type=float, default=0.055) +parser.add_argument("--close_z_offset", type=float, default=None) +parser.add_argument("--pregrasp_z", type=float, default=0.30) +parser.add_argument("--lift_z", type=float, default=0.30) +parser.add_argument("--place_z", type=float, default=0.18) +parser.add_argument("--release_z", type=float, default=0.32) +parser.add_argument("--open_release_z", type=float, default=None) +parser.add_argument("--place_x_offset", type=float, default=0.0) +parser.add_argument("--place_y_offset", type=float, default=0.0) +parser.add_argument("--basket_center_release", action=argparse.BooleanOptionalAction, default=True) +parser.add_argument("--basket_servo_gain", type=float, default=1.0) +parser.add_argument("--basket_servo_max_xy", type=float, default=0.30) +parser.add_argument("--staged_transport", action=argparse.BooleanOptionalAction, default=True) +parser.add_argument("--transport_servo_fraction", type=float, default=0.25) +parser.add_argument("--basket_xy_tol", type=float, default=0.055) +parser.add_argument("--basket_hold_steps", type=int, default=900) +parser.add_argument("--basket_stable_steps", type=int, default=80) +parser.add_argument("--basket_recovery_steps", type=int, default=900) +parser.add_argument("--dynamic_finger_servo", action=argparse.BooleanOptionalAction, default=True) +parser.add_argument("--close_steps", type=int, default=70) +parser.add_argument("--preclose_insert_steps", type=int, default=0) +parser.add_argument("--preclose_insert_dx", type=float, default=0.0) +parser.add_argument("--preclose_insert_dy", type=float, default=0.0) +parser.add_argument("--move_steps", type=int, default=160) +parser.add_argument("--transport_steps", type=int, default=None) +parser.add_argument("--place_steps", type=int, default=None) +parser.add_argument("--settle_steps", type=int, default=120) +parser.add_argument("--force_default_quat", action="store_true") +parser.add_argument("--use_task_quat", action="store_true") +parser.add_argument("--no_finger_servo", action="store_true") +parser.add_argument("--no_object_offset", action="store_true") +parser.add_argument("--post_push", action="store_true") +parser.add_argument("--auto_table_push_on_slip", action=argparse.BooleanOptionalAction, default=True) +parser.add_argument("--post_push_steps", type=int, default=600) +parser.add_argument("--post_push_behind", type=float, default=0.075) +parser.add_argument("--post_push_z", type=float, default=0.055) +parser.add_argument("--drag_recovery_steps", type=int, default=1200) +parser.add_argument("--mask_provider", choices=["oracle", "band", "sam3"], default="oracle") +parser.add_argument( + "--sam3_python", + default="/home/ubuntu/Documents/01Proj/sam3d_gs/.venv/bin/python", + help="Python executable for the isolated SAM3 environment.", +) +parser.add_argument("--sam3_threshold", type=float, default=0.35) +parser.add_argument("--sam3_mask_threshold", type=float, default=0.5) +parser.add_argument( + "--sam3_prompt", + action="append", + default=None, + help="SAM3 text prompt. Can repeat. Defaults are selected from --object.", +) +parser.add_argument("--save_debug_npz", default="logs/graspnet_task_e/latest_debug.npz") +AppLauncher.add_app_launcher_args(parser) +args_cli = parser.parse_args() +args_cli.enable_cameras = True + +app_launcher = AppLauncher(args_cli) +simulation_app = app_launcher.app + +import imageio.v2 as imageio +import numpy as np +import torch + +from isaaclab.actuators import ImplicitActuatorCfg +from isaaclab.envs import ManagerBasedRLEnv + +from atec_rl_lab.tasks.task_e.env_cfg import ( + BASKET_CENTER_X, + BASKET_CENTER_Y, + TABLE_TOP_Z, + TaskEEnvPiperCfg, +) +from atec_rl_lab.utils import CartesianController + +from scripts.act.task_e.collector import basket_status_lines, check_objects_in_basket +from scripts.act.task_e.config import ( + ACTION_SCALE, + ACT_DAMPING, + ACT_EFFORT_LIMIT, + ACT_STIFFNESS, + ACT_VEL_LIMIT, + ARM_JOINT_NAMES, + CARRY_Z, + DEFAULT_PLACE_QUAT_W, + EE_BODY_NAME, + GRIPPER_CLOSE_POS, + GRIPPER_JOINT_NAMES, + GRIPPER_OPEN_POS, + OBJ_GRASP_CENTER_OFFSETS, + OBJ_GRASP_Z_OFFSETS, + OBJ_CLOSE_Z_OFFSETS, + OBJ_FINGER_CENTER_SERVO_GAIN, + OBJ_FINGER_CENTER_SERVO_MAX_XY, + OBJ_FINGER_CENTER_SERVO_TARGET_Z, + OBJ_FINGER_CENTER_SERVO_MAX_Z, + RETRACT_POS_X, + RETRACT_POS_Y, +) +from scripts.act.task_e.state_machine import compute_grasp_quat +from scripts.graspnet_task_e.tuntun_adapter import ( + camera_arrays, + infer_grasp_from_camera, + oracle_object_mask, + rgbd_band_object_mask, + pos_to_torch, + quat_wxyz_to_torch, +) +from scripts.graspnet_task_e.anygrasp_adapter import infer_anygrasp_from_camera +from scripts.graspnet_task_e.pca_aabb_adapter import infer_pca_aabb_from_camera + + +GRASPNET_CLOSE_Z_DEFAULTS = { + 3: -0.005, +} + +SAM_MASK_P85_Z_MAX = { + 1: TABLE_TOP_Z + 0.13, + 2: TABLE_TOP_Z + 0.19, + 3: TABLE_TOP_Z + 0.085, +} + + +def build_env() -> ManagerBasedRLEnv: + cfg = TaskEEnvPiperCfg() + cfg.seed = args_cli.seed + cfg.scene.num_envs = 1 + cfg.episode_length_s = 90.0 + cfg.scene.robot.actuators["default"] = ImplicitActuatorCfg( + joint_names_expr=[".*"], + effort_limit=ACT_EFFORT_LIMIT, + velocity_limit=ACT_VEL_LIMIT, + stiffness=ACT_STIFFNESS, + damping=ACT_DAMPING, + ) + return ManagerBasedRLEnv(cfg) + + +def step_pose( + env, + robot, + ik_ctrl, + arm_ids, + gripper_ids, + default_jpos, + pos_w, + quat_w, + gripper, + frames, + camera, + n_steps, + *, + obj_idx: int | None = None, + obj=None, + finger_body_indices: tuple[int, int] | None = None, + servo_center_xy: np.ndarray | None = None, + servo_current_object_xy: bool = False, + finger_target_xy: np.ndarray | None = None, + finger_target_z: float | None = None, + finger_servo_gain: float = 1.0, + finger_servo_max_xy: float = 0.12, + finger_servo_max_z: float = 0.04, + object_target_xy: np.ndarray | None = None, + object_servo_gain: float = 1.0, + object_servo_max_xy: float = 0.30, +) -> dict[str, float | list[float] | None]: + dev = env.unwrapped.device + pos_np = np.asarray(pos_w, dtype=np.float64) + quat_t = quat_wxyz_to_torch(np.asarray(quat_w, dtype=np.float64), dev) + grip_t = torch.tensor([gripper], dtype=torch.float32, device=dev) + stats: dict[str, float | list[float] | None] = { + "min_finger_dist": None, + "min_finger_vec": None, + "min_finger_gap": None, + "min_finger_q": None, + "last_finger_q": None, + } + for _ in range(n_steps): + target_np = pos_np.copy() + if obj is not None and object_target_xy is not None: + obj_pos = obj.data.root_pos_w[0].detach() + target_xy = torch.tensor(object_target_xy, dtype=torch.float32, device=dev) + xy_error = target_xy - obj_pos[:2] + correction = xy_error * object_servo_gain + corr_norm = torch.linalg.norm(correction).clamp(min=1e-6) + if corr_norm.item() > object_servo_max_xy: + correction = correction / corr_norm * object_servo_max_xy + target_np[:2] = target_np[:2] + correction.detach().cpu().numpy() + if finger_body_indices is not None and not args_cli.no_finger_servo and ( + finger_target_xy is not None or (obj_idx is not None and obj is not None and servo_center_xy is not None) + ): + f0 = robot.data.body_pos_w[0, finger_body_indices[0], :3].detach() + f1 = robot.data.body_pos_w[0, finger_body_indices[1], :3].detach() + finger_center = 0.5 * (f0 + f1) + obj_pos = obj.data.root_pos_w[0].detach() if obj is not None else None + if finger_target_xy is not None: + target_xy = torch.tensor(finger_target_xy, dtype=torch.float32, device=dev) + elif servo_current_object_xy and obj_pos is not None: + target_xy = obj_pos[:2] + else: + target_xy = torch.tensor(servo_center_xy, dtype=torch.float32, device=dev) + grasp_center = torch.tensor( + [ + float(target_xy[0].item()), + float(target_xy[1].item()), + float(obj_pos[2].item()) if obj_pos is not None else float(finger_center[2].item()), + ], + dtype=torch.float32, + device=dev, + ) + finger_vec = finger_center - grasp_center + finger_dist = float(torch.linalg.norm(finger_vec).item()) + finger_gap = float(torch.linalg.norm(f0 - f1).item()) + if stats["min_finger_dist"] is None or finger_dist < float(stats["min_finger_dist"]): + stats["min_finger_dist"] = finger_dist + stats["min_finger_vec"] = [float(v) for v in finger_vec.detach().cpu().tolist()] + if stats["min_finger_gap"] is None or finger_gap < float(stats["min_finger_gap"]): + stats["min_finger_gap"] = finger_gap + q = robot.data.joint_pos[0, gripper_ids].detach().cpu().numpy() + stats["min_finger_q"] = [float(q[0]), float(q[1])] + q = robot.data.joint_pos[0, gripper_ids].detach().cpu().numpy() + stats["last_finger_q"] = [float(q[0]), float(q[1])] + xy_error = finger_center[:2] - target_xy + if finger_target_xy is not None or servo_current_object_xy or torch.linalg.norm(xy_error).item() <= 0.18: + gain = finger_servo_gain if finger_target_xy is not None else OBJ_FINGER_CENTER_SERVO_GAIN.get(obj_idx, 0.85) + correction = -xy_error * gain + max_xy = finger_servo_max_xy if finger_target_xy is not None else OBJ_FINGER_CENTER_SERVO_MAX_XY.get(obj_idx, 0.08) + corr_norm = torch.linalg.norm(correction).clamp(min=1e-6) + if corr_norm.item() > max_xy: + correction = correction / corr_norm * max_xy + target_np[:2] = target_np[:2] + correction.detach().cpu().numpy() + if finger_target_z is not None: + z_error = finger_target_z - float(finger_center[2].item()) + z_correction = max(-finger_servo_max_z, min(finger_servo_max_z, z_error * gain)) + target_np[2] = target_np[2] + z_correction + elif obj_pos is not None and obj_idx in OBJ_FINGER_CENTER_SERVO_TARGET_Z: + target_rel_z = OBJ_FINGER_CENTER_SERVO_TARGET_Z[obj_idx] + z_error = target_rel_z - float((finger_center[2] - obj_pos[2]).item()) + max_z = OBJ_FINGER_CENTER_SERVO_MAX_Z.get(obj_idx, 0.02) + z_correction = min(0.0, max(-max_z, z_error * gain)) + target_np[2] = target_np[2] + z_correction + pos_t = pos_to_torch(target_np, dev) + arm_des = ik_ctrl.compute(pos_t, quat_t) + target = robot.data.joint_pos.clone() + target[:, arm_ids] = arm_des + target[:, gripper_ids] = grip_t + action = (target - default_jpos) / ACTION_SCALE + env.step(action) + robot.update(dt=env.unwrapped.physics_dt) + if frames is not None: + rgba = camera.data.output["rgb"][0].detach().cpu().numpy() + frames.append(rgba[..., :3]) + return stats + + +def step_until_object_center_stable( + env, + robot, + ik_ctrl, + arm_ids, + gripper_ids, + default_jpos, + pos_w, + quat_w, + gripper, + frames, + camera, + *, + obj, + target_xy: np.ndarray, + xy_tol: float, + stable_steps: int, + max_steps: int, + object_servo_gain: float, + object_servo_max_xy: float, + obj_idx: int | None = None, + finger_body_indices: tuple[int, int] | None = None, + servo_center_xy: np.ndarray | None = None, + servo_current_object_xy: bool = True, +) -> dict[str, float | int | list[float]]: + stable = 0 + min_xy_err = 999.0 + last_obj_pos = None + for step in range(max_steps): + step_pose( + env, + robot, + ik_ctrl, + arm_ids, + gripper_ids, + default_jpos, + pos_w, + quat_w, + gripper, + frames, + camera, + 1, + obj_idx=obj_idx, + obj=obj, + finger_body_indices=finger_body_indices, + servo_center_xy=servo_center_xy, + servo_current_object_xy=servo_current_object_xy, + object_target_xy=target_xy, + object_servo_gain=object_servo_gain, + object_servo_max_xy=object_servo_max_xy, + ) + obj_pos = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64) + last_obj_pos = obj_pos + xy_err = float(np.linalg.norm(obj_pos[:2] - target_xy)) + min_xy_err = min(min_xy_err, xy_err) + if xy_err <= xy_tol: + stable += 1 + if stable >= stable_steps: + break + else: + stable = 0 + if last_obj_pos is None: + last_obj_pos = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64) + return { + "steps": step + 1 if max_steps > 0 else 0, + "stable": stable, + "min_xy_err": min_xy_err, + "final_xy_err": float(np.linalg.norm(last_obj_pos[:2] - target_xy)), + "final_obj_pos": [float(v) for v in last_obj_pos.tolist()], + } + + +def sam3_prompts_for_object(obj_idx: int) -> list[str]: + defaults = { + 1: ["sugar box", "box", "rectangular object"], + 2: ["mustard bottle", "bottle", "yellow bottle"], + 3: ["banana", "curved yellow object"], + } + return defaults.get(obj_idx, ["object"]) + + +def select_sam_candidate_by_world_band(candidates_path: Path, camera, obj_idx: int) -> np.ndarray | None: + from scipy.spatial.transform import Rotation + from scripts.act.task_e.config import OBJ_SPAWN_X_MIN, OBJ_SPAWN_X_MAX, OBJ_SPAWN_Y_BANDS + + if not candidates_path.exists(): + return None + data = np.load(candidates_path, allow_pickle=False) + masks = data["masks"].astype(bool) + metas = json.loads(str(data["metas"])) + _rgb, depth, K, pos_w, quat_wxyz_ros = camera_arrays(camera) + rot_w_cam = Rotation.from_quat( + [quat_wxyz_ros[1], quat_wxyz_ros[2], quat_wxyz_ros[3], quat_wxyz_ros[0]] + ).as_matrix() + y0, y1 = OBJ_SPAWN_Y_BANDS[obj_idx] + scored = [] + for idx, mask in enumerate(masks): + valid = mask & np.isfinite(depth) & (depth > 0.0) & (depth < 6.0) + ys, xs = np.where(valid) + if len(xs) < 64: + continue + z = depth[ys, xs].astype(np.float64) + x_cam = (xs.astype(np.float64) - float(K[0, 2])) / float(K[0, 0]) * z + y_cam = (ys.astype(np.float64) - float(K[1, 2])) / float(K[1, 1]) * z + pts_cam = np.stack([x_cam, y_cam, z], axis=1) + pts_w = (rot_w_cam @ pts_cam.T).T + pos_w + keep = ( + (pts_w[:, 0] >= OBJ_SPAWN_X_MIN - 0.10) + & (pts_w[:, 0] <= OBJ_SPAWN_X_MAX + 0.10) + & (pts_w[:, 1] >= y0 - 0.08) + & (pts_w[:, 1] <= y1 + 0.08) + & (pts_w[:, 2] >= TABLE_TOP_Z + 0.005) + & (pts_w[:, 2] <= TABLE_TOP_Z + 0.26) + ) + band_count = int(np.count_nonzero(keep)) + band_ratio = band_count / max(len(xs), 1) + if band_count < 64: + continue + band_pts = pts_w[keep] + p85_z = float(np.percentile(band_pts[:, 2], 85)) + if p85_z > SAM_MASK_P85_Z_MAX.get(obj_idx, TABLE_TOP_Z + 0.18): + continue + score = float(metas[idx].get("score", 0.0)) + # Prefer masks that live in the object's legal spawn band. Score is + # secondary because open-vocabulary prompts can rate distractors high. + scored.append((band_ratio, band_count, score, -p85_z, idx, keep, ys, xs)) + if not scored: + print("[SAM3] no candidate survived world-band filter; using best SAM3 mask") + return None + band_ratio, band_count, score, neg_p85_z, idx, keep, ys, xs = max(scored, key=lambda x: (x[1], x[0], x[2], x[3])) + refined = np.zeros_like(masks[idx], dtype=np.bool_) + refined[ys[keep], xs[keep]] = True + meta = metas[idx] + print( + f"[SAM3] selected_candidate={idx} prompt={meta.get('prompt')} score={score:.3f} " + f"band_ratio={band_ratio:.3f} band_pixels={band_count} p85_z={-neg_p85_z:.3f}" + ) + return refined + + +def sam3_object_mask(camera, rgb: np.ndarray, obj_idx: int, debug_dir: Path) -> np.ndarray: + if not Path(args_cli.sam3_python).exists(): + raise RuntimeError(f"SAM3 python not found: {args_cli.sam3_python}") + debug_dir.mkdir(parents=True, exist_ok=True) + image_path = debug_dir / f"sam3_obj{obj_idx}_rgb.png" + mask_path = debug_dir / f"sam3_obj{obj_idx}_mask.npy" + meta_path = debug_dir / f"sam3_obj{obj_idx}_meta.json" + candidates_path = debug_dir / f"sam3_obj{obj_idx}_candidates.npz" + imageio.imwrite(str(image_path), rgb.astype(np.uint8)) + prompts = args_cli.sam3_prompt or sam3_prompts_for_object(obj_idx) + cmd = [ + args_cli.sam3_python, + str(Path(__file__).with_name("sam3_segment_image.py")), + "--image", + str(image_path), + "--out_mask", + str(mask_path), + "--out_meta", + str(meta_path), + "--out_candidates", + str(candidates_path), + "--threshold", + str(args_cli.sam3_threshold), + "--mask_threshold", + str(args_cli.sam3_mask_threshold), + ] + for prompt in prompts: + cmd.extend(["--prompt", prompt]) + print(f"[SAM3] prompts={prompts} image={image_path}") + subprocess.run(cmd, check=True) + mask = np.load(mask_path).astype(bool) + if candidates_path.exists(): + refined = select_sam_candidate_by_world_band(candidates_path, camera=camera, obj_idx=obj_idx) + if refined is not None: + mask = refined + np.save(mask_path, mask.astype(np.bool_)) + print(f"[SAM3] mask_pixels={int(mask.sum())} meta={meta_path}") + return mask + + +def object_z_gain(env, obj_idx: int, z0: float) -> float: + pos = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"].data.root_pos_w[0] + return float(pos[2].item() - z0) + + +def run_table_push_recovery( + env, + robot, + ik_ctrl, + arm_ids, + gripper_ids, + default_jpos, + frames, + camera, + obj, + topdown_quat, + finger_body_indices: tuple[int, int] | None, +) -> None: + cur = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64) + push_z = TABLE_TOP_Z + args_cli.post_push_z + behind = args_cli.post_push_behind + # Approach from the positive-Y side and push toward the basket center. This + # is the deterministic fallback when the object has slipped back to the table. + push_start = np.array([cur[0], cur[1] + behind, push_z], dtype=np.float64) + push_mid = np.array([BASKET_CENTER_X, BASKET_CENTER_Y + behind, push_z], dtype=np.float64) + push_end = np.array([BASKET_CENTER_X, BASKET_CENTER_Y + behind * 0.20, push_z], dtype=np.float64) + print( + f"[TABLE_PUSH] cur=({cur[0]:.3f},{cur[1]:.3f},{cur[2]:.3f}) " + f"start=({push_start[0]:.3f},{push_start[1]:.3f},{push_start[2]:.3f}) " + f"mid=({push_mid[0]:.3f},{push_mid[1]:.3f},{push_mid[2]:.3f}) " + f"end=({push_end[0]:.3f},{push_end[1]:.3f},{push_end[2]:.3f})" + ) + contact_z = TABLE_TOP_Z + max(args_cli.post_push_z, 0.025) + step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, push_start, topdown_quat, GRIPPER_OPEN_POS, frames, camera, 120, finger_body_indices=finger_body_indices, finger_target_xy=push_start[:2], finger_target_z=contact_z) + step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, push_start, topdown_quat, GRIPPER_CLOSE_POS, frames, camera, 80, finger_body_indices=finger_body_indices, finger_target_xy=push_start[:2], finger_target_z=contact_z) + step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, push_mid, topdown_quat, GRIPPER_CLOSE_POS, frames, camera, max(args_cli.post_push_steps // 2, 1), finger_body_indices=finger_body_indices, finger_target_xy=push_mid[:2], finger_target_z=contact_z) + step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, push_end, topdown_quat, GRIPPER_CLOSE_POS, frames, camera, max(args_cli.post_push_steps // 2, 1), finger_body_indices=finger_body_indices, finger_target_xy=push_end[:2], finger_target_z=contact_z) + step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, push_end, topdown_quat, GRIPPER_OPEN_POS, frames, camera, 80) + + +def run_closed_drag_recovery( + env, + robot, + ik_ctrl, + arm_ids, + gripper_ids, + default_jpos, + frames, + camera, + obj, + quat_w, + finger_body_indices: tuple[int, int] | None, +) -> None: + cur = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64) + drag_z = TABLE_TOP_Z + max(args_cli.post_push_z, 0.025) + # Keep the gripper closed and continue from the current contact region. + # The intermediate target stays slightly behind the basket center so the + # object is swept into the success box instead of being abandoned early. + drag_start = np.array([cur[0], cur[1], drag_z], dtype=np.float64) + drag_mid = np.array([BASKET_CENTER_X, (cur[1] + BASKET_CENTER_Y) * 0.5, drag_z], dtype=np.float64) + drag_end = np.array([BASKET_CENTER_X, BASKET_CENTER_Y, drag_z], dtype=np.float64) + print( + f"[CLOSED_DRAG] cur=({cur[0]:.3f},{cur[1]:.3f},{cur[2]:.3f}) " + f"start=({drag_start[0]:.3f},{drag_start[1]:.3f},{drag_start[2]:.3f}) " + f"mid=({drag_mid[0]:.3f},{drag_mid[1]:.3f},{drag_mid[2]:.3f}) " + f"end=({drag_end[0]:.3f},{drag_end[1]:.3f},{drag_end[2]:.3f})" + ) + step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, drag_start, quat_w, GRIPPER_CLOSE_POS, frames, camera, 120, finger_body_indices=finger_body_indices, finger_target_xy=drag_start[:2], finger_target_z=drag_z) + step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, drag_mid, quat_w, GRIPPER_CLOSE_POS, frames, camera, max(args_cli.drag_recovery_steps // 2, 1), finger_body_indices=finger_body_indices, finger_target_xy=drag_mid[:2], finger_target_z=drag_z) + step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, drag_end, quat_w, GRIPPER_CLOSE_POS, frames, camera, max(args_cli.drag_recovery_steps // 2, 1), finger_body_indices=finger_body_indices, finger_target_xy=drag_end[:2], finger_target_z=drag_z) + + +def main() -> None: + env = build_env() + dev = env.unwrapped.device + env.reset() + + robot = env.unwrapped.scene.articulations["robot"] + robot.write_joint_state_to_sim(robot.data.default_joint_pos, torch.zeros_like(robot.data.default_joint_vel)) + default_jpos = robot.data.default_joint_pos.clone() + arm_ids, _ = robot.find_joints(ARM_JOINT_NAMES) + gripper_ids, _ = robot.find_joints(GRIPPER_JOINT_NAMES) + link7_ids, _ = robot.find_bodies("link7") + link8_ids, _ = robot.find_bodies("link8") + finger_body_indices = None + if len(link7_ids) > 0 and len(link8_ids) > 0: + finger_body_indices = (int(link7_ids[0]), int(link8_ids[0])) + camera = env.unwrapped.scene["video_cam"] + + ik_ctrl = CartesianController( + robot=robot, + ee_body_name=EE_BODY_NAME, + arm_joint_names=ARM_JOINT_NAMES, + num_envs=1, + device=dev, + command_type="pose", + lambda_val=0.05, + max_joint_delta=0.18, + ) + ik_ctrl.reset() + + frames: list[np.ndarray] = [] + home = np.array([RETRACT_POS_X, RETRACT_POS_Y, CARRY_Z], dtype=np.float64) + topdown_quat = np.asarray(DEFAULT_PLACE_QUAT_W, dtype=np.float64) + for _ in range(2): + step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, home, topdown_quat, GRIPPER_OPEN_POS, frames, camera, 80) + + obj = env.unwrapped.scene.rigid_objects[f"object_{args_cli.object}"] + obj_initial = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64) + + rgb, depth, K, pos_w, quat_wxyz_ros = camera_arrays(camera) + debug_dir = Path(args_cli.save_debug_npz).with_suffix("") + if args_cli.mask_provider == "band": + mask = rgbd_band_object_mask(camera, args_cli.object) + elif args_cli.mask_provider == "sam3": + mask = sam3_object_mask(camera, rgb, args_cli.object, debug_dir) + else: + mask = oracle_object_mask(env, camera, args_cli.object) + Path(args_cli.save_debug_npz).parent.mkdir(parents=True, exist_ok=True) + np.savez_compressed( + args_cli.save_debug_npz, + rgb=rgb, + depth=depth, + mask=mask, + K=K, + camera_pos_w=pos_w, + camera_quat_wxyz_ros=quat_wxyz_ros, + object_initial=obj_initial, + ) + if args_cli.grasp_provider == "anygrasp": + grasp = infer_anygrasp_from_camera(camera, mask) + elif args_cli.grasp_provider == "pca": + grasp = infer_pca_aabb_from_camera(camera, mask, object_index=args_cli.object) + else: + grasp = infer_grasp_from_camera(camera, mask) + print( + f"[GRASP] provider={args_cli.grasp_provider} obj={args_cli.object} " + f"score={grasp.score:.4f} width={grasp.width:.4f} " + f"t_w=({grasp.translation_w[0]:.3f},{grasp.translation_w[1]:.3f},{grasp.translation_w[2]:.3f})" + ) + + pick_xy = grasp.translation_w[:2].copy() + if not args_cli.no_object_offset: + pick_xy += np.asarray(OBJ_GRASP_CENTER_OFFSETS.get(args_cli.object, (0.0, 0.0, 0.0))[:2], dtype=np.float64) + grasp_z = max(float(grasp.translation_w[2] + args_cli.tcp_z_offset), TABLE_TOP_Z + 0.055) + close_offset = ( + GRASPNET_CLOSE_Z_DEFAULTS.get( + args_cli.object, + OBJ_CLOSE_Z_OFFSETS.get(args_cli.object, OBJ_GRASP_Z_OFFSETS.get(args_cli.object, args_cli.tcp_z_offset)), + ) + if args_cli.close_z_offset is None + else args_cli.close_z_offset + ) + close_z = max(float(obj_initial[2] + close_offset), TABLE_TOP_Z + 0.030) + if args_cli.force_default_quat: + grasp_quat = topdown_quat + elif args_cli.use_task_quat: + grasp_quat = compute_grasp_quat(obj.data.root_quat_w[0], dev).detach().cpu().numpy().astype(np.float64) + else: + grasp_quat = grasp.quat_wxyz_w + pre = np.array([pick_xy[0], pick_xy[1], TABLE_TOP_Z + args_cli.pregrasp_z], dtype=np.float64) + reach = np.array([pick_xy[0], pick_xy[1], grasp_z], dtype=np.float64) + close = np.array([pick_xy[0], pick_xy[1], close_z], dtype=np.float64) + lift = np.array([pick_xy[0], pick_xy[1], TABLE_TOP_Z + args_cli.lift_z], dtype=np.float64) + place = np.array( + [BASKET_CENTER_X + args_cli.place_x_offset, BASKET_CENTER_Y + args_cli.place_y_offset, TABLE_TOP_Z + args_cli.place_z], + dtype=np.float64, + ) + release = np.array( + [BASKET_CENTER_X + args_cli.place_x_offset, BASKET_CENTER_Y + args_cli.place_y_offset, TABLE_TOP_Z + args_cli.release_z], + dtype=np.float64, + ) + open_release = release.copy() + if args_cli.open_release_z is not None: + open_release[2] = TABLE_TOP_Z + float(args_cli.open_release_z) + basket_target_xy = np.array([BASKET_CENTER_X, BASKET_CENTER_Y], dtype=np.float64) + transport_steps = args_cli.transport_steps if args_cli.transport_steps is not None else args_cli.move_steps + place_steps = args_cli.place_steps if args_cli.place_steps is not None else args_cli.move_steps + print( + f"[PLAN] pick=({pick_xy[0]:.3f},{pick_xy[1]:.3f}) " + f"reach_z={reach[2]:.3f} close_z={close[2]:.3f} lift_z={lift[2]:.3f} " + f"place=({place[0]:.3f},{place[1]:.3f},{place[2]:.3f}) " + f"release=({release[0]:.3f},{release[1]:.3f},{release[2]:.3f}) " + f"open_release=({open_release[0]:.3f},{open_release[1]:.3f},{open_release[2]:.3f}) " + f"transport_steps={transport_steps} place_steps={place_steps} " + f"quat=({grasp_quat[0]:.3f},{grasp_quat[1]:.3f},{grasp_quat[2]:.3f},{grasp_quat[3]:.3f})" + ) + + servo_center_xy = pick_xy.astype(np.float64) + close_servo_xy = servo_center_xy.copy() + if args_cli.preclose_insert_steps > 0: + close_servo_xy = close_servo_xy + np.array( + [args_cli.preclose_insert_dx, args_cli.preclose_insert_dy], + dtype=np.float64, + ) + print( + f"[PRECLOSE_INSERT] steps={args_cli.preclose_insert_steps} " + f"finger_target=({close_servo_xy[0]:.3f},{close_servo_xy[1]:.3f}) " + f"offset=({args_cli.preclose_insert_dx:+.3f},{args_cli.preclose_insert_dy:+.3f})" + ) + step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, pre, grasp_quat, GRIPPER_OPEN_POS, frames, camera, args_cli.move_steps) + reach_stats = step_pose( + env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, reach, grasp_quat, GRIPPER_OPEN_POS, + frames, camera, args_cli.move_steps, obj_idx=args_cli.object, obj=obj, + finger_body_indices=finger_body_indices, servo_center_xy=servo_center_xy, + ) + insert_stats = None + if args_cli.preclose_insert_steps > 0: + insert_stats = step_pose( + env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, close, grasp_quat, GRIPPER_OPEN_POS, + frames, camera, args_cli.preclose_insert_steps, obj_idx=args_cli.object, obj=obj, + finger_body_indices=finger_body_indices, finger_target_xy=close_servo_xy, + finger_target_z=close[2], finger_servo_gain=1.0, + finger_servo_max_xy=0.16, finger_servo_max_z=0.04, + ) + close_stats = step_pose( + env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, close, grasp_quat, GRIPPER_CLOSE_POS, + frames, camera, args_cli.close_steps, obj_idx=args_cli.object, obj=obj, + finger_body_indices=finger_body_indices, servo_center_xy=close_servo_xy, + ) + z_gain_close = object_z_gain(env, args_cli.object, float(obj_initial[2])) + lift_stats = step_pose( + env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, lift, grasp_quat, GRIPPER_CLOSE_POS, + frames, camera, args_cli.move_steps, obj_idx=args_cli.object, obj=obj, + finger_body_indices=finger_body_indices, servo_center_xy=close_servo_xy, + ) + z_gain_lift = object_z_gain(env, args_cli.object, float(obj_initial[2])) + place_quat = grasp_quat if args_cli.object in (1, 2) else topdown_quat + place_servo_xy = basket_target_xy if args_cli.basket_center_release else None + release_stable = True + if args_cli.staged_transport and transport_steps >= 3: + servo_steps = int(round(transport_steps * max(0.0, min(1.0, args_cli.transport_servo_fraction)))) + servo_steps = min(max(servo_steps, 1 if place_servo_xy is not None else 0), max(transport_steps - 2, 0)) + carry_steps = max(transport_steps - servo_steps, 2) + first_steps = max(carry_steps // 2, 1) + second_steps = max(carry_steps - first_steps, 1) + mid = np.array( + [ + (lift[0] + release[0]) * 0.5, + (lift[1] + release[1]) * 0.5, + max(lift[2], release[2]), + ], + dtype=np.float64, + ) + print( + f"[TRANSPORT] staged first={first_steps} second={second_steps} servo={servo_steps} " + f"mid=({mid[0]:.3f},{mid[1]:.3f},{mid[2]:.3f})" + ) + step_pose( + env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, mid, place_quat, GRIPPER_CLOSE_POS, + frames, camera, first_steps, obj_idx=args_cli.object, obj=obj, + finger_body_indices=finger_body_indices, servo_center_xy=servo_center_xy, + servo_current_object_xy=args_cli.dynamic_finger_servo, + ) + step_pose( + env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, release, place_quat, GRIPPER_CLOSE_POS, + frames, camera, second_steps, obj_idx=args_cli.object, obj=obj, + finger_body_indices=finger_body_indices, servo_center_xy=servo_center_xy, + servo_current_object_xy=args_cli.dynamic_finger_servo, + ) + if servo_steps > 0: + step_pose( + env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, release, place_quat, GRIPPER_CLOSE_POS, + frames, camera, servo_steps, obj_idx=args_cli.object, obj=obj, + finger_body_indices=finger_body_indices, servo_center_xy=servo_center_xy, + servo_current_object_xy=args_cli.dynamic_finger_servo, + object_target_xy=place_servo_xy, + object_servo_gain=args_cli.basket_servo_gain, object_servo_max_xy=args_cli.basket_servo_max_xy, + ) + else: + step_pose( + env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, release, place_quat, GRIPPER_CLOSE_POS, + frames, camera, transport_steps, obj_idx=args_cli.object, obj=obj, + finger_body_indices=finger_body_indices, servo_center_xy=servo_center_xy, + servo_current_object_xy=args_cli.dynamic_finger_servo, + object_target_xy=place_servo_xy, + object_servo_gain=args_cli.basket_servo_gain, object_servo_max_xy=args_cli.basket_servo_max_xy, + ) + transport_pos = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64) + transport_xy_err = float(np.linalg.norm(transport_pos[:2] - basket_target_xy)) + print( + f"[TRANSPORT_END] obj=({transport_pos[0]:.3f},{transport_pos[1]:.3f},{transport_pos[2]:.3f}) " + f"xy_err={transport_xy_err:.3f} lifted_z_gain={transport_pos[2] - obj_initial[2]:.3f}" + ) + hold_stats = None + if place_servo_xy is not None: + hold_stats = step_until_object_center_stable( + env, + robot, + ik_ctrl, + arm_ids, + gripper_ids, + default_jpos, + release, + place_quat, + GRIPPER_CLOSE_POS, + frames, + camera, + obj=obj, + target_xy=place_servo_xy, + xy_tol=args_cli.basket_xy_tol, + stable_steps=args_cli.basket_stable_steps, + max_steps=args_cli.basket_hold_steps, + object_servo_gain=args_cli.basket_servo_gain, + object_servo_max_xy=args_cli.basket_servo_max_xy, + obj_idx=args_cli.object, + finger_body_indices=finger_body_indices, + servo_center_xy=servo_center_xy, + servo_current_object_xy=args_cli.dynamic_finger_servo, + ) + print(f"[BASKET_HOLD] {hold_stats}") + if int(hold_stats["stable"]) < args_cli.basket_stable_steps: + print("[BASKET_HOLD] not stable; keeping gripper closed and running recovery servo before release") + hold_stats = step_until_object_center_stable( + env, + robot, + ik_ctrl, + arm_ids, + gripper_ids, + default_jpos, + place, + place_quat, + GRIPPER_CLOSE_POS, + frames, + camera, + obj=obj, + target_xy=place_servo_xy, + xy_tol=args_cli.basket_xy_tol, + stable_steps=args_cli.basket_stable_steps, + max_steps=args_cli.basket_recovery_steps, + object_servo_gain=args_cli.basket_servo_gain, + object_servo_max_xy=args_cli.basket_servo_max_xy, + obj_idx=args_cli.object, + finger_body_indices=finger_body_indices, + servo_center_xy=servo_center_xy, + servo_current_object_xy=args_cli.dynamic_finger_servo, + ) + print(f"[BASKET_RECOVERY] {hold_stats}") + if int(hold_stats["stable"]) < args_cli.basket_stable_steps: + print("[BASKET_HOLD] still not stable; skipping open release to avoid early drop") + place_steps = 0 + release_stable = False + open_target = open_release if args_cli.open_release_z is not None else release + if args_cli.open_release_z is not None: + step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, open_target, place_quat, GRIPPER_CLOSE_POS, frames, camera, 120) + step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, open_target, place_quat, GRIPPER_CLOSE_POS, frames, camera, 60) + if place_steps > 0: + step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, open_target, place_quat, GRIPPER_OPEN_POS, frames, camera, place_steps) + slipped_to_table = float(obj.data.root_pos_w[0, 2].item()) <= TABLE_TOP_Z + 0.08 + need_push = not check_objects_in_basket(env, [args_cli.object]) and ( + args_cli.post_push or (args_cli.auto_table_push_on_slip and (slipped_to_table or not release_stable)) + ) + if need_push: + run_closed_drag_recovery(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, frames, camera, obj, place_quat, finger_body_indices) + if not check_objects_in_basket(env, [args_cli.object]): + run_table_push_recovery(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, frames, camera, obj, topdown_quat, finger_body_indices) + step_pose(env, robot, ik_ctrl, arm_ids, gripper_ids, default_jpos, home, topdown_quat, GRIPPER_OPEN_POS, frames, camera, args_cli.settle_steps) + + final_pos = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64) + inside = check_objects_in_basket(env, [args_cli.object]) + print( + f"[RESULT] obj={args_cli.object} inside={inside} " + f"z_gain_close={z_gain_close:.3f} z_gain_lift={z_gain_lift:.3f} " + f"final=({final_pos[0]:.3f},{final_pos[1]:.3f},{final_pos[2]:.3f})" + ) + print(f"[TRACE] reach={reach_stats} insert={insert_stats} close={close_stats} lift={lift_stats}") + for line in basket_status_lines(env, [args_cli.object]): + print(f"[BASKET] {line}") + + video_path = Path(args_cli.video_path) + video_path.parent.mkdir(parents=True, exist_ok=True) + if frames: + imageio.mimwrite(str(video_path), frames, fps=50, quality=7) + print(f"[VIDEO] {video_path.resolve()}") + env.close() + + +if __name__ == "__main__": + try: + main() + finally: + simulation_app.close() diff --git a/scripts/graspnet_task_e/sam3_segment_image.py b/scripts/graspnet_task_e/sam3_segment_image.py new file mode 100644 index 0000000000000000000000000000000000000000..50783cd3448af25ab0f88b733b0cb06a5e87847b --- /dev/null +++ b/scripts/graspnet_task_e/sam3_segment_image.py @@ -0,0 +1,109 @@ +"""Run local SAM3 on a saved RGB image and write a binary mask. + +This script is intentionally small and dependency-isolated: Task-E/Isaac can +call it from the SAM3 virtualenv without installing SAM3 into the Isaac env. +""" + +from __future__ import annotations + +import argparse +import json +import sys +from pathlib import Path + +import numpy as np +from PIL import Image + + +PROMPT_INPAINT = Path("/home/ubuntu/Documents/01Proj/sam3d_gs/submodule/Prompt-Inpaint") +if not PROMPT_INPAINT.exists(): + raise SystemExit(f"Prompt-Inpaint not found: {PROMPT_INPAINT}") +sys.path.insert(0, str(PROMPT_INPAINT)) + +from src.sam3_predictor import SAM3Predictor # noqa: E402 + + +def _bbox_area(mask: np.ndarray) -> int: + ys, xs = np.nonzero(mask) + if len(xs) == 0: + return 0 + return int((xs.max() - xs.min() + 1) * (ys.max() - ys.min() + 1)) + + +def main() -> None: + parser = argparse.ArgumentParser(description="Segment one image with local SAM3.") + parser.add_argument("--image", required=True, help="Input RGB image path.") + parser.add_argument("--out_mask", required=True, help="Output .npy binary mask path.") + parser.add_argument("--out_meta", default=None, help="Optional JSON metadata output.") + parser.add_argument("--out_candidates", default=None, help="Optional .npz with all candidate masks.") + parser.add_argument("--prompt", action="append", required=True, help="Text prompt. Can repeat.") + parser.add_argument("--threshold", type=float, default=0.35) + parser.add_argument("--mask_threshold", type=float, default=0.5) + parser.add_argument( + "--model", + default="/home/ubuntu/Documents/01Proj/sam3d_gs/submodule/Prompt-Inpaint/checkpoints/sam3.pt", + ) + args = parser.parse_args() + + image = np.asarray(Image.open(args.image).convert("RGB")) + predictor = SAM3Predictor( + model_id=args.model, + device="cuda", + threshold=args.threshold, + mask_threshold=args.mask_threshold, + ) + predictor.set_image(image) + + detections = [] + for prompt in args.prompt: + detections.extend(predictor.detect(prompt)) + + candidates = [] + image_area = image.shape[0] * image.shape[1] + for det in detections: + if det.mask is None: + continue + mask = det.mask.astype(bool) + area = int(mask.sum()) + if area < 40 or area > int(image_area * 0.35): + continue + candidates.append( + { + "prompt": det.label, + "score": float(det.score), + "bbox": [int(v) for v in det.bbox], + "area": area, + "bbox_area": _bbox_area(mask), + "mask": mask, + } + ) + + if not candidates: + raise SystemExit("SAM3 produced no usable mask") + + # Prefer confident, compact object masks. This avoids selecting the table or + # a merged scene-sized region when prompts are broad. + best = max(candidates, key=lambda c: (c["score"], -c["bbox_area"])) + out_mask = Path(args.out_mask) + out_mask.parent.mkdir(parents=True, exist_ok=True) + np.save(out_mask, best["mask"].astype(np.bool_)) + + if args.out_meta: + meta = {k: v for k, v in best.items() if k != "mask"} + meta["num_candidates"] = len(candidates) + Path(args.out_meta).parent.mkdir(parents=True, exist_ok=True) + Path(args.out_meta).write_text(json.dumps(meta, indent=2), encoding="utf-8") + + if args.out_candidates: + cand_path = Path(args.out_candidates) + cand_path.parent.mkdir(parents=True, exist_ok=True) + masks = np.stack([c["mask"].astype(np.bool_) for c in candidates], axis=0) + metas = [ + {k: v for k, v in c.items() if k != "mask"} + for c in candidates + ] + np.savez_compressed(cand_path, masks=masks, metas=json.dumps(metas)) + + +if __name__ == "__main__": + main() diff --git a/scripts/graspnet_task_e/tuntun_adapter.py b/scripts/graspnet_task_e/tuntun_adapter.py new file mode 100644 index 0000000000000000000000000000000000000000..6937a1659824a0a42150a700fccd368ee44ca52a --- /dev/null +++ b/scripts/graspnet_task_e/tuntun_adapter.py @@ -0,0 +1,388 @@ +"""Small Task-E bridge around the TunTunClaw GraspNet API. + +The GraspNet model predicts grasps in the camera/ROS frame. Task E executes a +top-down Piper grasp in world frame, so this adapter intentionally uses +GraspNet for the contact centre and jaw yaw, then forces a stable top-down +orientation for the Piper gripper. +""" + +from __future__ import annotations + +from dataclasses import dataclass +from functools import lru_cache +from pathlib import Path +import os +import sys + +import numpy as np +import torch +from scipy.spatial.transform import Rotation + + +REPO_ROOT = Path(__file__).resolve().parents[2] +TUNTUN_ROOT = REPO_ROOT / "third_party" / "tuntunclaw" +GRASPNET_ROOT = TUNTUN_ROOT / "graspnet-baseline" +CHECKPOINT_PATH = TUNTUN_ROOT / "temp" / "logs" / "log_rs" / "checkpoint-rs.tar" + + +def _ensure_tuntun_paths() -> None: + paths = [ + GRASPNET_ROOT / "models", + GRASPNET_ROOT / "dataset", + GRASPNET_ROOT / "utils", + GRASPNET_ROOT / "graspnetAPI", + TUNTUN_ROOT / "manipulator_grasp", + ] + for path in paths: + p = str(path) + if p not in sys.path: + sys.path.insert(0, p) + + +@dataclass(frozen=True) +class TaskEGrasp: + translation_w: np.ndarray + quat_wxyz_w: np.ndarray + score: float + width: float + raw_translation_cam: np.ndarray + + +def camera_arrays(camera) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]: + """Return RGB, depth, K, camera position and ROS-frame quaternion.""" + rgb = camera.data.output["rgb"][0].detach().cpu().numpy()[..., :3] + depth = camera.data.output["depth"][0].detach().cpu().numpy() + if depth.ndim == 3: + depth = depth[..., 0] + K = camera.data.intrinsic_matrices[0].detach().cpu().numpy() + pos_w = camera.data.pos_w[0].detach().cpu().numpy() + quat_wxyz_ros = camera.data.quat_w_ros[0].detach().cpu().numpy() + return rgb, depth.astype(np.float32), K.astype(np.float32), pos_w.astype(np.float64), quat_wxyz_ros.astype(np.float64) + + +def project_world_points_to_image(points_w: np.ndarray, K: np.ndarray, pos_w: np.ndarray, quat_wxyz_ros: np.ndarray) -> np.ndarray: + """Project world points into a ROS camera image.""" + rot_w_cam = Rotation.from_quat( + [quat_wxyz_ros[1], quat_wxyz_ros[2], quat_wxyz_ros[3], quat_wxyz_ros[0]] + ).as_matrix() + pts_cam = (rot_w_cam.T @ (points_w - pos_w).T).T + z = np.clip(pts_cam[:, 2], 1e-6, None) + u = K[0, 0] * pts_cam[:, 0] / z + K[0, 2] + v = K[1, 1] * pts_cam[:, 1] / z + K[1, 2] + return np.stack([u, v, pts_cam[:, 2]], axis=1) + + +def oracle_object_mask(env, camera, obj_idx: int, pad_px: int = 24) -> np.ndarray: + """Create a temporary ROI mask by projecting the known simulated object bbox. + + This is for fast grasp primitive debugging. Once the primitive is stable, + replace this mask provider with RGB-D segmentation/VLM masks for submission. + """ + from atec_rl_lab.tasks.task_e.env_cfg import OBJ_HALF_EXTENTS, TABLE_TOP_Z + + rgb, depth, K, pos_w, quat_wxyz_ros = camera_arrays(camera) + h, w = depth.shape[:2] + obj = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"] + center = obj.data.root_pos_w[0].detach().cpu().numpy().astype(np.float64) + hx, hy = OBJ_HALF_EXTENTS[f"object_{obj_idx}"] + z_lo = TABLE_TOP_Z + 0.005 + z_hi = max(center[2] + 0.16, TABLE_TOP_Z + 0.08) + corners = np.array( + [ + [center[0] + sx * hx, center[1] + sy * hy, z] + for sx in (-1.0, 1.0) + for sy in (-1.0, 1.0) + for z in (z_lo, z_hi) + ], + dtype=np.float64, + ) + uvz = project_world_points_to_image(corners, K, pos_w, quat_wxyz_ros) + valid = uvz[:, 2] > 0.02 + mask = np.zeros((h, w), dtype=np.uint8) + if not np.any(valid): + return mask + u = uvz[valid, 0] + v = uvz[valid, 1] + x1 = int(np.clip(np.floor(u.min()) - pad_px, 0, w - 1)) + y1 = int(np.clip(np.floor(v.min()) - pad_px, 0, h - 1)) + x2 = int(np.clip(np.ceil(u.max()) + pad_px, 0, w - 1)) + y2 = int(np.clip(np.ceil(v.max()) + pad_px, 0, h - 1)) + if x2 > x1 and y2 > y1: + mask[y1 : y2 + 1, x1 : x2 + 1] = 255 + # Remove obvious background/table pixels while keeping the object surface. + obj_depth = depth[mask > 0] + obj_depth = obj_depth[np.isfinite(obj_depth) & (obj_depth > 0.0)] + if obj_depth.size: + d_min = float(np.percentile(obj_depth, 3)) + d_max = float(np.percentile(obj_depth, 70)) + mask[(depth < d_min - 0.03) | (depth > d_max + 0.06)] = 0 + # Debug oracle refinement: keep only RGB-D points whose reconstructed + # world coordinates lie inside the selected object's AABB. The first + # rectangular ROI can include neighboring objects for banana/long + # shapes, which shifts GraspNet's execution centre by tens of cm. + ys, xs = np.where((mask > 0) & np.isfinite(depth) & (depth > 0.0)) + if len(xs) > 0: + z = depth[ys, xs].astype(np.float64) + x_cam = (xs.astype(np.float64) - float(K[0, 2])) / float(K[0, 0]) * z + y_cam = (ys.astype(np.float64) - float(K[1, 2])) / float(K[1, 1]) * z + pts_cam = np.stack([x_cam, y_cam, z], axis=1) + rot_w_cam = Rotation.from_quat( + [quat_wxyz_ros[1], quat_wxyz_ros[2], quat_wxyz_ros[3], quat_wxyz_ros[0]] + ).as_matrix() + pts_w = (rot_w_cam @ pts_cam.T).T + pos_w + keep = ( + (pts_w[:, 0] >= center[0] - hx - 0.025) + & (pts_w[:, 0] <= center[0] + hx + 0.025) + & (pts_w[:, 1] >= center[1] - hy - 0.025) + & (pts_w[:, 1] <= center[1] + hy + 0.025) + & (pts_w[:, 2] >= TABLE_TOP_Z - 0.010) + & (pts_w[:, 2] <= center[2] + 0.180) + ) + refined = np.zeros_like(mask) + refined[ys[keep], xs[keep]] = 255 + if np.count_nonzero(refined) > 128: + mask = refined + return mask + + +_BAND_Z_LIMITS = { + 1: (0.035, 0.130), # sugar box: reject table pixels and high gripper links + 2: (0.020, 0.190), # mustard bottle + 3: (0.012, 0.095), # banana +} + + +def rgbd_band_object_mask(camera, obj_idx: int, margin_y: float = 0.045) -> np.ndarray: + """Segment a Task-E object from RGB-D using legal scene priors. + + The official randomizer keeps each object type in a distinct world-Y band. + Reconstructing the video camera depth into world coordinates lets us isolate + the object without reading simulator object state. This is the intended + replacement for ``oracle_object_mask`` in submission-style tests. + """ + from scripts.act.task_e.config import OBJ_SPAWN_X_MIN, OBJ_SPAWN_X_MAX, OBJ_SPAWN_Y_BANDS + from atec_rl_lab.tasks.task_e.env_cfg import TABLE_TOP_Z + + rgb, depth, K, pos_w, quat_wxyz_ros = camera_arrays(camera) + valid = np.isfinite(depth) & (depth > 0.0) & (depth < 6.0) + ys, xs = np.where(valid) + mask = np.zeros(depth.shape[:2], dtype=np.uint8) + if len(xs) == 0: + return mask + + z = depth[ys, xs].astype(np.float64) + x_cam = (xs.astype(np.float64) - float(K[0, 2])) / float(K[0, 0]) * z + y_cam = (ys.astype(np.float64) - float(K[1, 2])) / float(K[1, 1]) * z + pts_cam = np.stack([x_cam, y_cam, z], axis=1) + rot_w_cam = Rotation.from_quat( + [quat_wxyz_ros[1], quat_wxyz_ros[2], quat_wxyz_ros[3], quat_wxyz_ros[0]] + ).as_matrix() + pts_w = (rot_w_cam @ pts_cam.T).T + pos_w + + y0, y1 = OBJ_SPAWN_Y_BANDS[obj_idx] + z_min_rel, z_max_rel = _BAND_Z_LIMITS.get(obj_idx, (0.006, 0.24)) + rgb_pts = rgb[ys, xs].astype(np.float32) + maxc = rgb_pts.max(axis=1) + minc = rgb_pts.min(axis=1) + sat = maxc - minc + non_gray = (sat > 18.0) | (maxc > 170.0) + world_keep = ( + (pts_w[:, 0] >= OBJ_SPAWN_X_MIN - 0.08) + & (pts_w[:, 0] <= OBJ_SPAWN_X_MAX + 0.08) + & (pts_w[:, 1] >= y0 - margin_y) + & (pts_w[:, 1] <= y1 + margin_y) + & (pts_w[:, 2] >= TABLE_TOP_Z + z_min_rel) + & (pts_w[:, 2] <= TABLE_TOP_Z + z_max_rel) + & non_gray + ) + mask[ys[world_keep], xs[world_keep]] = 255 + + # Fill the component's rectangular holes lightly; GraspNet expects enough + # depth samples and the box has large white low-saturation areas. + if np.count_nonzero(mask) > 0: + yy, xx = np.where(mask > 0) + x1, x2 = int(xx.min()), int(xx.max()) + y1p, y2p = int(yy.min()), int(yy.max()) + roi = np.zeros_like(mask) + roi[y1p : y2p + 1, x1 : x2 + 1] = 255 + fill_keep = roi[ys, xs] > 0 + fill_keep &= ( + (pts_w[:, 1] >= y0 - margin_y) + & (pts_w[:, 1] <= y1 + margin_y) + & (pts_w[:, 2] >= TABLE_TOP_Z + z_min_rel) + & (pts_w[:, 2] <= TABLE_TOP_Z + z_max_rel) + ) + mask[ys[fill_keep], xs[fill_keep]] = 255 + return mask + + +@lru_cache(maxsize=1) +def _load_graspnet_model(): + _ensure_tuntun_paths() + if not CHECKPOINT_PATH.exists(): + raise FileNotFoundError( + f"GraspNet checkpoint missing: {CHECKPOINT_PATH}. " + "Download official checkpoint-rs.tar there first." + ) + from graspnet import GraspNet + + net = GraspNet( + input_feature_dim=0, + num_view=300, + num_angle=12, + num_depth=4, + cylinder_radius=0.05, + hmin=-0.02, + hmax_list=[0.01, 0.02, 0.03, 0.04], + is_training=False, + ) + device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") + net.to(device) + checkpoint = torch.load(CHECKPOINT_PATH, map_location=device) + net.load_state_dict(checkpoint["model_state_dict"]) + net.eval() + return net + + +def _run_graspnet(rgb: np.ndarray, depth: np.ndarray, mask: np.ndarray, K: np.ndarray): + _ensure_tuntun_paths() + import open3d as o3d + from collision_detector import ModelFreeCollisionDetector + from data_utils import CameraInfo, create_point_cloud_from_depth_image + from graspnet import pred_decode + from graspnetAPI import GraspGroup + + color = rgb.astype(np.float32) / 255.0 + height, width = depth.shape[:2] + camera_info = CameraInfo(width, height, float(K[0, 0]), float(K[1, 1]), float(K[0, 2]), float(K[1, 2]), 1.0) + cloud = create_point_cloud_from_depth_image(depth, camera_info, organized=True) + + valid = (mask > 0) & np.isfinite(depth) & (depth > 0.0) & (depth < 6.0) + cloud_masked = cloud[valid] + color_masked = color[valid] + if len(cloud_masked) == 0: + raise RuntimeError("No valid masked depth points for GraspNet.") + + num_point = 5000 + if len(cloud_masked) >= num_point: + idxs = np.random.choice(len(cloud_masked), num_point, replace=False) + else: + idxs = np.concatenate( + [np.arange(len(cloud_masked)), np.random.choice(len(cloud_masked), num_point - len(cloud_masked), replace=True)] + ) + cloud_sampled = torch.from_numpy(cloud_masked[idxs][None].astype(np.float32)).to( + torch.device("cuda:0" if torch.cuda.is_available() else "cpu") + ) + end_points = {"point_clouds": cloud_sampled, "cloud_colors": color_masked[idxs]} + + net = _load_graspnet_model() + with torch.no_grad(): + end_points = net(end_points) + grasp_preds = pred_decode(end_points) + + gg = GraspGroup(grasp_preds[0].detach().cpu().numpy()).nms().sort_by_score() + if len(gg) > 128: + gg = gg[:128] + + cloud_o3d = o3d.geometry.PointCloud() + cloud_o3d.points = o3d.utility.Vector3dVector(cloud_masked.astype(np.float32)) + cloud_o3d.colors = o3d.utility.Vector3dVector(color_masked.astype(np.float32)) + try: + detector = ModelFreeCollisionDetector(np.asarray(cloud_o3d.points, dtype=np.float32), voxel_size=0.01) + collision_mask = detector.detect(gg, approach_dist=0.05, collision_thresh=0.01) + gg = gg[~collision_mask] + except Exception as exc: + print(f"[graspnet] collision check skipped: {exc}") + + gg = gg.sort_by_score() + grasps = list(gg) + if not grasps: + raise RuntimeError("No GraspNet candidates after filtering.") + center = np.mean(cloud_masked, axis=0) + # TunTunClaw's empirical selector: prefer grasps near the segmented object centre. + max_dist = max(np.linalg.norm(g.translation - center) for g in grasps) or 1.0 + best = max(grasps, key=lambda g: float(g.score) * 0.1 + (1.0 - np.linalg.norm(g.translation - center) / max_dist) * 0.9) + out = GraspGroup() + out.add(best) + return out + + +def _load_graspnet(): + _ensure_tuntun_paths() + if not CHECKPOINT_PATH.exists(): + raise FileNotFoundError( + f"GraspNet checkpoint missing: {CHECKPOINT_PATH}. " + "Download official checkpoint-rs.tar there first." + ) + return _run_graspnet + + +def infer_grasp_from_camera(camera, mask: np.ndarray) -> TaskEGrasp: + """Run TunTunClaw GraspNet and convert the selected grasp to Task-E world pose.""" + rgb, depth, _K, pos_w, quat_wxyz_ros = camera_arrays(camera) + run_grasp_inference = _load_graspnet() + gg = run_grasp_inference(rgb, depth, mask, _K) + if len(gg) == 0: + raise RuntimeError("GraspNet returned no grasps.") + grasp = list(gg)[0] + + rot_w_cam = Rotation.from_quat( + [quat_wxyz_ros[1], quat_wxyz_ros[2], quat_wxyz_ros[3], quat_wxyz_ros[0]] + ).as_matrix() + t_cam = np.asarray(grasp.translation, dtype=np.float64) + t_w = rot_w_cam @ t_cam + pos_w + valid = (mask > 0) & np.isfinite(depth) & (depth > 0.0) & (depth < 6.0) + if np.any(valid): + ys, xs = np.where(valid) + z = depth[ys, xs].astype(np.float64) + x = (xs.astype(np.float64) - float(_K[0, 2])) / float(_K[0, 0]) * z + y = (ys.astype(np.float64) - float(_K[1, 2])) / float(_K[1, 1]) * z + pts_cam = np.stack([x, y, z], axis=1) + pts_w = (rot_w_cam @ pts_cam.T).T + pos_w + # For top-down Piper execution, the upper object-surface cloud is more + # stable than a single GraspNet seed point on box/bottle edges. Keep + # GraspNet's yaw/width/score, recenter only the execution target. + z_gate = float(np.percentile(pts_w[:, 2], 70)) + upper = pts_w[pts_w[:, 2] >= z_gate] + if len(upper) > 16: + # The highest-score GraspNet seed often sits on a visible edge for + # Task-E boxes/bottles. Piper's parallel jaw is more reliable when + # executed through the segmented object's robust surface centre. + t_w[:2] = np.median(upper[:, :2], axis=0) + else: + t_w[:2] = np.median(pts_w[:, :2], axis=0) + t_w[2] = float(np.percentile(pts_w[:, 2], 85)) + + # GraspNet's first column is the approach axis. We keep its jaw hint but + # force the Piper tool z-axis downward because the Task-E IK/top-down setup + # is much more stable than arbitrary 6-DoF wrist poses. + R_cam_grasp = np.asarray(grasp.rotation_matrix, dtype=np.float64) + jaw_hint_w = rot_w_cam @ R_cam_grasp[:, 1] + jaw_xy = np.array([jaw_hint_w[0], jaw_hint_w[1], 0.0], dtype=np.float64) + if np.linalg.norm(jaw_xy) < 1e-6: + jaw_xy = np.array([0.0, 1.0, 0.0], dtype=np.float64) + jaw_xy = jaw_xy / np.linalg.norm(jaw_xy) + grip_z = np.array([0.0, 0.0, -1.0], dtype=np.float64) + align_x = np.cross(jaw_xy, grip_z) + align_x = align_x / max(np.linalg.norm(align_x), 1e-6) + jaw_y = np.cross(grip_z, align_x) + jaw_y = jaw_y / max(np.linalg.norm(jaw_y), 1e-6) + R_w_tool = np.stack([align_x, jaw_y, grip_z], axis=1) + quat_xyzw = Rotation.from_matrix(R_w_tool).as_quat() + quat_wxyz = np.array([quat_xyzw[3], quat_xyzw[0], quat_xyzw[1], quat_xyzw[2]], dtype=np.float64) + + return TaskEGrasp( + translation_w=t_w.astype(np.float64), + quat_wxyz_w=quat_wxyz, + score=float(grasp.score), + width=float(grasp.width), + raw_translation_cam=t_cam, + ) + + +def quat_wxyz_to_torch(quat_wxyz: np.ndarray, device: str) -> torch.Tensor: + return torch.tensor([quat_wxyz], dtype=torch.float32, device=device) + + +def pos_to_torch(pos: np.ndarray, device: str) -> torch.Tensor: + return torch.tensor([pos], dtype=torch.float32, device=device) diff --git a/scripts/pi05/compare_pi05_vs_act_baseline.py b/scripts/pi05/compare_pi05_vs_act_baseline.py new file mode 100644 index 0000000000000000000000000000000000000000..a5d9fd53400ecf9dc7654604e201b31d8eab885d --- /dev/null +++ b/scripts/pi05/compare_pi05_vs_act_baseline.py @@ -0,0 +1,94 @@ +#!/usr/bin/env python3 +"""Compare a pi0.5 Task-E eval directory against the current ACT/XSA evidence.""" + +from __future__ import annotations + +import argparse +from pathlib import Path +import re +import statistics + + +RESULT_RE = re.compile(r"\[RESULT\].*?score=([0-9.]+).*?steps=([0-9]+).*?done=(True|False)") +BASKET_RE = re.compile(r"\[BASKET\].*?(object_[123]): .*?inside=(True|False)") + +DEFAULT_BASELINE_LOGS = [ + Path("logs/eval_task_e_xsa_final_seed11_recheck.log"), + Path("logs/eval_task_e_xsa_final_seed12_recheck.log"), + Path("logs/eval_task_e_xsa_final_seed13_recheck.log"), + Path("logs/eval_task_e_deployed_xsa_final_seed11_verify.log"), +] +CURRENT_POLICY_SHA = "c3eacae3f1b0ec8ccde9fdc05d680fff119cc2ca70e1f79e4ddd5610c4bbfa93" + + +def parse_log(path: Path) -> tuple[float | None, dict[str, bool]]: + if not path.exists(): + return None, {} + text = path.read_text(errors="replace") + result = RESULT_RE.search(text) + baskets = {obj: inside == "True" for obj, inside in BASKET_RE.findall(text)} + return (float(result.group(1)) if result else None), baskets + + +def collect_pi05(eval_dir: Path) -> list[tuple[Path, float, dict[str, bool]]]: + rows = [] + for log in sorted(eval_dir.glob("seed*.log")): + score, baskets = parse_log(log) + if score is not None: + rows.append((log, score, baskets)) + return rows + + +def print_rows(title: str, rows: list[tuple[Path, float, dict[str, bool]]]) -> None: + print(f"[{title}]") + if not rows: + print(" no complete result logs") + return + for path, score, baskets in rows: + basket_text = ", ".join(f"{obj}={inside}" for obj, inside in sorted(baskets.items())) + print(f" {path}: score={score:.2f}; {basket_text or 'basket=unknown'}") + scores = [score for _, score, _ in rows] + print( + f" summary: n={len(scores)} mean={statistics.fmean(scores):.2f} " + f"min={min(scores):.2f} max={max(scores):.2f}" + ) + + +def main() -> int: + parser = argparse.ArgumentParser() + parser.add_argument("eval_dir", type=Path) + parser.add_argument("--repo", type=Path, default=Path.cwd()) + args = parser.parse_args() + + repo = args.repo.resolve() + eval_dir = args.eval_dir if args.eval_dir.is_absolute() else repo / args.eval_dir + baseline_rows = [] + for log in DEFAULT_BASELINE_LOGS: + path = log if log.is_absolute() else repo / log + score, baskets = parse_log(path) + if score is not None: + baseline_rows.append((path, score, baskets)) + + pi05_rows = collect_pi05(eval_dir) + print(f"[CURRENT_DEPLOYED_POLICY_SHA] {CURRENT_POLICY_SHA}") + print_rows("ACT_XSA_BASELINE_EVIDENCE", baseline_rows) + print_rows("PI05_CANDIDATE_EVIDENCE", pi05_rows) + + if len(pi05_rows) < 3: + print("[DECISION] HOLD: pi0.5 does not yet have all seed11/12/13 results.") + return 0 + + pi05_scores = [score for _, score, _ in pi05_rows] + baseline_independent = [score for path, score, _ in baseline_rows if "xsa_final_seed" in path.name] + baseline_mean = statistics.fmean(baseline_independent) if baseline_independent else 0.0 + pi05_mean = statistics.fmean(pi05_scores) + + if min(pi05_scores) >= baseline_mean and pi05_mean > baseline_mean: + print("[DECISION] REVIEW_FOR_DEPLOY: pi0.5 is clearly better on this evidence set.") + else: + print("[DECISION] HOLD_ACT_XSA: pi0.5 is not clearly better than the current ACT/XSA baseline.") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/scripts/pi05/convert_task_e_hdf5_to_lerobot.py b/scripts/pi05/convert_task_e_hdf5_to_lerobot.py new file mode 100644 index 0000000000000000000000000000000000000000..7ea3e299adb93c815cac340059610648625431cf --- /dev/null +++ b/scripts/pi05/convert_task_e_hdf5_to_lerobot.py @@ -0,0 +1,206 @@ +#!/usr/bin/env python3 +"""Convert ATEC Task E ACT HDF5 demos to a LeRobot dataset for OpenPI/pi0.5. + +The existing Task E demos store a single 8-DoF Piper arm action: +6 arm joints + 2 gripper joints. The local OpenPI EBench tabletop policy +expects a 16-D fixed-base action split as 12 arm joints + 4 gripper joints, +so this converter pads the unused second-arm slots with zeros. +""" + +from __future__ import annotations + +import argparse +import os +from pathlib import Path +import shutil + +import h5py +import numpy as np +from lerobot.common.datasets.lerobot_dataset import LeRobotDataset +from tqdm import tqdm + + +DEFAULT_PROMPT = "identify all objects, pick them up, and place them into the target basket" + + +def _sorted_traj_keys(h5_file: h5py.File) -> list[str]: + keys = [key for key in h5_file.keys() if key.startswith("traj_")] + return sorted(keys, key=lambda item: int(item.split("_", 1)[1])) + + +def _pad_state(qpos8: np.ndarray) -> tuple[np.ndarray, np.ndarray]: + qpos8 = np.asarray(qpos8, dtype=np.float32) + joints = np.zeros(12, dtype=np.float32) + gripper = np.zeros(4, dtype=np.float32) + joints[:6] = qpos8[:6] + gripper[:2] = qpos8[6:8] + return joints, gripper + + +def _pad_action(action8: np.ndarray) -> tuple[np.ndarray, np.ndarray]: + action8 = np.asarray(action8, dtype=np.float32) + joints = np.zeros(12, dtype=np.float32) + gripper = np.zeros(4, dtype=np.float32) + joints[:6] = action8[:6] + gripper[:2] = action8[6:8] + return joints, gripper + + +def create_dataset( + *, + repo_id: str, + root: Path, + fps: int, + use_videos: bool, + overwrite: bool, + image_writer_processes: int, + image_writer_threads: int, + image_height: int, + image_width: int, +) -> LeRobotDataset: + dataset_dir = root / repo_id + if dataset_dir.exists(): + if not overwrite: + raise FileExistsError(f"{dataset_dir} already exists; pass --overwrite to replace it") + shutil.rmtree(dataset_dir) + + features = { + "video.overlook_camera_view": { + "dtype": "image", + "shape": (image_height, image_width, 3), + "names": ["height", "width", "channel"], + }, + "video.left_camera_view": { + "dtype": "image", + "shape": (image_height, image_width, 3), + "names": ["height", "width", "channel"], + }, + "video.right_camera_view": { + "dtype": "image", + "shape": (image_height, image_width, 3), + "names": ["height", "width", "channel"], + }, + "state.joints": { + "dtype": "float32", + "shape": (12,), + "names": ["joint"], + }, + "state.gripper": { + "dtype": "float32", + "shape": (4,), + "names": ["gripper"], + }, + "action.joints": { + "dtype": "float32", + "shape": (12,), + "names": ["joint"], + }, + "action.gripper": { + "dtype": "float32", + "shape": (4,), + "names": ["gripper"], + }, + } + return LeRobotDataset.create( + repo_id=repo_id, + root=dataset_dir, + robot_type="atec_piper_task_e", + fps=fps, + features=features, + use_videos=use_videos, + image_writer_processes=image_writer_processes, + image_writer_threads=image_writer_threads, + ) + + +def _resize_image(rgb: np.ndarray, height: int, width: int) -> np.ndarray: + if rgb.shape[0] == height and rgb.shape[1] == width: + return rgb + import cv2 + + return cv2.resize(rgb, (width, height), interpolation=cv2.INTER_AREA) + + +def convert(args: argparse.Namespace) -> None: + input_path = Path(args.input).expanduser().resolve() + root = Path(args.root).expanduser().resolve() + root.mkdir(parents=True, exist_ok=True) + os.environ.setdefault("HF_LEROBOT_HOME", str(root)) + + dataset = create_dataset( + repo_id=args.repo_id, + root=root, + fps=args.fps, + use_videos=args.use_videos, + overwrite=args.overwrite, + image_writer_processes=args.image_writer_processes, + image_writer_threads=args.image_writer_threads, + image_height=args.image_height, + image_width=args.image_width, + ) + + with h5py.File(input_path, "r") as h5_file: + traj_keys = _sorted_traj_keys(h5_file) + if args.max_episodes is not None: + traj_keys = traj_keys[: args.max_episodes] + if not traj_keys: + raise ValueError(f"No traj_* groups found in {input_path}") + + for traj_key in tqdm(traj_keys, desc="episodes"): + group = h5_file[traj_key] + qpos = group["obs"] + actions = group["actions"] + images = group["images/rgb"] + length = min(len(qpos), len(actions), len(images)) + if length <= 0: + continue + + for step in range(0, length, args.stride): + state_joints, state_gripper = _pad_state(qpos[step]) + action_joints, action_gripper = _pad_action(actions[step]) + rgb = _resize_image(images[step], args.image_height, args.image_width) + dataset.add_frame( + { + "video.overlook_camera_view": rgb, + "video.left_camera_view": rgb, + "video.right_camera_view": rgb, + "state.joints": state_joints, + "state.gripper": state_gripper, + "action.joints": action_joints, + "action.gripper": action_gripper, + "task": args.prompt, + } + ) + dataset.save_episode() + + print(f"[OK] Wrote LeRobot dataset repo_id={args.repo_id} root={root}") + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser() + parser.add_argument( + "--input", + default="datasets/atec_task_e_obj321_servo_100demos/trajectory_filtered.hdf5", + help="Filtered ATEC Task E HDF5 file.", + ) + parser.add_argument( + "--root", + default="/home/ubuntu/projects/robotics_shared/datasets/lerobot", + help="LeRobot dataset root. Also exported as HF_LEROBOT_HOME by this script.", + ) + parser.add_argument("--repo_id", default="atec/task_e_obj321_servo_100demos") + parser.add_argument("--prompt", default=DEFAULT_PROMPT) + parser.add_argument("--fps", type=int, default=50) + parser.add_argument("--image_height", type=int, default=224) + parser.add_argument("--image_width", type=int, default=224) + parser.add_argument("--stride", type=int, default=1, help="Temporal subsampling stride.") + parser.add_argument("--max_episodes", type=int, default=None) + parser.add_argument("--use_videos", action=argparse.BooleanOptionalAction, default=False) + parser.add_argument("--overwrite", action="store_true") + parser.add_argument("--image_writer_processes", type=int, default=0) + parser.add_argument("--image_writer_threads", type=int, default=0) + return parser.parse_args() + + +if __name__ == "__main__": + convert(parse_args()) diff --git a/scripts/pi05/convert_task_e_hdf5_to_lerobot_native8.py b/scripts/pi05/convert_task_e_hdf5_to_lerobot_native8.py new file mode 100644 index 0000000000000000000000000000000000000000..ba036fe957cb59144b974dc383fa4d3b1ae2b5e9 --- /dev/null +++ b/scripts/pi05/convert_task_e_hdf5_to_lerobot_native8.py @@ -0,0 +1,184 @@ +#!/usr/bin/env python3 +"""Convert ATEC Task E HDF5 demos to a native 8D Piper LeRobot dataset. + +This variant keeps the ATEC action/state representation intact: +6 arm joints + 2 gripper joints. The OpenPI transform pads the 8D vector to +the pi0.5 model dimension later, which avoids the old fixed-base 12+4 mapping. +""" + +from __future__ import annotations + +import argparse +import os +from pathlib import Path +import shutil + +import h5py +import numpy as np +from lerobot.common.datasets.lerobot_dataset import LeRobotDataset +from tqdm import tqdm + + +DEFAULT_PROMPT = "identify all objects, pick them up, and place them into the target basket" +DEFAULT_JOINT_POS = np.asarray([0.0, 1.2, -1.5, 0.0, 1.2, 0.0, 0.035, -0.035], dtype=np.float32) +ACTION_SCALE = np.float32(0.5) + + +def _sorted_traj_keys(h5_file: h5py.File) -> list[str]: + keys = [key for key in h5_file.keys() if key.startswith("traj_")] + return sorted(keys, key=lambda item: int(item.split("_", 1)[1])) + + +def _resize_image(rgb: np.ndarray, height: int, width: int) -> np.ndarray: + if rgb.shape[0] == height and rgb.shape[1] == width: + return rgb + import cv2 + + return cv2.resize(rgb, (width, height), interpolation=cv2.INTER_AREA) + + +def create_dataset( + *, + repo_id: str, + root: Path, + fps: int, + use_videos: bool, + overwrite: bool, + image_writer_processes: int, + image_writer_threads: int, + image_height: int, + image_width: int, +) -> LeRobotDataset: + dataset_dir = root / repo_id + if dataset_dir.exists(): + if not overwrite: + raise FileExistsError(f"{dataset_dir} already exists; pass --overwrite to replace it") + shutil.rmtree(dataset_dir) + + features = { + "video.base_camera_view": { + "dtype": "image", + "shape": (image_height, image_width, 3), + "names": ["height", "width", "channel"], + }, + "state": { + "dtype": "float32", + "shape": (8,), + "names": ["state"], + }, + "action": { + "dtype": "float32", + "shape": (8,), + "names": ["action"], + }, + } + return LeRobotDataset.create( + repo_id=repo_id, + root=dataset_dir, + robot_type="atec_piper_task_e_native8", + fps=fps, + features=features, + use_videos=use_videos, + image_writer_processes=image_writer_processes, + image_writer_threads=image_writer_threads, + ) + + +def convert(args: argparse.Namespace) -> None: + input_path = Path(args.input).expanduser().resolve() + root = Path(args.root).expanduser().resolve() + root.mkdir(parents=True, exist_ok=True) + os.environ.setdefault("HF_LEROBOT_HOME", str(root)) + + dataset = create_dataset( + repo_id=args.repo_id, + root=root, + fps=args.fps, + use_videos=args.use_videos, + overwrite=args.overwrite, + image_writer_processes=args.image_writer_processes, + image_writer_threads=args.image_writer_threads, + image_height=args.image_height, + image_width=args.image_width, + ) + + frame_count = 0 + with h5py.File(input_path, "r") as h5_file: + traj_keys = _sorted_traj_keys(h5_file) + if args.max_episodes is not None: + traj_keys = traj_keys[: args.max_episodes] + if not traj_keys: + raise ValueError(f"No traj_* groups found in {input_path}") + + for traj_key in tqdm(traj_keys, desc="episodes"): + group = h5_file[traj_key] + qpos = group["obs"] + actions = group["actions"] + images = group["images/rgb"] + length = min(len(qpos), len(actions), len(images)) + if length <= 0: + continue + + written_this_episode = 0 + for step in range(0, length, args.stride): + if args.max_frames_per_episode is not None and written_this_episode >= args.max_frames_per_episode: + break + rgb = _resize_image(images[step], args.image_height, args.image_width) + action = np.asarray(actions[step], dtype=np.float32) + if args.action_mode == "absolute_target": + action = DEFAULT_JOINT_POS + ACTION_SCALE * action + elif args.action_mode != "env_action": + raise ValueError(f"Unsupported --action_mode={args.action_mode!r}") + dataset.add_frame( + { + "video.base_camera_view": rgb, + "state": np.asarray(qpos[step], dtype=np.float32), + "action": action, + "task": args.prompt, + } + ) + frame_count += 1 + written_this_episode += 1 + dataset.save_episode() + + print( + f"[OK] Wrote native8 LeRobot dataset repo_id={args.repo_id} " + f"root={root} episodes={len(traj_keys)} frames={frame_count}" + ) + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser() + parser.add_argument("--input", default="datasets/atec_task_e_obj321_servo_100demos/trajectory_filtered.hdf5") + parser.add_argument("--root", default="/home/ubuntu/projects/robotics_shared/datasets/lerobot") + parser.add_argument("--repo_id", default="atec/task_e_obj321_servo_20demos_native8_s1_224") + parser.add_argument("--prompt", default=DEFAULT_PROMPT) + parser.add_argument("--fps", type=int, default=50) + parser.add_argument("--image_height", type=int, default=224) + parser.add_argument("--image_width", type=int, default=224) + parser.add_argument("--stride", type=int, default=1) + parser.add_argument("--max_episodes", type=int, default=20) + parser.add_argument( + "--max_frames_per_episode", + type=int, + default=None, + help="Optional cap after stride sampling; useful for fast bridge sanity checks on long raw demos.", + ) + parser.add_argument( + "--action_mode", + choices=("env_action", "absolute_target"), + default="env_action", + help=( + "Store raw ATEC env actions, or convert them to absolute joint targets with " + "joint_target = default_joint_pos + 0.5 * env_action." + ), + ) + parser.add_argument("--use_videos", action=argparse.BooleanOptionalAction, default=False) + parser.add_argument("--overwrite", action="store_true") + parser.add_argument("--image_writer_processes", type=int, default=5) + parser.add_argument("--image_writer_threads", type=int, default=10) + return parser.parse_args() + + +if __name__ == "__main__": + convert(parse_args()) diff --git a/scripts/pi05/eval_task_e_pi05.py b/scripts/pi05/eval_task_e_pi05.py new file mode 100644 index 0000000000000000000000000000000000000000..d117bc1baab83985365e1ecbb965c703086da10c --- /dev/null +++ b/scripts/pi05/eval_task_e_pi05.py @@ -0,0 +1,183 @@ +#!/usr/bin/env python3 +"""Rollout evaluation for a Task-E pi0.5 websocket policy.""" + +from __future__ import annotations + +import argparse +import os +import sys +import time +from datetime import datetime + +from isaaclab.app import AppLauncher + + +parser = argparse.ArgumentParser(description="Evaluate an OpenPI/pi0.5 server on ATEC Task E.") +parser.add_argument("--task", type=str, default="ATEC-TaskE-Piper") +parser.add_argument("--episodes", type=int, default=1) +parser.add_argument("--max_steps", type=int, default=1500) +parser.add_argument("--video_path", type=str, default=None, help="Optional MP4 output path for episode 1.") +parser.add_argument("--video_interval", type=int, default=2) +parser.add_argument("--video_fps", type=int, default=25) +parser.add_argument("--seed", type=int, default=None) +parser.add_argument("--host", type=str, default="127.0.0.1") +parser.add_argument("--port", type=int, default=8000) +parser.add_argument("--action_repeat", type=int, default=5) +parser.add_argument("--solution_module", type=str, default="solution_pi05") +parser.add_argument("--disable_fabric", action="store_true", default=False) +parser.add_argument("--debug", action="store_true", default=False) +AppLauncher.add_app_launcher_args(parser) +args_cli = parser.parse_args() +args_cli.enable_cameras = True + +repo_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..")) +os.environ["ATEC_PI05_HOST"] = args_cli.host +os.environ["ATEC_PI05_PORT"] = str(args_cli.port) +os.environ["ATEC_PI05_ACTION_REPEAT"] = str(args_cli.action_repeat) + +app_launcher = AppLauncher(args_cli) +simulation_app = app_launcher.app + +import gymnasium as gym # noqa: E402 +import torch # noqa: E402 + +from isaaclab.envs import DirectMARLEnv, multi_agent_to_single_agent # noqa: E402 +from isaaclab_tasks.utils import parse_env_cfg # noqa: E402 + +import atec_rl_lab.tasks # noqa: F401, E402 + +demo_dir = os.path.join(repo_root, "demo") +if repo_root not in sys.path: + sys.path.insert(0, repo_root) +if demo_dir not in sys.path: + sys.path.insert(0, demo_dir) + +from scripts.act.task_e.collector import basket_status_lines # noqa: E402 +import importlib # noqa: E402 + +AlgSolution = importlib.import_module(args_cli.solution_module).AlgSolution # noqa: E402 + + +def _frame_from_obs(obs) -> object: + rgb = obs["image"]["video_rgb"] + if isinstance(rgb, torch.Tensor): + frame = rgb[0].detach().cpu() + if frame.ndim == 3 and frame.shape[0] in (3, 4): + frame = frame.permute(1, 2, 0) + if frame.shape[-1] == 4: + frame = frame[..., :3] + if frame.dtype != torch.uint8: + frame = (frame.float() * 255.0).clamp(0, 255).to(torch.uint8) + return frame.numpy() + return rgb[0] + + +def _resolve_video_path() -> str | None: + if args_cli.video_path is None: + return None + if args_cli.video_path: + return os.path.abspath(args_cli.video_path) + stamp = datetime.now().strftime("%Y%m%d_%H%M%S") + return os.path.join(repo_root, "logs", "videos", "task_e_pi05_eval", f"eval_{stamp}.mp4") + + +def evaluate() -> list[dict[str, float]]: + env_cfg = parse_env_cfg( + args_cli.task, + device=args_cli.device, + num_envs=1, + use_fabric=not args_cli.disable_fabric, + ) + if args_cli.seed is not None: + env_cfg.seed = args_cli.seed + env = gym.make(args_cli.task, cfg=env_cfg) + if isinstance(env.unwrapped, DirectMARLEnv): + env = multi_agent_to_single_agent(env) + + policy = AlgSolution() + video_path = _resolve_video_path() + writer = None + if video_path is not None: + import imageio.v2 as imageio + + os.makedirs(os.path.dirname(video_path), exist_ok=True) + writer = imageio.get_writer(video_path, fps=args_cli.video_fps, quality=7) + print(f"[INFO] Recording episode 1 video to: {video_path}") + + results = [] + try: + for episode in range(args_cli.episodes): + reset_kwargs = {"seed": args_cli.seed + episode} if args_cli.seed is not None else {} + obs, _ = env.reset(**reset_kwargs) + policy.reset_episode() + total_reward = 0.0 + elapsed_time = 0.0 + steps = 0 + done = False + start_wall = time.time() + if writer is not None and episode == 0: + writer.append_data(_frame_from_obs(obs)) + + while simulation_app.is_running() and steps < args_cli.max_steps: + resp = policy.predicts(obs, total_reward) + if resp["giveup"]: + break + action = torch.as_tensor(resp["action"], dtype=torch.float32, device=args_cli.device).view(1, -1) + obs, reward, terminated, truncated, info = env.step(action) + + sim_dt = info["Step_dt"] + total_reward += reward.mean().item() / sim_dt if isinstance(reward, torch.Tensor) else float(reward) / sim_dt + if isinstance(info, dict) and "Elapsed_Time" in info: + elapsed = info["Elapsed_Time"] + elapsed_time = elapsed.item() if hasattr(elapsed, "item") else float(elapsed) + else: + elapsed_time += env.unwrapped.step_dt + done = bool(terminated.item() or truncated.item()) + steps += 1 + if writer is not None and episode == 0 and steps % max(1, args_cli.video_interval) == 0: + writer.append_data(_frame_from_obs(obs)) + if args_cli.debug and steps % 100 == 0: + print(f"[DEBUG] episode={episode + 1} step={steps} score={total_reward:.2f}") + if done: + break + + result = { + "episode": episode + 1, + "score": float(total_reward), + "elapsed_time": float(elapsed_time), + "steps": float(steps), + "done": float(done), + "wall_time": time.time() - start_wall, + } + results.append(result) + try: + for line in basket_status_lines(env, [1, 2, 3]): + print(f"[BASKET] episode={episode + 1} {line}") + except Exception as exc: + if args_cli.debug: + print(f"[DEBUG] basket status unavailable: {exc}") + print( + "[RESULT] " + f"episode={result['episode']:.0f} " + f"score={result['score']:.2f} " + f"elapsed_time={result['elapsed_time']:.2f} " + f"steps={result['steps']:.0f} " + f"done={bool(result['done'])} " + f"wall_time={result['wall_time']:.1f}s" + ) + finally: + if writer is not None: + writer.close() + env.close() + + return results + + +if __name__ == "__main__": + try: + results = evaluate() + if results: + scores = torch.tensor([r["score"] for r in results], dtype=torch.float32) + print(f"[SUMMARY] episodes={len(results)} mean_score={scores.mean().item():.2f} best_score={scores.max().item():.2f}") + finally: + simulation_app.close() diff --git a/scripts/pi05/run_pi05_20demos_after_convert.sh b/scripts/pi05/run_pi05_20demos_after_convert.sh new file mode 100644 index 0000000000000000000000000000000000000000..b15501791070eec7b6df11faaa0b309c51489fa5 --- /dev/null +++ b/scripts/pi05/run_pi05_20demos_after_convert.sh @@ -0,0 +1,42 @@ +#!/usr/bin/env bash +set -euo pipefail + +REPO=/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge +OPENPI=/home/ubuntu/src/openpi-ebench-clean +PY=/home/ubuntu/envs/openpi-pi05/bin/python +CONFIG=pi05_atec_task_e_20demos_s5_224 +CONVERT_UNIT_FILE="$REPO/logs/pi05_convert_task_e_s5_224_20demos.latest_unit" +STAMP="$(date +%Y%m%d%H%M%S)" +NORM_LOG="$REPO/logs/pi05_norm_task_e_20demos_s5_224_${STAMP}.log" +TRAIN_LOG="$REPO/logs/pi05_train_task_e_20demos_s5_224_${STAMP}.log" + +export HF_LEROBOT_HOME=/home/ubuntu/projects/robotics_shared/datasets/lerobot +export HF_HOME=/home/ubuntu/projects/robotics_shared/hf_cache +export PYTHONPATH="$OPENPI/src:$OPENPI/packages/openpi-client/src" +export XLA_PYTHON_CLIENT_MEM_FRACTION="${XLA_PYTHON_CLIENT_MEM_FRACTION:-0.80}" + +cd "$OPENPI" + +if [[ -f "$CONVERT_UNIT_FILE" ]]; then + convert_unit="$(cat "$CONVERT_UNIT_FILE").service" + echo "[INFO] Waiting for $convert_unit" + while systemctl --user is-active --quiet "$convert_unit"; do + sleep 60 + done + systemctl --user is-failed --quiet "$convert_unit" && { + echo "[ERROR] Conversion unit failed: $convert_unit" + systemctl --user status "$convert_unit" --no-pager --lines=80 || true + exit 1 + } +fi + +echo "[INFO] Computing norm stats for $CONFIG" | tee "$NORM_LOG" +"$PY" scripts/compute_norm_stats.py \ + --config-name "$CONFIG" \ + --max-frames 7000 2>&1 | tee -a "$NORM_LOG" + +echo "[INFO] Training $CONFIG" | tee "$TRAIN_LOG" +"$PY" scripts/train.py \ + "$CONFIG" \ + --exp-name atec_task_e_pi05_20demos_s5_224_2k_${STAMP} \ + --overwrite 2>&1 | tee -a "$TRAIN_LOG" diff --git a/scripts/pi05/run_pi05_eval_checkpoint.sh b/scripts/pi05/run_pi05_eval_checkpoint.sh new file mode 100644 index 0000000000000000000000000000000000000000..ffb9d01613a5172fb31aaca94e7fdbc06e64fa31 --- /dev/null +++ b/scripts/pi05/run_pi05_eval_checkpoint.sh @@ -0,0 +1,84 @@ +#!/usr/bin/env bash +set -euo pipefail + +REPO=/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge +OPENPI=/home/ubuntu/src/openpi-ebench-clean +OPENPI_PY=/home/ubuntu/envs/openpi-pi05/bin/python +ISAAC_PY=/home/ubuntu/envs/genmanip-isaac5-py311/bin/python + +CONFIG="${CONFIG:-pi05_atec_task_e_s5_224}" +CHECKPOINT_DIR="${1:-${CHECKPOINT_DIR:-}}" +PORT="${PORT:-8015}" +ACTION_REPEAT="${ACTION_REPEAT:-5}" +STAMP="$(date +%Y%m%d%H%M%S)" +SERVER_LOG="$REPO/logs/pi05_policy_server_${STAMP}.log" +EVAL_DIR="$REPO/logs/pi05_eval_${STAMP}" + +if [[ -z "$CHECKPOINT_DIR" ]]; then + CHECKPOINT_DIR="$(find /home/ubuntu/projects/robotics_shared/checkpoints/openpi/atec_runs/checkpoints/"$CONFIG" -mindepth 2 -maxdepth 2 -type d -regex '.*/[0-9]+' 2>/dev/null | sort -V | tail -1 || true)" +fi +if [[ -z "$CHECKPOINT_DIR" || ! -d "$CHECKPOINT_DIR" ]]; then + echo "[ERROR] Checkpoint dir not found. Pass it as argv[1] or set CHECKPOINT_DIR." >&2 + exit 1 +fi + +mkdir -p "$EVAL_DIR" "$REPO/logs/videos/task_e_pi05_eval" + +export HF_LEROBOT_HOME=/home/ubuntu/projects/robotics_shared/datasets/lerobot +export HF_HOME=/home/ubuntu/projects/robotics_shared/hf_cache +export PYTHONPATH="$OPENPI/src:$OPENPI/packages/openpi-client/src" + +cd "$OPENPI" +"$OPENPI_PY" scripts/serve_policy.py \ + --port "$PORT" \ + policy:checkpoint \ + --policy.config "$CONFIG" \ + --policy.dir "$CHECKPOINT_DIR" \ + > "$SERVER_LOG" 2>&1 & +server_pid=$! + +cleanup() { + kill "$server_pid" 2>/dev/null || true +} +trap cleanup EXIT + +echo "[INFO] Started OpenPI server pid=$server_pid port=$PORT checkpoint=$CHECKPOINT_DIR" +for _ in $(seq 1 120); do + if grep -q "Creating server" "$SERVER_LOG" 2>/dev/null; then + break + fi + if ! kill -0 "$server_pid" 2>/dev/null; then + echo "[ERROR] OpenPI server exited early. Tail:" >&2 + tail -80 "$SERVER_LOG" >&2 || true + exit 1 + fi + sleep 5 +done + +export OMNI_KIT_ACCEPT_EULA=YES +export PYTHONUNBUFFERED=1 +export PYTHONPATH="/home/ubuntu/envs/genmanip-isaac5-py311/lib/python3.11/site-packages/isaaclab/source/isaaclab:/home/ubuntu/envs/genmanip-isaac5-py311/lib/python3.11/site-packages/isaaclab/source/isaaclab_assets:/home/ubuntu/envs/genmanip-isaac5-py311/lib/python3.11/site-packages/isaaclab/source/isaaclab_tasks:$REPO/source/atec_rl_lab:$REPO/scripts/act" + +cd "$REPO" +for seed in 11 12 13; do + video_arg=() + if [[ "$seed" == "11" ]]; then + video_arg=(--video_path "$REPO/logs/videos/task_e_pi05_eval/pi05_${CONFIG}_seed11_${STAMP}.mp4") + fi + "$ISAAC_PY" scripts/pi05/eval_task_e_pi05.py \ + --episodes 1 \ + --seed "$seed" \ + --host 127.0.0.1 \ + --port "$PORT" \ + --action_repeat "$ACTION_REPEAT" \ + --headless \ + --disable_fabric \ + "${video_arg[@]}" \ + > "$EVAL_DIR/seed${seed}.log" 2>&1 + tail -12 "$EVAL_DIR/seed${seed}.log" +done + +"$ISAAC_PY" scripts/pi05/summarize_pi05_eval.py "$EVAL_DIR" || true +"$ISAAC_PY" scripts/pi05/compare_pi05_vs_act_baseline.py "$EVAL_DIR" --repo "$REPO" || true +echo "[INFO] Eval logs: $EVAL_DIR" +echo "[INFO] Server log: $SERVER_LOG" diff --git a/scripts/pi05/run_pi05_native8_100demos_prepare.sh b/scripts/pi05/run_pi05_native8_100demos_prepare.sh new file mode 100644 index 0000000000000000000000000000000000000000..5facf27c9865dd03864735ae8156e1a5f2152742 --- /dev/null +++ b/scripts/pi05/run_pi05_native8_100demos_prepare.sh @@ -0,0 +1,30 @@ +#!/usr/bin/env bash +set -euo pipefail + +REPO=/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge +OPENPI=/home/ubuntu/src/openpi-ebench-clean +PY=/home/ubuntu/envs/openpi-pi05/bin/python +CONFIG=pi05_atec_task_e_native8_100demos_s1_224 +REPO_ID=atec/task_e_obj321_servo_100demos_native8_s1_224 +STAMP="$(date +%Y%m%d%H%M%S)" + +export HF_LEROBOT_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot +export HF_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/hf_cache +export PYTHONPATH="$OPENPI/src:$OPENPI/packages/openpi-client/src" + +cd "$REPO" +"$PY" scripts/pi05/convert_task_e_hdf5_to_lerobot_native8.py \ + --root "$HF_LEROBOT_HOME" \ + --repo_id "$REPO_ID" \ + --max_episodes 100 \ + --stride 1 \ + --fps 50 \ + --overwrite \ + 2>&1 | tee "logs/pi05_native8_convert_100demos_s1_224_${STAMP}.log" + +cd "$OPENPI" +"$PY" scripts/compute_norm_stats.py \ + --config-name "$CONFIG" \ + 2>&1 | tee "$REPO/logs/pi05_native8_norm_100demos_s1_224_${STAMP}.log" + +echo "[INFO] Prepared native8 100-demo dataset/norm stats for $CONFIG" diff --git a/scripts/pi05/run_pi05_native8_100demos_s2_gate.sh b/scripts/pi05/run_pi05_native8_100demos_s2_gate.sh new file mode 100644 index 0000000000000000000000000000000000000000..b86577c038e5001665d1ba609bdf11da60683d44 --- /dev/null +++ b/scripts/pi05/run_pi05_native8_100demos_s2_gate.sh @@ -0,0 +1,47 @@ +#!/usr/bin/env bash +set -euo pipefail + +REPO=/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge +OPENPI=/home/ubuntu/src/openpi-ebench-clean +PY=/home/ubuntu/envs/openpi-pi05/bin/python +CONFIG=pi05_atec_task_e_native8_100demos_s2_224 +REPO_ID=atec/task_e_obj321_servo_100demos_native8_s2_224 +STAMP="${ATEC_PI05_STAMP:-$(date +%Y%m%d%H%M%S)}" + +export HF_LEROBOT_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot +export HF_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/hf_cache +export PYTHONPATH="$OPENPI/src:$OPENPI/packages/openpi-client/src" + +mkdir -p "$REPO/logs" + +cd "$REPO" +"$PY" scripts/pi05/convert_task_e_hdf5_to_lerobot_native8.py \ + --root "$HF_LEROBOT_HOME" \ + --repo_id "$REPO_ID" \ + --max_episodes 100 \ + --stride 2 \ + --fps 25 \ + --overwrite \ + 2>&1 | tee "logs/pi05_native8_convert_100demos_s2_224_${STAMP}.log" + +cd "$OPENPI" +"$PY" scripts/compute_norm_stats.py \ + --config-name "$CONFIG" \ + 2>&1 | tee "$REPO/logs/pi05_native8_norm_100demos_s2_224_${STAMP}.log" + +"$PY" scripts/train.py \ + "$CONFIG" \ + --exp-name "atec_task_e_pi05_native8_100demos_s2_224_10k_${STAMP}" \ + --overwrite \ + 2>&1 | tee "$REPO/logs/pi05_native8_train_100demos_s2_224_${STAMP}.log" + +CKPT_DIR="$(find /data/Data4TB/01Proj/13atec/openpi_atec_runs/checkpoints/"$CONFIG" -mindepth 2 -maxdepth 2 -type d -regex '.*/[0-9]+' 2>/dev/null | sort -V | tail -1 || true)" +if [[ -z "$CKPT_DIR" ]]; then + echo "[ERROR] No checkpoint found after training for $CONFIG" >&2 + exit 1 +fi + +cd "$REPO" +CONFIG="$CONFIG" ACTION_REPEAT=2 PORT=8023 \ + scripts/pi05/run_pi05_native8_eval_checkpoint.sh "$CKPT_DIR" \ + 2>&1 | tee "logs/pi05_native8_eval_100demos_s2_224_${STAMP}.log" diff --git a/scripts/pi05/run_pi05_native8_100demos_s2_lora_gate.sh b/scripts/pi05/run_pi05_native8_100demos_s2_lora_gate.sh new file mode 100644 index 0000000000000000000000000000000000000000..e3f929c2e1f8c92858e5af5198336ba95effa419 --- /dev/null +++ b/scripts/pi05/run_pi05_native8_100demos_s2_lora_gate.sh @@ -0,0 +1,55 @@ +#!/usr/bin/env bash +set -euo pipefail + +REPO=/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge +OPENPI=/home/ubuntu/src/openpi-ebench-clean +PY=/home/ubuntu/envs/openpi-pi05/bin/python +CONFIG=pi05_atec_task_e_native8_100demos_s2_224_lora +BASE_CONFIG=pi05_atec_task_e_native8_100demos_s2_224 +REPO_ID=atec/task_e_obj321_servo_100demos_native8_s2_224 +STAMP="${ATEC_PI05_STAMP:-$(date +%Y%m%d%H%M%S)}" + +export HF_LEROBOT_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot +export HF_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/hf_cache +export PYTHONPATH="$OPENPI/src:$OPENPI/packages/openpi-client/src" + +DATA_DIR="$HF_LEROBOT_HOME/$REPO_ID" +BASE_ASSET_DIR="/data/Data4TB/01Proj/13atec/openpi_atec_runs/assets/$BASE_CONFIG/$REPO_ID" +LORA_ASSET_DIR="/data/Data4TB/01Proj/13atec/openpi_atec_runs/assets/$CONFIG/$REPO_ID" + +mkdir -p "$REPO/logs" + +if [[ ! -d "$DATA_DIR" ]]; then + echo "[ERROR] Missing native8 100-demo dataset: $DATA_DIR" >&2 + echo "[ERROR] Run scripts/pi05/run_pi05_native8_100demos_s2_gate.sh once before LoRA." >&2 + exit 1 +fi + +if [[ -f "$BASE_ASSET_DIR/norm_stats.json" ]]; then + mkdir -p "$LORA_ASSET_DIR" + cp "$BASE_ASSET_DIR/norm_stats.json" "$LORA_ASSET_DIR/norm_stats.json" + echo "[INFO] Reused norm stats from $BASE_ASSET_DIR" +else + cd "$OPENPI" + "$PY" scripts/compute_norm_stats.py \ + --config-name "$CONFIG" \ + 2>&1 | tee "$REPO/logs/pi05_native8_lora_norm_100demos_s2_224_${STAMP}.log" +fi + +cd "$OPENPI" +"$PY" scripts/train.py \ + "$CONFIG" \ + --exp-name "atec_task_e_pi05_native8_100demos_s2_224_lora_7500_${STAMP}" \ + --overwrite \ + 2>&1 | tee "$REPO/logs/pi05_native8_lora_train_100demos_s2_224_${STAMP}.log" + +CKPT_DIR="$(find /data/Data4TB/01Proj/13atec/openpi_atec_runs/checkpoints/"$CONFIG" -mindepth 2 -maxdepth 2 -type d -regex '.*/[0-9]+' 2>/dev/null | sort -V | tail -1 || true)" +if [[ -z "$CKPT_DIR" ]]; then + echo "[ERROR] No checkpoint found after training for $CONFIG" >&2 + exit 1 +fi + +cd "$REPO" +CONFIG="$CONFIG" ACTION_REPEAT=2 PORT=8024 \ + scripts/pi05/run_pi05_native8_eval_checkpoint.sh "$CKPT_DIR" \ + 2>&1 | tee "logs/pi05_native8_lora_eval_100demos_s2_224_${STAMP}.log" diff --git a/scripts/pi05/run_pi05_native8_20demos_s2_smoke.sh b/scripts/pi05/run_pi05_native8_20demos_s2_smoke.sh new file mode 100644 index 0000000000000000000000000000000000000000..b6dd737b8963fb4af2d6cd819e4cc829f5a9af24 --- /dev/null +++ b/scripts/pi05/run_pi05_native8_20demos_s2_smoke.sh @@ -0,0 +1,45 @@ +#!/usr/bin/env bash +set -euo pipefail + +REPO=/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge +OPENPI=/home/ubuntu/src/openpi-ebench-clean +PY=/home/ubuntu/envs/openpi-pi05/bin/python +CONFIG=pi05_atec_task_e_native8_20demos_s2_224 +REPO_ID=atec/task_e_obj321_servo_20demos_native8_s2_224 +STAMP="$(date +%Y%m%d%H%M%S)" + +export HF_LEROBOT_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot +export HF_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/hf_cache +export PYTHONPATH="$OPENPI/src:$OPENPI/packages/openpi-client/src" + +cd "$REPO" +"$PY" scripts/pi05/convert_task_e_hdf5_to_lerobot_native8.py \ + --root "$HF_LEROBOT_HOME" \ + --repo_id "$REPO_ID" \ + --max_episodes 20 \ + --stride 2 \ + --fps 25 \ + --overwrite \ + 2>&1 | tee "logs/pi05_native8_convert_20demos_s2_224_${STAMP}.log" + +cd "$OPENPI" +"$PY" scripts/compute_norm_stats.py \ + --config-name "$CONFIG" \ + 2>&1 | tee "$REPO/logs/pi05_native8_norm_20demos_s2_224_${STAMP}.log" + +"$PY" scripts/train.py \ + "$CONFIG" \ + --exp-name "atec_task_e_pi05_native8_20demos_s2_224_3k_${STAMP}" \ + --overwrite \ + 2>&1 | tee "$REPO/logs/pi05_native8_train_20demos_s2_224_${STAMP}.log" + +CKPT_DIR="$(find /data/Data4TB/01Proj/13atec/openpi_atec_runs/checkpoints/"$CONFIG" -mindepth 2 -maxdepth 2 -type d -regex '.*/[0-9]+' 2>/dev/null | sort -V | tail -1 || true)" +if [[ -z "$CKPT_DIR" ]]; then + echo "[ERROR] No checkpoint found after training for $CONFIG" >&2 + exit 1 +fi + +cd "$REPO" +CONFIG="$CONFIG" ACTION_REPEAT=2 PORT=8022 \ + scripts/pi05/run_pi05_native8_eval_checkpoint.sh "$CKPT_DIR" \ + 2>&1 | tee "logs/pi05_native8_eval_20demos_s2_224_${STAMP}.log" diff --git a/scripts/pi05/run_pi05_native8_20demos_smoke.sh b/scripts/pi05/run_pi05_native8_20demos_smoke.sh new file mode 100644 index 0000000000000000000000000000000000000000..23e754b8a71e48c1d0589e4e964f1305ec8c464c --- /dev/null +++ b/scripts/pi05/run_pi05_native8_20demos_smoke.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +set -euo pipefail + +REPO=/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge +OPENPI=/home/ubuntu/src/openpi-ebench-clean +PY=/home/ubuntu/envs/openpi-pi05/bin/python +CONFIG=pi05_atec_task_e_native8_20demos_s1_224 +REPO_ID=atec/task_e_obj321_servo_20demos_native8_s1_224 +STAMP="$(date +%Y%m%d%H%M%S)" + +export HF_LEROBOT_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot +export HF_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/hf_cache +export PYTHONPATH="$OPENPI/src:$OPENPI/packages/openpi-client/src" + +cd "$REPO" +"$PY" scripts/pi05/convert_task_e_hdf5_to_lerobot_native8.py \ + --root "$HF_LEROBOT_HOME" \ + --repo_id "$REPO_ID" \ + --max_episodes 20 \ + --stride 1 \ + --fps 50 \ + --overwrite \ + 2>&1 | tee "logs/pi05_native8_convert_20demos_s1_224_${STAMP}.log" + +cd "$OPENPI" +"$PY" scripts/compute_norm_stats.py \ + --config-name "$CONFIG" \ + 2>&1 | tee "$REPO/logs/pi05_native8_norm_20demos_s1_224_${STAMP}.log" + +"$PY" scripts/train.py \ + "$CONFIG" \ + --exp-name "atec_task_e_pi05_native8_20demos_s1_224_5k_${STAMP}" \ + --overwrite \ + 2>&1 | tee "$REPO/logs/pi05_native8_train_20demos_s1_224_${STAMP}.log" diff --git a/scripts/pi05/run_pi05_native8_4demos_s2_sanity.sh b/scripts/pi05/run_pi05_native8_4demos_s2_sanity.sh new file mode 100644 index 0000000000000000000000000000000000000000..23a727c9149c9833a84a7b4f87094c5c5b574b2e --- /dev/null +++ b/scripts/pi05/run_pi05_native8_4demos_s2_sanity.sh @@ -0,0 +1,45 @@ +#!/usr/bin/env bash +set -euo pipefail + +REPO=/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge +OPENPI=/home/ubuntu/src/openpi-ebench-clean +PY=/home/ubuntu/envs/openpi-pi05/bin/python +CONFIG=pi05_atec_task_e_native8_4demos_s2_224 +REPO_ID=atec/task_e_obj321_servo_4demos_native8_s2_224 +STAMP="$(date +%Y%m%d%H%M%S)" + +export HF_LEROBOT_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot +export HF_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/hf_cache +export PYTHONPATH="$OPENPI/src:$OPENPI/packages/openpi-client/src" + +cd "$REPO" +"$PY" scripts/pi05/convert_task_e_hdf5_to_lerobot_native8.py \ + --root "$HF_LEROBOT_HOME" \ + --repo_id "$REPO_ID" \ + --max_episodes 4 \ + --stride 2 \ + --fps 25 \ + --overwrite \ + 2>&1 | tee "logs/pi05_native8_convert_4demos_s2_224_${STAMP}.log" + +cd "$OPENPI" +"$PY" scripts/compute_norm_stats.py \ + --config-name "$CONFIG" \ + 2>&1 | tee "$REPO/logs/pi05_native8_norm_4demos_s2_224_${STAMP}.log" + +"$PY" scripts/train.py \ + "$CONFIG" \ + --exp-name "atec_task_e_pi05_native8_4demos_s2_224_1k_${STAMP}" \ + --overwrite \ + 2>&1 | tee "$REPO/logs/pi05_native8_train_4demos_s2_224_${STAMP}.log" + +CKPT_DIR="$(find /data/Data4TB/01Proj/13atec/openpi_atec_runs/checkpoints/"$CONFIG" -mindepth 2 -maxdepth 2 -type d -regex '.*/[0-9]+' 2>/dev/null | sort -V | tail -1 || true)" +if [[ -z "$CKPT_DIR" ]]; then + echo "[ERROR] No checkpoint found after training for $CONFIG" >&2 + exit 1 +fi + +cd "$REPO" +CONFIG="$CONFIG" ACTION_REPEAT=2 PORT=8023 MAX_STEPS=2200 \ + scripts/pi05/run_pi05_native8_eval_checkpoint.sh "$CKPT_DIR" \ + 2>&1 | tee "logs/pi05_native8_eval_4demos_s2_224_${STAMP}.log" diff --git a/scripts/pi05/run_pi05_native8_eval_checkpoint.sh b/scripts/pi05/run_pi05_native8_eval_checkpoint.sh new file mode 100644 index 0000000000000000000000000000000000000000..12015a06aec31c807be7b4748b657a9e824216a3 --- /dev/null +++ b/scripts/pi05/run_pi05_native8_eval_checkpoint.sh @@ -0,0 +1,87 @@ +#!/usr/bin/env bash +set -euo pipefail + +REPO=/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge +OPENPI=/home/ubuntu/src/openpi-ebench-clean +OPENPI_PY=/home/ubuntu/envs/openpi-pi05/bin/python +ISAAC_PY=/home/ubuntu/envs/genmanip-isaac5-py311/bin/python + +CONFIG="${CONFIG:-pi05_atec_task_e_native8_20demos_s1_224}" +CHECKPOINT_DIR="${1:-${CHECKPOINT_DIR:-}}" +PORT="${PORT:-8021}" +ACTION_REPEAT="${ACTION_REPEAT:-1}" +MAX_STEPS="${MAX_STEPS:-2200}" +SEEDS="${SEEDS:-11 12 13}" +STAMP="$(date +%Y%m%d%H%M%S)" +SERVER_LOG="$REPO/logs/pi05_native8_policy_server_${STAMP}.log" +EVAL_DIR="$REPO/logs/pi05_native8_eval_${STAMP}" + +if [[ -z "$CHECKPOINT_DIR" ]]; then + CHECKPOINT_DIR="$(find /data/Data4TB/01Proj/13atec/openpi_atec_runs/checkpoints/"$CONFIG" -mindepth 2 -maxdepth 2 -type d -regex '.*/[0-9]+' 2>/dev/null | sort -V | tail -1 || true)" +fi +if [[ -z "$CHECKPOINT_DIR" || ! -d "$CHECKPOINT_DIR" ]]; then + echo "[ERROR] Checkpoint dir not found. Pass it as argv[1] or set CHECKPOINT_DIR." >&2 + exit 1 +fi + +mkdir -p "$EVAL_DIR" "$REPO/logs/videos/task_e_pi05_native8_eval" + +export HF_LEROBOT_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot +export HF_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/hf_cache +export PYTHONPATH="$OPENPI/src:$OPENPI/packages/openpi-client/src" + +cd "$OPENPI" +"$OPENPI_PY" scripts/serve_policy.py \ + --port "$PORT" \ + policy:checkpoint \ + --policy.config "$CONFIG" \ + --policy.dir "$CHECKPOINT_DIR" \ + > "$SERVER_LOG" 2>&1 & +server_pid=$! + +cleanup() { + kill "$server_pid" 2>/dev/null || true +} +trap cleanup EXIT + +echo "[INFO] Started OpenPI native8 server pid=$server_pid port=$PORT checkpoint=$CHECKPOINT_DIR" +for _ in $(seq 1 120); do + if grep -q "Creating server" "$SERVER_LOG" 2>/dev/null; then + break + fi + if ! kill -0 "$server_pid" 2>/dev/null; then + echo "[ERROR] OpenPI server exited early. Tail:" >&2 + tail -80 "$SERVER_LOG" >&2 || true + exit 1 + fi + sleep 5 +done + +export OMNI_KIT_ACCEPT_EULA=YES +export PYTHONUNBUFFERED=1 +export PYTHONPATH="/home/ubuntu/envs/genmanip-isaac5-py311/lib/python3.11/site-packages/isaaclab/source/isaaclab:/home/ubuntu/envs/genmanip-isaac5-py311/lib/python3.11/site-packages/isaaclab/source/isaaclab_assets:/home/ubuntu/envs/genmanip-isaac5-py311/lib/python3.11/site-packages/isaaclab/source/isaaclab_tasks:$REPO/source/atec_rl_lab:$REPO/scripts/act" + +cd "$REPO" +for seed in $SEEDS; do + video_arg=() + if [[ "$seed" == "11" ]]; then + video_arg=(--video_path "$REPO/logs/videos/task_e_pi05_native8_eval/pi05_native8_${CONFIG}_seed11_${STAMP}.mp4") + fi + "$ISAAC_PY" scripts/pi05/eval_task_e_pi05.py \ + --episodes 1 \ + --seed "$seed" \ + --host 127.0.0.1 \ + --port "$PORT" \ + --action_repeat "$ACTION_REPEAT" \ + --max_steps "$MAX_STEPS" \ + --solution_module solution_pi05_native8 \ + --headless \ + --disable_fabric \ + "${video_arg[@]}" \ + > "$EVAL_DIR/seed${seed}.log" 2>&1 + tail -12 "$EVAL_DIR/seed${seed}.log" +done + +"$ISAAC_PY" scripts/pi05/summarize_pi05_eval.py "$EVAL_DIR" || true +echo "[INFO] Eval logs: $EVAL_DIR" +echo "[INFO] Server log: $SERVER_LOG" diff --git a/scripts/pi05/run_pi05_native8_rawabs_1demo_s10_aefull_h10_10k_lr5.sh b/scripts/pi05/run_pi05_native8_rawabs_1demo_s10_aefull_h10_10k_lr5.sh new file mode 100644 index 0000000000000000000000000000000000000000..148154fefee180b1a5eb53769931f958ba341506 --- /dev/null +++ b/scripts/pi05/run_pi05_native8_rawabs_1demo_s10_aefull_h10_10k_lr5.sh @@ -0,0 +1,31 @@ +#!/usr/bin/env bash +set -euo pipefail + +REPO=/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge +OPENPI=/home/ubuntu/src/openpi-ebench-clean +PY=/home/ubuntu/envs/openpi-pi05/bin/python +CONFIG=pi05_atec_task_e_native8_rawabs_1demo_s10_224_aefull_h10_10k_lr5 +DATASET_DIR=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot/atec/task_e_obj321_servo_rawabs_1demo_native8_s10_224 +STAMP="${ATEC_PI05_STAMP:-$(date +%Y%m%d%H%M%S)}" + +export HF_LEROBOT_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot +export HF_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/hf_cache +export PYTHONPATH="$OPENPI/src:$OPENPI/packages/openpi-client/src" + +mkdir -p "$REPO/logs" + +if [[ ! -d "$DATASET_DIR" ]]; then + echo "[ERROR] Missing dataset: $DATASET_DIR" >&2 + exit 1 +fi + +cd "$OPENPI" +"$PY" scripts/compute_norm_stats.py \ + --config-name "$CONFIG" \ + 2>&1 | tee "$REPO/logs/pi05_native8_rawabs_norm_1demo_s10_224_aefull_h10_10k_lr5_${STAMP}.log" + +"$PY" scripts/train.py \ + "$CONFIG" \ + --exp-name "atec_task_e_pi05_native8_rawabs_1demo_s10_224_aefull_h10_10k_lr5_${STAMP}" \ + --overwrite \ + 2>&1 | tee "$REPO/logs/pi05_native8_rawabs_train_1demo_s10_224_aefull_h10_10k_lr5_${STAMP}.log" diff --git a/scripts/pi05/run_pi05_native8_rawabs_1demo_s10_aefull_h10_2k.sh b/scripts/pi05/run_pi05_native8_rawabs_1demo_s10_aefull_h10_2k.sh new file mode 100644 index 0000000000000000000000000000000000000000..8e8df802a16a686b074a48ee34a8c34d3439d69f --- /dev/null +++ b/scripts/pi05/run_pi05_native8_rawabs_1demo_s10_aefull_h10_2k.sh @@ -0,0 +1,31 @@ +#!/usr/bin/env bash +set -euo pipefail + +REPO=/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge +OPENPI=/home/ubuntu/src/openpi-ebench-clean +PY=/home/ubuntu/envs/openpi-pi05/bin/python +CONFIG=pi05_atec_task_e_native8_rawabs_1demo_s10_224_aefull_h10_2k +DATASET_DIR=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot/atec/task_e_obj321_servo_rawabs_1demo_native8_s10_224 +STAMP="${ATEC_PI05_STAMP:-$(date +%Y%m%d%H%M%S)}" + +export HF_LEROBOT_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot +export HF_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/hf_cache +export PYTHONPATH="$OPENPI/src:$OPENPI/packages/openpi-client/src" + +mkdir -p "$REPO/logs" + +if [[ ! -d "$DATASET_DIR" ]]; then + echo "[ERROR] Missing dataset: $DATASET_DIR" >&2 + exit 1 +fi + +cd "$OPENPI" +"$PY" scripts/compute_norm_stats.py \ + --config-name "$CONFIG" \ + 2>&1 | tee "$REPO/logs/pi05_native8_rawabs_norm_1demo_s10_224_aefull_h10_2k_${STAMP}.log" + +"$PY" scripts/train.py \ + "$CONFIG" \ + --exp-name "atec_task_e_pi05_native8_rawabs_1demo_s10_224_aefull_h10_2k_${STAMP}" \ + --overwrite \ + 2>&1 | tee "$REPO/logs/pi05_native8_rawabs_train_1demo_s10_224_aefull_h10_2k_${STAMP}.log" diff --git a/scripts/pi05/run_pi05_native8_rawabs_1demo_s10_lora_base2k.sh b/scripts/pi05/run_pi05_native8_rawabs_1demo_s10_lora_base2k.sh new file mode 100644 index 0000000000000000000000000000000000000000..44e73410457911370e4f4daf4b029379a4f9347a --- /dev/null +++ b/scripts/pi05/run_pi05_native8_rawabs_1demo_s10_lora_base2k.sh @@ -0,0 +1,43 @@ +#!/usr/bin/env bash +set -euo pipefail + +REPO=/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge +OPENPI=/home/ubuntu/src/openpi-ebench-clean +PY=/home/ubuntu/envs/openpi-pi05/bin/python +CONFIG=pi05_atec_task_e_native8_rawabs_1demo_s10_224_lora_base2k +DATASET_DIR=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot/atec/task_e_obj321_servo_rawabs_1demo_native8_s10_224 +STAMP="${ATEC_PI05_STAMP:-$(date +%Y%m%d%H%M%S)}" + +export HF_LEROBOT_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot +export HF_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/hf_cache +export PYTHONPATH="$OPENPI/src:$OPENPI/packages/openpi-client/src" + +mkdir -p "$REPO/logs" + +if [[ ! -d "$DATASET_DIR" ]]; then + echo "[ERROR] Missing dataset: $DATASET_DIR" >&2 + echo "Run scripts/pi05/run_pi05_native8_rawabs_1demo_s10_lora_sanity.sh first." >&2 + exit 1 +fi + +cd "$OPENPI" +"$PY" scripts/compute_norm_stats.py \ + --config-name "$CONFIG" \ + 2>&1 | tee "$REPO/logs/pi05_native8_rawabs_norm_1demo_s10_224_base2k_${STAMP}.log" + +"$PY" scripts/train.py \ + "$CONFIG" \ + --exp-name "atec_task_e_pi05_native8_rawabs_1demo_s10_224_lora_base2k_${STAMP}" \ + --overwrite \ + 2>&1 | tee "$REPO/logs/pi05_native8_rawabs_train_1demo_s10_224_base2k_${STAMP}.log" + +CKPT_DIR="$(find /data/Data4TB/01Proj/13atec/openpi_atec_runs/checkpoints/"$CONFIG" -mindepth 2 -maxdepth 2 -type d -regex '.*/[0-9]+' 2>/dev/null | sort -V | tail -1 || true)" +if [[ -z "$CKPT_DIR" ]]; then + echo "[ERROR] No checkpoint found after training for $CONFIG" >&2 + exit 1 +fi + +cd "$REPO" +CONFIG="$CONFIG" ACTION_REPEAT=10 MAX_STEPS=1000 SEEDS="${SEEDS:-11}" PORT="${PORT:-8030}" \ + scripts/pi05/run_pi05_native8_eval_checkpoint.sh "$CKPT_DIR" \ + 2>&1 | tee "logs/pi05_native8_rawabs_eval_1demo_s10_224_base2k_${STAMP}.log" diff --git a/scripts/pi05/run_pi05_native8_rawabs_1demo_s10_lora_base_h10_2k.sh b/scripts/pi05/run_pi05_native8_rawabs_1demo_s10_lora_base_h10_2k.sh new file mode 100644 index 0000000000000000000000000000000000000000..eb294e6533fdb503d333845db1111e97fd8d801d --- /dev/null +++ b/scripts/pi05/run_pi05_native8_rawabs_1demo_s10_lora_base_h10_2k.sh @@ -0,0 +1,31 @@ +#!/usr/bin/env bash +set -euo pipefail + +REPO=/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge +OPENPI=/home/ubuntu/src/openpi-ebench-clean +PY=/home/ubuntu/envs/openpi-pi05/bin/python +CONFIG=pi05_atec_task_e_native8_rawabs_1demo_s10_224_lora_base_h10_2k +DATASET_DIR=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot/atec/task_e_obj321_servo_rawabs_1demo_native8_s10_224 +STAMP="${ATEC_PI05_STAMP:-$(date +%Y%m%d%H%M%S)}" + +export HF_LEROBOT_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot +export HF_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/hf_cache +export PYTHONPATH="$OPENPI/src:$OPENPI/packages/openpi-client/src" + +mkdir -p "$REPO/logs" + +if [[ ! -d "$DATASET_DIR" ]]; then + echo "[ERROR] Missing dataset: $DATASET_DIR" >&2 + exit 1 +fi + +cd "$OPENPI" +"$PY" scripts/compute_norm_stats.py \ + --config-name "$CONFIG" \ + 2>&1 | tee "$REPO/logs/pi05_native8_rawabs_norm_1demo_s10_224_base_h10_2k_${STAMP}.log" + +"$PY" scripts/train.py \ + "$CONFIG" \ + --exp-name "atec_task_e_pi05_native8_rawabs_1demo_s10_224_lora_base_h10_2k_${STAMP}" \ + --overwrite \ + 2>&1 | tee "$REPO/logs/pi05_native8_rawabs_train_1demo_s10_224_base_h10_2k_${STAMP}.log" diff --git a/scripts/pi05/run_pi05_native8_rawabs_1demo_s10_lora_sanity.sh b/scripts/pi05/run_pi05_native8_rawabs_1demo_s10_lora_sanity.sh new file mode 100644 index 0000000000000000000000000000000000000000..2af6da68893ffeda0b7a51b3c7d26305b7163ce3 --- /dev/null +++ b/scripts/pi05/run_pi05_native8_rawabs_1demo_s10_lora_sanity.sh @@ -0,0 +1,52 @@ +#!/usr/bin/env bash +set -euo pipefail + +REPO=/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge +OPENPI=/home/ubuntu/src/openpi-ebench-clean +PY=/home/ubuntu/envs/openpi-pi05/bin/python +CONFIG=pi05_atec_task_e_native8_rawabs_1demo_s10_224_lora +REPO_ID=atec/task_e_obj321_servo_rawabs_1demo_native8_s10_224 +STAMP="${ATEC_PI05_STAMP:-$(date +%Y%m%d%H%M%S)}" + +export HF_LEROBOT_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot +export HF_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/hf_cache +export PYTHONPATH="$OPENPI/src:$OPENPI/packages/openpi-client/src" + +mkdir -p "$REPO/logs" + +cd "$REPO" +"$PY" scripts/pi05/convert_task_e_hdf5_to_lerobot_native8.py \ + --input datasets/atec_task_e_obj321_servo_100demos/trajectory.hdf5 \ + --root "$HF_LEROBOT_HOME" \ + --repo_id "$REPO_ID" \ + --max_episodes 1 \ + --stride 10 \ + --max_frames_per_episode 250 \ + --fps 5 \ + --action_mode absolute_target \ + --overwrite \ + --image_writer_processes 2 \ + --image_writer_threads 4 \ + 2>&1 | tee "logs/pi05_native8_rawabs_convert_1demo_s10_224_${STAMP}.log" + +cd "$OPENPI" +"$PY" scripts/compute_norm_stats.py \ + --config-name "$CONFIG" \ + 2>&1 | tee "$REPO/logs/pi05_native8_rawabs_norm_1demo_s10_224_${STAMP}.log" + +"$PY" scripts/train.py \ + "$CONFIG" \ + --exp-name "atec_task_e_pi05_native8_rawabs_1demo_s10_224_lora_500_${STAMP}" \ + --overwrite \ + 2>&1 | tee "$REPO/logs/pi05_native8_rawabs_train_1demo_s10_224_${STAMP}.log" + +CKPT_DIR="$(find /data/Data4TB/01Proj/13atec/openpi_atec_runs/checkpoints/"$CONFIG" -mindepth 2 -maxdepth 2 -type d -regex '.*/[0-9]+' 2>/dev/null | sort -V | tail -1 || true)" +if [[ -z "$CKPT_DIR" ]]; then + echo "[ERROR] No checkpoint found after training for $CONFIG" >&2 + exit 1 +fi + +cd "$REPO" +CONFIG="$CONFIG" ACTION_REPEAT=10 MAX_STEPS=2200 SEEDS="${SEEDS:-11}" PORT="${PORT:-8028}" \ + scripts/pi05/run_pi05_native8_eval_checkpoint.sh "$CKPT_DIR" \ + 2>&1 | tee "logs/pi05_native8_rawabs_eval_1demo_s10_224_${STAMP}.log" diff --git a/scripts/pi05/run_pi05_native8_rawabs_4demos_s2_lora_sanity.sh b/scripts/pi05/run_pi05_native8_rawabs_4demos_s2_lora_sanity.sh new file mode 100644 index 0000000000000000000000000000000000000000..cdf9ab89662c1c7882fcd9634b2a1c83db7237f8 --- /dev/null +++ b/scripts/pi05/run_pi05_native8_rawabs_4demos_s2_lora_sanity.sh @@ -0,0 +1,49 @@ +#!/usr/bin/env bash +set -euo pipefail + +REPO=/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge +OPENPI=/home/ubuntu/src/openpi-ebench-clean +PY=/home/ubuntu/envs/openpi-pi05/bin/python +CONFIG=pi05_atec_task_e_native8_rawabs_4demos_s2_224_lora +REPO_ID=atec/task_e_obj321_servo_rawabs_4demos_native8_s2_224 +STAMP="${ATEC_PI05_STAMP:-$(date +%Y%m%d%H%M%S)}" + +export HF_LEROBOT_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/datasets/lerobot +export HF_HOME=/data/Data4TB/01Proj/13atec/robotics_shared/hf_cache +export PYTHONPATH="$OPENPI/src:$OPENPI/packages/openpi-client/src" + +mkdir -p "$REPO/logs" + +cd "$REPO" +"$PY" scripts/pi05/convert_task_e_hdf5_to_lerobot_native8.py \ + --input datasets/atec_task_e_obj321_servo_100demos/trajectory.hdf5 \ + --root "$HF_LEROBOT_HOME" \ + --repo_id "$REPO_ID" \ + --max_episodes 4 \ + --stride 2 \ + --fps 25 \ + --action_mode absolute_target \ + --overwrite \ + 2>&1 | tee "logs/pi05_native8_rawabs_convert_4demos_s2_224_${STAMP}.log" + +cd "$OPENPI" +"$PY" scripts/compute_norm_stats.py \ + --config-name "$CONFIG" \ + 2>&1 | tee "$REPO/logs/pi05_native8_rawabs_norm_4demos_s2_224_${STAMP}.log" + +"$PY" scripts/train.py \ + "$CONFIG" \ + --exp-name "atec_task_e_pi05_native8_rawabs_4demos_s2_224_lora_1k_${STAMP}" \ + --overwrite \ + 2>&1 | tee "$REPO/logs/pi05_native8_rawabs_train_4demos_s2_224_${STAMP}.log" + +CKPT_DIR="$(find /data/Data4TB/01Proj/13atec/openpi_atec_runs/checkpoints/"$CONFIG" -mindepth 2 -maxdepth 2 -type d -regex '.*/[0-9]+' 2>/dev/null | sort -V | tail -1 || true)" +if [[ -z "$CKPT_DIR" ]]; then + echo "[ERROR] No checkpoint found after training for $CONFIG" >&2 + exit 1 +fi + +cd "$REPO" +CONFIG="$CONFIG" ACTION_REPEAT=2 PORT=8027 \ + scripts/pi05/run_pi05_native8_eval_checkpoint.sh "$CKPT_DIR" \ + 2>&1 | tee "logs/pi05_native8_rawabs_eval_4demos_s2_224_${STAMP}.log" diff --git a/scripts/pi05/run_pi05_s5_after_convert.sh b/scripts/pi05/run_pi05_s5_after_convert.sh new file mode 100644 index 0000000000000000000000000000000000000000..a901d20234a6a9b4283a1bff27e61760b357b09f --- /dev/null +++ b/scripts/pi05/run_pi05_s5_after_convert.sh @@ -0,0 +1,41 @@ +#!/usr/bin/env bash +set -euo pipefail + +REPO=/home/ubuntu/Documents/01Proj/13atec/ATEC2026_Simulation_Challenge +OPENPI=/home/ubuntu/src/openpi-ebench-clean +PY=/home/ubuntu/envs/openpi-pi05/bin/python +CONVERT_UNIT_FILE="$REPO/logs/pi05_convert_task_e_s5_224.latest_unit" +STAMP="$(date +%Y%m%d%H%M%S)" +NORM_LOG="$REPO/logs/pi05_norm_task_e_s5_224_${STAMP}.log" +TRAIN_LOG="$REPO/logs/pi05_train_task_e_s5_224_${STAMP}.log" + +export HF_LEROBOT_HOME=/home/ubuntu/projects/robotics_shared/datasets/lerobot +export HF_HOME=/home/ubuntu/projects/robotics_shared/hf_cache +export PYTHONPATH="$OPENPI/src:$OPENPI/packages/openpi-client/src" +export XLA_PYTHON_CLIENT_MEM_FRACTION="${XLA_PYTHON_CLIENT_MEM_FRACTION:-0.80}" + +cd "$OPENPI" + +if [[ -f "$CONVERT_UNIT_FILE" ]]; then + convert_unit="$(cat "$CONVERT_UNIT_FILE").service" + echo "[INFO] Waiting for $convert_unit" + while systemctl --user is-active --quiet "$convert_unit"; do + sleep 60 + done + systemctl --user is-failed --quiet "$convert_unit" && { + echo "[ERROR] Conversion unit failed: $convert_unit" + systemctl --user status "$convert_unit" --no-pager --lines=80 || true + exit 1 + } +fi + +echo "[INFO] Computing norm stats for pi05_atec_task_e_s5_224" | tee "$NORM_LOG" +"$PY" scripts/compute_norm_stats.py \ + --config-name pi05_atec_task_e_s5_224 \ + --max-frames 20000 2>&1 | tee -a "$NORM_LOG" + +echo "[INFO] Training pi05_atec_task_e_s5_224" | tee "$TRAIN_LOG" +"$PY" scripts/train.py \ + pi05_atec_task_e_s5_224 \ + --exp-name atec_task_e_pi05_s5_224_30k_${STAMP} \ + --overwrite 2>&1 | tee -a "$TRAIN_LOG" diff --git a/scripts/pi05/summarize_pi05_eval.py b/scripts/pi05/summarize_pi05_eval.py new file mode 100644 index 0000000000000000000000000000000000000000..6dfdb4eec769320d2cd9b4d3da356829434419bb --- /dev/null +++ b/scripts/pi05/summarize_pi05_eval.py @@ -0,0 +1,55 @@ +#!/usr/bin/env python3 +"""Summarize Task-E pi0.5 eval logs.""" + +from __future__ import annotations + +import argparse +from pathlib import Path +import re +import statistics + + +RESULT_RE = re.compile(r"\[RESULT\].*?score=([0-9.]+).*?steps=([0-9]+).*?done=(True|False)") +BASKET_RE = re.compile(r"\[BASKET\].*?(object_[123]): .*?inside=(True|False)") + + +def summarize(eval_dir: Path) -> int: + logs = sorted(eval_dir.glob("seed*.log")) + if not logs: + print(f"[ERROR] No seed*.log files found in {eval_dir}") + return 1 + + scores: list[float] = [] + for log in logs: + text = log.read_text(errors="replace") + result = RESULT_RE.search(text) + baskets = BASKET_RE.findall(text) + if not result: + print(f"{log.name}: missing result") + continue + score = float(result.group(1)) + steps = int(result.group(2)) + done = result.group(3) + scores.append(score) + basket_text = ", ".join(f"{obj}={inside}" for obj, inside in baskets) if baskets else "basket=unknown" + print(f"{log.name}: score={score:.2f}, steps={steps}, done={done}, {basket_text}") + + if scores: + print( + f"[SUMMARY] n={len(scores)} mean={statistics.fmean(scores):.2f} " + f"best={max(scores):.2f} min={min(scores):.2f}" + ) + videos = sorted((eval_dir.parents[1] / "videos" / "task_e_pi05_eval").glob("*.mp4")) + if videos: + print(f"[VIDEO] latest={videos[-1]}") + return 0 + + +def main() -> int: + parser = argparse.ArgumentParser() + parser.add_argument("eval_dir", type=Path) + return summarize(parser.parse_args().eval_dir) + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/scripts/rsl_rl/cli_args.py b/scripts/rsl_rl/cli_args.py new file mode 100644 index 0000000000000000000000000000000000000000..9b098799843bb7785b508e158579b3aa8743f920 --- /dev/null +++ b/scripts/rsl_rl/cli_args.py @@ -0,0 +1,86 @@ +from __future__ import annotations + +import argparse +import random +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from isaaclab_rl.rsl_rl import RslRlBaseRunnerCfg + + +def add_rsl_rl_args(parser: argparse.ArgumentParser): + """Add RSL-RL arguments to the parser. + + Args: + parser: The parser to add the arguments to. + """ + # create a new argument group + arg_group = parser.add_argument_group("rsl_rl", description="Arguments for RSL-RL agent.") + # -- experiment arguments + arg_group.add_argument( + "--experiment_name", type=str, default=None, help="Name of the experiment folder where logs will be stored." + ) + arg_group.add_argument("--run_name", type=str, default=None, help="Run name suffix to the log directory.") + # -- load arguments + arg_group.add_argument("--resume", action="store_true", default=False, help="Whether to resume from a checkpoint.") + arg_group.add_argument("--load_run", type=str, default=None, help="Name of the run folder to resume from.") + arg_group.add_argument("--checkpoint", type=str, default=None, help="Checkpoint file to resume from.") + # -- logger arguments + arg_group.add_argument( + "--logger", type=str, default=None, choices={"wandb", "tensorboard", "neptune"}, help="Logger module to use." + ) + arg_group.add_argument( + "--log_project_name", type=str, default=None, help="Name of the logging project when using wandb or neptune." + ) + + +def parse_rsl_rl_cfg(task_name: str, args_cli: argparse.Namespace) -> RslRlBaseRunnerCfg: + """Parse configuration for RSL-RL agent based on inputs. + + Args: + task_name: The name of the environment. + args_cli: The command line arguments. + + Returns: + The parsed configuration for RSL-RL agent based on inputs. + """ + from isaaclab_tasks.utils.parse_cfg import load_cfg_from_registry + + # load the default configuration + rslrl_cfg: RslRlBaseRunnerCfg = load_cfg_from_registry(task_name, "rsl_rl_cfg_entry_point") + rslrl_cfg = update_rsl_rl_cfg(rslrl_cfg, args_cli) + return rslrl_cfg + + +def update_rsl_rl_cfg(agent_cfg: RslRlBaseRunnerCfg, args_cli: argparse.Namespace): + """Update configuration for RSL-RL agent based on inputs. + + Args: + agent_cfg: The configuration for RSL-RL agent. + args_cli: The command line arguments. + + Returns: + The updated configuration for RSL-RL agent based on inputs. + """ + # override the default configuration with CLI arguments + if hasattr(args_cli, "seed") and args_cli.seed is not None: + # randomly sample a seed if seed = -1 + if args_cli.seed == -1: + args_cli.seed = random.randint(0, 10000) + agent_cfg.seed = args_cli.seed + if args_cli.resume is not None: + agent_cfg.resume = args_cli.resume + if args_cli.load_run is not None: + agent_cfg.load_run = args_cli.load_run + if args_cli.checkpoint is not None: + agent_cfg.load_checkpoint = args_cli.checkpoint + if args_cli.run_name is not None: + agent_cfg.run_name = args_cli.run_name + if args_cli.logger is not None: + agent_cfg.logger = args_cli.logger + # set the project name for wandb and neptune + if agent_cfg.logger in {"wandb", "neptune"} and args_cli.log_project_name: + agent_cfg.wandb_project = args_cli.log_project_name + agent_cfg.neptune_project = args_cli.log_project_name + + return agent_cfg diff --git a/scripts/rsl_rl/play.py b/scripts/rsl_rl/play.py new file mode 100644 index 0000000000000000000000000000000000000000..e95e116bf63ef017d27a6b531284d2f756f2803b --- /dev/null +++ b/scripts/rsl_rl/play.py @@ -0,0 +1,225 @@ +"""Script to play a checkpoint if an RL agent from RSL-RL.""" + +"""Launch Isaac Sim Simulator first.""" + +import argparse +import sys + +from isaaclab.app import AppLauncher + +# local imports +import cli_args # isort: skip + +# add argparse arguments +parser = argparse.ArgumentParser(description="Train an RL agent with RSL-RL.") +parser.add_argument("--video", action="store_true", default=False, help="Record videos during training.") +parser.add_argument("--video_length", type=int, default=200, help="Length of the recorded video (in steps).") +parser.add_argument( + "--disable_fabric", action="store_true", default=False, help="Disable fabric and use USD I/O operations." +) +parser.add_argument("--num_envs", type=int, default=None, help="Number of environments to simulate.") +parser.add_argument("--task", type=str, default=None, help="Name of the task.") +parser.add_argument( + "--agent", type=str, default="rsl_rl_cfg_entry_point", help="Name of the RL agent configuration entry point." +) +parser.add_argument("--seed", type=int, default=None, help="Seed used for the environment") +parser.add_argument( + "--use_pretrained_checkpoint", + action="store_true", + help="Use the pre-trained checkpoint from Nucleus.", +) +parser.add_argument("--real-time", action="store_true", default=False, help="Run in real-time, if possible.") +# append RSL-RL cli arguments +cli_args.add_rsl_rl_args(parser) +# append AppLauncher cli args +AppLauncher.add_app_launcher_args(parser) +# parse the arguments +args_cli, hydra_args = parser.parse_known_args() +# always enable cameras to record video +if args_cli.video: + args_cli.enable_cameras = True + +# clear out sys.argv for Hydra +sys.argv = [sys.argv[0]] + hydra_args + +# launch omniverse app +app_launcher = AppLauncher(args_cli) +simulation_app = app_launcher.app + +"""Rest everything follows.""" + +import os +import time + +import gymnasium as gym +import torch +from rsl_rl.runners import DistillationRunner, OnPolicyRunner + +from isaaclab.envs import ( + DirectMARLEnv, + DirectMARLEnvCfg, + DirectRLEnvCfg, + ManagerBasedRLEnvCfg, + multi_agent_to_single_agent, +) +from isaaclab.managers import ObservationTermCfg as ObsTerm +from isaaclab.utils.assets import retrieve_file_path +from isaaclab.utils.dict import print_dict + +from isaaclab_rl.rsl_rl import RslRlBaseRunnerCfg, RslRlVecEnvWrapper, export_policy_as_jit, export_policy_as_onnx +from isaaclab_rl.utils.pretrained_checkpoint import get_published_pretrained_checkpoint + +from isaaclab_tasks.utils import get_checkpoint_path +from isaaclab_tasks.utils.hydra import hydra_task_config + +import atec_rl_lab.train # noqa: F401 # isort: skip + +sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))) + + +# PLACEHOLDER: Extension template (do not remove this comment) + + +@hydra_task_config(args_cli.task, args_cli.agent) +def main(env_cfg: ManagerBasedRLEnvCfg | DirectRLEnvCfg | DirectMARLEnvCfg, agent_cfg: RslRlBaseRunnerCfg): + """Play with RSL-RL agent.""" + # grab task name for checkpoint path + task_name = args_cli.task.split(":")[-1] + + # override configurations with non-hydra CLI arguments + agent_cfg: RslRlBaseRunnerCfg = cli_args.update_rsl_rl_cfg(agent_cfg, args_cli) + env_cfg.scene.num_envs = args_cli.num_envs if args_cli.num_envs is not None else 64 + + # set the environment seed + # note: certain randomizations occur in the environment initialization so we set the seed here + env_cfg.seed = agent_cfg.seed + env_cfg.sim.device = args_cli.device if args_cli.device is not None else env_cfg.sim.device + + # spawn the robot randomly in the grid (instead of their terrain levels) + env_cfg.scene.terrain.max_init_terrain_level = None + # reduce the number of terrains to save memory + if env_cfg.scene.terrain.terrain_generator is not None: + env_cfg.scene.terrain.terrain_generator.num_rows = 5 + env_cfg.scene.terrain.terrain_generator.num_cols = 5 + env_cfg.scene.terrain.terrain_generator.curriculum = False + + # disable randomization for play + env_cfg.observations.policy.enable_corruption = False + # remove random pushing + env_cfg.events.randomize_apply_external_force_torque = None + env_cfg.events.push_robot = None + env_cfg.curriculum.command_levels_lin_vel = None + env_cfg.curriculum.command_levels_ang_vel = None + + # specify directory for logging experiments + log_root_path = os.path.join("logs", "rsl_rl", agent_cfg.experiment_name) + log_root_path = os.path.abspath(log_root_path) + print(f"[INFO] Loading experiment from directory: {log_root_path}") + if args_cli.use_pretrained_checkpoint: + resume_path = get_published_pretrained_checkpoint("rsl_rl", task_name) + if not resume_path: + print("[INFO] Unfortunately a pre-trained checkpoint is currently unavailable for this task.") + return + elif args_cli.checkpoint: + resume_path = retrieve_file_path(args_cli.checkpoint) + else: + resume_path = get_checkpoint_path(log_root_path, agent_cfg.load_run, agent_cfg.load_checkpoint) + + log_dir = os.path.dirname(resume_path) + + # set the log directory for the environment (works for all environment types) + env_cfg.log_dir = log_dir + + # create isaac environment + env = gym.make(args_cli.task, cfg=env_cfg, render_mode="rgb_array" if args_cli.video else None) + + # convert to single-agent instance if required by the RL algorithm + if isinstance(env.unwrapped, DirectMARLEnv): + env = multi_agent_to_single_agent(env) + + # wrap for video recording + if args_cli.video: + video_kwargs = { + "video_folder": os.path.join(log_dir, "videos", "play"), + "step_trigger": lambda step: step == 0, + "video_length": args_cli.video_length, + "disable_logger": True, + } + print("[INFO] Recording videos during training.") + print_dict(video_kwargs, nesting=4) + env = gym.wrappers.RecordVideo(env, **video_kwargs) + + # wrap around environment for rsl-rl + env = RslRlVecEnvWrapper(env, clip_actions=agent_cfg.clip_actions) + + print(f"[INFO]: Loading model checkpoint from: {resume_path}") + # load previously trained model + if agent_cfg.class_name == "OnPolicyRunner": + runner = OnPolicyRunner(env, agent_cfg.to_dict(), log_dir=None, device=agent_cfg.device) + elif agent_cfg.class_name == "DistillationRunner": + runner = DistillationRunner(env, agent_cfg.to_dict(), log_dir=None, device=agent_cfg.device) + else: + raise ValueError(f"Unsupported runner class: {agent_cfg.class_name}") + runner.load(resume_path) + + # obtain the trained policy for inference + policy = runner.get_inference_policy(device=env.unwrapped.device) + + # extract the neural network module + # we do this in a try-except to maintain backwards compatibility. + try: + # version 2.3 onwards + policy_nn = runner.alg.policy + except AttributeError: + # version 2.2 and below + policy_nn = runner.alg.actor_critic + + # extract the normalizer + if hasattr(policy_nn, "actor_obs_normalizer"): + normalizer = policy_nn.actor_obs_normalizer + elif hasattr(policy_nn, "student_obs_normalizer"): + normalizer = policy_nn.student_obs_normalizer + else: + normalizer = None + + # export policy to onnx/jit + export_model_dir = os.path.join(os.path.dirname(resume_path), "exported") + export_policy_as_jit(policy_nn, normalizer=normalizer, path=export_model_dir, filename="policy.pt") + export_policy_as_onnx(policy_nn, normalizer=normalizer, path=export_model_dir, filename="policy.onnx") + + dt = env.unwrapped.step_dt + + # reset environment + obs = env.get_observations() + timestep = 0 + # simulate environment + while simulation_app.is_running(): + start_time = time.time() + # run everything in inference mode + with torch.inference_mode(): + # agent stepping + actions = policy(obs) + # env stepping + obs, _, dones, _ = env.step(actions) + # reset recurrent states for episodes that have terminated + policy_nn.reset(dones) + if args_cli.video: + timestep += 1 + # Exit the play loop after recording one video + if timestep == args_cli.video_length: + break + + # time delay for real-time evaluation + sleep_time = dt - (time.time() - start_time) + if args_cli.real_time and sleep_time > 0: + time.sleep(sleep_time) + + # close the simulator + env.close() + + +if __name__ == "__main__": + # run the main function + main() + # close sim app + simulation_app.close() diff --git a/scripts/rsl_rl/train.py b/scripts/rsl_rl/train.py new file mode 100644 index 0000000000000000000000000000000000000000..bf81da0534ad6ab2864adf703dc4aac9f680db2b --- /dev/null +++ b/scripts/rsl_rl/train.py @@ -0,0 +1,226 @@ + +"""Script to train RL agent with RSL-RL.""" + +"""Launch Isaac Sim Simulator first.""" + +import argparse +import sys + +from isaaclab.app import AppLauncher + +# local imports +import cli_args # isort: skip + +# add argparse arguments +parser = argparse.ArgumentParser(description="Train an RL agent with RSL-RL.") +parser.add_argument("--video", action="store_true", default=False, help="Record videos during training.") +parser.add_argument("--video_length", type=int, default=200, help="Length of the recorded video (in steps).") +parser.add_argument("--video_interval", type=int, default=2000, help="Interval between video recordings (in steps).") +parser.add_argument("--num_envs", type=int, default=None, help="Number of environments to simulate.") +parser.add_argument("--task", type=str, default=None, help="Name of the task.") +parser.add_argument( + "--agent", type=str, default="rsl_rl_cfg_entry_point", help="Name of the RL agent configuration entry point." +) +parser.add_argument("--seed", type=int, default=None, help="Seed used for the environment") +parser.add_argument("--max_iterations", type=int, default=None, help="RL Policy training iterations.") +parser.add_argument( + "--distributed", action="store_true", default=False, help="Run training with multiple GPUs or nodes." +) +parser.add_argument("--export_io_descriptors", action="store_true", default=False, help="Export IO descriptors.") +parser.add_argument( + "--ray-proc-id", "-rid", type=int, default=None, help="Automatically configured by Ray integration, otherwise None." +) +# append RSL-RL cli arguments +cli_args.add_rsl_rl_args(parser) +# append AppLauncher cli args +AppLauncher.add_app_launcher_args(parser) +args_cli, hydra_args = parser.parse_known_args() + +# always enable cameras to record video +if args_cli.video: + args_cli.enable_cameras = True + +# clear out sys.argv for Hydra +sys.argv = [sys.argv[0]] + hydra_args + +# launch omniverse app +app_launcher = AppLauncher(args_cli) +simulation_app = app_launcher.app + +"""Check for minimum supported RSL-RL version.""" + +import importlib.metadata as metadata +import platform + +from packaging import version + +# check minimum supported rsl-rl version +RSL_RL_VERSION = "3.0.1" +installed_version = metadata.version("rsl-rl-lib") +if version.parse(installed_version) < version.parse(RSL_RL_VERSION): + if platform.system() == "Windows": + cmd = [r".\isaaclab.bat", "-p", "-m", "pip", "install", f"rsl-rl-lib=={RSL_RL_VERSION}"] + else: + cmd = ["./isaaclab.sh", "-p", "-m", "pip", "install", f"rsl-rl-lib=={RSL_RL_VERSION}"] + print( + f"Please install the correct version of RSL-RL.\nExisting version is: '{installed_version}'" + f" and required version is: '{RSL_RL_VERSION}'.\nTo install the correct version, run:" + f"\n\n\t{' '.join(cmd)}\n" + ) + exit(1) + +"""Rest everything follows.""" + +import logging +import os +import time +from datetime import datetime + +import gymnasium as gym +import torch +from rsl_rl.runners import DistillationRunner, OnPolicyRunner + +from isaaclab.envs import ( + DirectMARLEnv, + DirectMARLEnvCfg, + DirectRLEnvCfg, + ManagerBasedRLEnvCfg, + multi_agent_to_single_agent, +) +from isaaclab.utils.dict import print_dict +from isaaclab.utils.io import dump_yaml + +from isaaclab_rl.rsl_rl import RslRlBaseRunnerCfg, RslRlVecEnvWrapper + +from isaaclab_tasks.utils import get_checkpoint_path +from isaaclab_tasks.utils.hydra import hydra_task_config + +import atec_rl_lab.train # noqa: F401 # isort: skip + +# import logger +logger = logging.getLogger(__name__) + +# PLACEHOLDER: Extension template (do not remove this comment) + +torch.backends.cuda.matmul.allow_tf32 = True +torch.backends.cudnn.allow_tf32 = True +torch.backends.cudnn.deterministic = False +torch.backends.cudnn.benchmark = False + + +@hydra_task_config(args_cli.task, args_cli.agent) +def main(env_cfg: ManagerBasedRLEnvCfg | DirectRLEnvCfg | DirectMARLEnvCfg, agent_cfg: RslRlBaseRunnerCfg): + """Train with RSL-RL agent.""" + # override configurations with non-hydra CLI arguments + agent_cfg = cli_args.update_rsl_rl_cfg(agent_cfg, args_cli) + env_cfg.scene.num_envs = args_cli.num_envs if args_cli.num_envs is not None else env_cfg.scene.num_envs + agent_cfg.max_iterations = ( + args_cli.max_iterations if args_cli.max_iterations is not None else agent_cfg.max_iterations + ) + + # set the environment seed + # note: certain randomizations occur in the environment initialization so we set the seed here + env_cfg.seed = agent_cfg.seed + env_cfg.sim.device = args_cli.device if args_cli.device is not None else env_cfg.sim.device + # check for invalid combination of CPU device with distributed training + if args_cli.distributed and args_cli.device is not None and "cpu" in args_cli.device: + raise ValueError( + "Distributed training is not supported when using CPU device. " + "Please use GPU device (e.g., --device cuda) for distributed training." + ) + + # multi-gpu training configuration + if args_cli.distributed: + env_cfg.sim.device = f"cuda:{app_launcher.local_rank}" + agent_cfg.device = f"cuda:{app_launcher.local_rank}" + + # set seed to have diversity in different threads + seed = agent_cfg.seed + app_launcher.local_rank + env_cfg.seed = seed + agent_cfg.seed = seed + + # specify directory for logging experiments + log_root_path = os.path.join("logs", "rsl_rl", agent_cfg.experiment_name) + log_root_path = os.path.abspath(log_root_path) + print(f"[INFO] Logging experiment in directory: {log_root_path}") + # specify directory for logging runs: {time-stamp}_{run_name} + log_dir = datetime.now().strftime("%Y-%m-%d_%H-%M-%S") + # The Ray Tune workflow extracts experiment name using the logging line below, hence, do not + # change it (see PR #2346, comment-2819298849) + print(f"Exact experiment name requested from command line: {log_dir}") + if agent_cfg.run_name: + log_dir += f"_{agent_cfg.run_name}" + log_dir = os.path.join(log_root_path, log_dir) + + # set the IO descriptors export flag if requested + if isinstance(env_cfg, ManagerBasedRLEnvCfg): + env_cfg.export_io_descriptors = args_cli.export_io_descriptors + else: + logger.warning( + "IO descriptors are only supported for manager based RL environments. No IO descriptors will be exported." + ) + + # set the log directory for the environment (works for all environment types) + env_cfg.log_dir = log_dir + + # create isaac environment + env = gym.make(args_cli.task, cfg=env_cfg, render_mode="rgb_array" if args_cli.video else None) + + # convert to single-agent instance if required by the RL algorithm + if isinstance(env.unwrapped, DirectMARLEnv): + env = multi_agent_to_single_agent(env) + + # save resume path before creating a new log_dir + if agent_cfg.resume or agent_cfg.algorithm.class_name == "Distillation": + resume_path = get_checkpoint_path(log_root_path, agent_cfg.load_run, agent_cfg.load_checkpoint) + + # wrap for video recording + if args_cli.video: + video_kwargs = { + "video_folder": os.path.join(log_dir, "videos", "train"), + "step_trigger": lambda step: step % args_cli.video_interval == 0, + "video_length": args_cli.video_length, + "disable_logger": True, + } + print("[INFO] Recording videos during training.") + print_dict(video_kwargs, nesting=4) + env = gym.wrappers.RecordVideo(env, **video_kwargs) + + start_time = time.time() + + # wrap around environment for rsl-rl + env = RslRlVecEnvWrapper(env, clip_actions=agent_cfg.clip_actions) + + # create runner from rsl-rl + if agent_cfg.class_name == "OnPolicyRunner": + runner = OnPolicyRunner(env, agent_cfg.to_dict(), log_dir=log_dir, device=agent_cfg.device) + elif agent_cfg.class_name == "DistillationRunner": + runner = DistillationRunner(env, agent_cfg.to_dict(), log_dir=log_dir, device=agent_cfg.device) + else: + raise ValueError(f"Unsupported runner class: {agent_cfg.class_name}") + # write git state to logs + runner.add_git_repo_to_log(__file__) + # load the checkpoint + if agent_cfg.resume or agent_cfg.algorithm.class_name == "Distillation": + print(f"[INFO]: Loading model checkpoint from: {resume_path}") + # load previously trained model + runner.load(resume_path) + + # dump the configuration into log-directory + dump_yaml(os.path.join(log_dir, "params", "env.yaml"), env_cfg) + dump_yaml(os.path.join(log_dir, "params", "agent.yaml"), agent_cfg) + + # run training + runner.learn(num_learning_iterations=agent_cfg.max_iterations, init_at_random_ep_len=True) + + print(f"Training time: {round(time.time() - start_time, 2)} seconds") + + # close the simulator + env.close() + + +if __name__ == "__main__": + # run the main function + main() + # close sim app + simulation_app.close() diff --git a/third_party/Agilex-College/.marscode/deviceInfo.json b/third_party/Agilex-College/.marscode/deviceInfo.json new file mode 100644 index 0000000000000000000000000000000000000000..8b63d437b6bd7731cdcf718a7c0da451be45f284 --- /dev/null +++ b/third_party/Agilex-College/.marscode/deviceInfo.json @@ -0,0 +1,3 @@ +{ + "deviceId": "6f981eef66c647ab92a0e819e5e022b662bbfc7fc6d7ef557433e99029bc5c1b" +} \ No newline at end of file diff --git a/third_party/Agilex-College/README.md b/third_party/Agilex-College/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f05f63620ce97df87aa65445a0eb0c07ab2d23e0 --- /dev/null +++ b/third_party/Agilex-College/README.md @@ -0,0 +1,41 @@ + + +# 松灵学院开源技术贴 + +**一站式代码仓库** + +松灵学院面向所有开发者、高校团队与爱好者，持续发布基于松灵机器人全线产品的**开源示例与教程**。无论你是初次接触，还是想快速落地项目，都能在这里找到“拿即可用”的代码与步骤说明。更多产品DEMO示例将陆续上线，欢迎 Star、提 Issue 或一起共建。 + +当前聚焦：Piper 系列机械臂 + +| 标题 | 描述 | +| ------------------------------------------------------------ | ----------------------------------------------- | +| [固定点位录制与播放](https://github.com/agilexrobotics/Agilex-College/tree/master/piper/recordAndPlayPos) | 使用Piper录制固定点位运动并播放 | +| [连续轨迹录制与播放](https://github.com/agilexrobotics/Agilex-College/tree/master/piper/recordAndPlayTraj) | 使用Piepr录制连续运动的轨迹并播放 | +| [机械臂识别方块与曲线](https://github.com/agilexrobotics/Agilex-College/tree/master/piper/cubeAndLineDet) | 使用相机识别方块和曲线；并使Piper机械臂跟随曲线 | +| [手机陀螺仪遥操机械臂](https://github.com/agilexrobotics/Agilex-College/tree/master/piper/mobilePhoneCtl) | 使用手机陀螺仪遥操机械臂臂 | +| [手势遥操机械臂](https://github.com/agilexrobotics/Agilex-College/tree/master/piper/handpose_det) | 使用手势遥操作Piper机械臂末端六自由度位姿 | +| [robotic_arm_kinematics](https://github.com/vanstrong12138/robotic_arm_kinematics) | 机械臂逆解数值教学与Piper底层解析解的调用 | +| [游戏手柄](https://github.com/agilexrobotics/Agilex-College/tree/master/piper/gamepad) | 使用游戏手柄遥操机械臂 | +| [手眼标定](https://github.com/agilexrobotics/Agilex-College/tree/master/piper/handeye) | Piper手眼标定教程 | +| [GraspGen](https://github.com/agilexrobotics/Agilex-College/tree/master/piper/GraspGen) | 位姿生成与抓取 | +| [Piper_rl](https://github.com/vanstrong12138/Piper_rl.git) | PiPER强化学习demo | +| [Isaac sim 导入piper](https://github.com/agilexrobotics/Agilex-College/tree/master/isaac_sim/piper_isaac_sim) | 在Isaac sim 中导入piper并添加摄像头 | +| [复现RDA_planner](https://github.com/agilexrobotics/Agilex-College/tree/master/limo/RDA_planner) | 复现RDA_planner | +| [Piper_moveit](https://github.com/agilexrobotics/Agilex-College/tree/master/piper/piper_moveit) | 从零到玩转Moveit 机械臂控制（ROS1） | +| [Nero_moveit](https://github.com/agilexrobotics/Agilex-College/tree/master/piper/nero_moveit2) | 从零到玩转Moveit 机械臂控制（ROS2） | + +更多内容欢迎关注松灵机器人 + +网站：https://global.agilex.ai/ + +微信公众号：松灵机器人 + +------ + +**声明** + +本仓库内所有内容均为松灵机器人合法拥有，仅限个人学习、研究使用，超出上述范围的使用（包括但不限于基于商业用途的复制、修改、在发布衍生开发等）均需事先获得松灵机器人的书面授权；对于未经授权使用本公司相关作品的行为，本公司将依法追究其法律责任。 + +如需授权请联系 [support@agilex.ai](https://github.com/agilexrobotics/Agilex-College/blob/master) + diff --git a/third_party/Agilex-College/README_EN.md b/third_party/Agilex-College/README_EN.md new file mode 100644 index 0000000000000000000000000000000000000000..881e7c2e324ead32c6fbe4847a4544a134dde50b --- /dev/null +++ b/third_party/Agilex-College/README_EN.md @@ -0,0 +1,33 @@ +# AgileX College Open Source Technology Post + +**One-Stop Code Repository** + +AgileX College provides developers, university teams, and enthusiasts with continuously updated **open-source examples and tutorials** based on the full range of 松灵机器人 products. Whether you are a beginner or looking to implement projects quickly, you can find ready-to-use code and step-by-step instructions here. More product DEMO examples will be released gradually. We welcome you to Star the repository, raise Issues, or contribute together. + +Current Focus: Piper Series Robotic Arm + +| Title | Description | +| :--- | :--- | +| [Record and Play Fixed Points](https://github.com/agilexrobotics/Agilex-College/tree/master/piper/recordAndPlayPos) | Use Piper to record fixed point movements and play them back. | +| [Record and Play Continuous Trajectories](https://github.com/agilexrobotics/Agilex-College/tree/master/piper/recordAndPlayTraj) | Use Piper to record continuously moving trajectories and play them back. | +| [Cube and Curve Detection with Robotic Arm](https://github.com/agilexrobotics/Agilex-College/tree/master/piper/cubeAndLineDet) | Use a camera to detect cubes and curves; enable the Piper arm to follow the curves. | +| [Mobile Phone Gyroscope Teleoperation](https://github.com/agilexrobotics/Agilex-College/tree/master/piper/mobilePhoneCtl) | Use a mobile phone's gyroscope to teleoperate the robotic arm. | +| [Hand Gesture Teleoperation](https://github.com/agilexrobotics/Agilex-College/tree/master/piper/handpose_det) | Use hand gestures to teleoperate the 6-DOF pose of the Piper arm's end-effector. | +| [Piper Kinematics Package](https://github.com/agilexrobotics/Agilex-College/tree/master/piper/piper_kinematics) | Numerical inverse kinematics teaching and calling Piper's underlying analytical solver. | +| [Gamepad Control](https://github.com/agilexrobotics/Agilex-College/tree/master/piper/gamepad) | Use a gamepad to teleoperate the robotic arm. | +| [Hand-eye calibration](https://github.com/agilexrobotics/Agilex-College/tree/master/piper/handeye) | Piper hand-eye calibration tutorial. | +| [GraspGen](https://github.com/agilexrobotics/Agilex-College/tree/master/piper/GraspGen) | GraspGen is an system that generates robotic grasp poses for known objects. | + +For more content, follow 松灵机器人 + +Website: https://global.agilex.ai/ + +WeChat Official Account: 松灵机器人 + +--- + +**Disclaimer** + +All content in this repository is legally owned by 松灵机器人. It is intended solely for personal learning and research use. Any use beyond this scope (including but not limited to commercial use, modification, redistribution, derivative development, etc.) requires prior written authorization from 松灵机器人. Unauthorized use of the company's related works will be subject to legal pursuit by the company. + +For authorization, please contact: [support@agilex.ai](mailto:support@agilex.ai) \ No newline at end of file diff --git "a/third_party/Agilex-College/isaac_sim/agx_arm_IsaacLab/Nero\345\256\236\347\224\250\346\241\210\344\276\213--\345\237\272\344\272\216 Isaac Lab \344\275\277\347\224\250\345\274\272\345\214\226\345\255\246\344\271\240\345\256\236\347\216\260\345\210\260\350\276\276\347\233\256\346\240\207\347\202\271.md" "b/third_party/Agilex-College/isaac_sim/agx_arm_IsaacLab/Nero\345\256\236\347\224\250\346\241\210\344\276\213--\345\237\272\344\272\216 Isaac Lab \344\275\277\347\224\250\345\274\272\345\214\226\345\255\246\344\271\240\345\256\236\347\216\260\345\210\260\350\276\276\347\233\256\346\240\207\347\202\271.md" new file mode 100644 index 0000000000000000000000000000000000000000..6cb9e3ac2620a44fef69e181c69392ae5cd2eb47 --- /dev/null +++ "b/third_party/Agilex-College/isaac_sim/agx_arm_IsaacLab/Nero\345\256\236\347\224\250\346\241\210\344\276\213--\345\237\272\344\272\216 Isaac Lab \344\275\277\347\224\250\345\274\272\345\214\226\345\255\246\344\271\240\345\256\236\347\216\260\345\210\260\350\276\276\347\233\256\346\240\207\347\202\271.md" @@ -0,0 +1,116 @@ +# 基于 Isaac Lab 的 Nero和Piper强化学习案例 + +在机器人研究领域，机械臂的智能控制一直是具身智能研究的核心方向之一。传统的运动学控制方案虽然稳定，但面对复杂的非结构化环境往往束手无策，而强化学习技术的出现，为机械臂实现自主适应环境、完成复杂任务提供了全新的可能。 + +今天我们要介绍的`isaac_so_arm101`项目，在原有 SO-ARM100 项目的基础上，完成了对松灵机器人旗下两款热门科研机械臂 ——Nero 七轴仿人臂与 Piper 六轴轻量臂的适配，让开发者可以快速基于 NVIDIA Isaac Lab 平台，开展机械臂的强化学习训练与验证。 + +## 一、项目安装与环境准备 + +项目采用了`uv`作为包管理工具，这是一款新一代的 Python 包管理工具，相比传统的 pip，它的安装速度更快，依赖解析更高效，还能自动管理虚拟环境，彻底解决了环境依赖混乱的问题。 + +### 1.1 安装 uv 包管理工具 + +首先我们需要安装 uv，只需要一行命令即可完成： + +```bash +curl -LsSf https://astral.sh/uv/install.sh | sh +``` + +安装完成后，重启终端或者执行`source $HOME/.cargo/env`即可让 uv 命令生效。 + +### 1.2 克隆项目并安装依赖 + +接下来克隆本项目的仓库，然后进入项目目录，使用 uv 一键安装所有依赖： + +```bash +git clone https://github.com/smalleha/isaac_so_arm101.git +cd isaac_so_arm101 +uv sync +``` + +uv 会自动创建虚拟环境，并且下载安装所有需要的依赖包，整个过程只需要几分钟，比传统的 pip 安装快了数倍。 + +## 二、环境测试 + +安装完成后，我们可以先测试一下环境是否正常，首先可以列出所有已经适配好的环境，确认我们的 Nero 和 Piper 环境都在其中： + +```bash +uv run list_envs +``` + +如果一切正常，你会在输出中看到`Isaac-Nero-Reach-v0`和`Isaac-Piper-Reach-v0`这两个我们需要的环境。 + +接下来，我们可以用虚拟智能体来测试一下环境是否可以正常运行，这一步可以帮我们验证仿真环境的加载是否正常： + +```bash +# 测试Piper环境，发送零动作 +uv run zero_agent --task SO-ARM100-Reach-Play-v0 +``` + +如果仿真窗口正常弹出，机械臂可以正常运动，说明我们的环境已经准备就绪了。 + +![](./img/env_test_1.png) + +## 三、从到达目标点到抓取方块 + +这个项目为我们提供了两个典型的强化学习任务，分别对应 Piper 和 Nero 两款机械臂，我们可以分别来体验一下。 + +### 5.1 Piper 的目标到达任务：学习逆运动学 + +首先我们来看 Piper 机械臂的目标到达任务，这个任务的目标是让机械臂学会自主控制关节，让末端执行器移动到指定的目标位置，本质上就是通过强化学习来学习逆运动学（IK）。 + +传统的逆运动学需要精确的机械臂模型，而且面对冗余自由度的机械臂往往会有多个解，而强化学习可以直接从数据中学习到端到端的控制策略，不仅不需要精确的模型，还能同时考虑避障、平滑运动等约束。 + +#### 训练策略 + +我们可以直接启动训练，使用`--headless`参数开启无头模式，这样可以关闭 GUI，大幅提升训练速度： + +```bash +uv run train --task Isaac-Piper-Reach-v0 --headless +``` + +训练过程中，Isaac Lab 会自动并行运行多个环境，快速收集数据，更新 PPO 策略网络的参数。 + +#### 评估训练结果 + +训练完成后，我们就可以加载训练好的策略，看看它的表现了： + +```bash +uv run play --task Isaac-Piper-Reach-v0 +``` + +这时候你会看到，机械臂可以精准地把末端移动到随机生成的目标点，哪怕目标点不断变化，它也能快速响应，这就是强化学习训练出来的策略的威力。 + +![](./img/piper_rl.gif) + +### 5.2 Nero 的抓取任务：从仿真中学习操作 + +接下来我们来看更复杂的 Nero 机械臂的任务，这个任务不仅要求机械臂到达目标位置，还要完成对方块的抓取，并且把方块移动到指定的目标点，这是一个典型的手眼抓取任务，也是工业机器人最常用的任务之一。 + +#### 启动训练 + +对于这个更复杂的任务，我们可以调整并行环境的数量，来提升训练的效率，比如设置 64 个并行环境： + +```bash +uv run train --task Isaac-Nero-Reach-v0 --num_envs 64 +``` + +这里的`--num_envs`参数就是并行环境的数量，数值越大，数据收集的速度越快，训练的效率也就越高，当然这也会占用更多的 GPU 显存，如果你显存比较小，可以适当调低这个数值。 + +如果你想实时看到训练的过程，也可以去掉`--headless`参数，这样就能看到仿真窗口里，多个机械臂同时在进行训练尝试，非常直观。 + +#### 回放训练好的策略 + +训练完成后，我们同样可以用 play 命令来查看效果： + +```bash +# 直接加载最新的检查点 +uv run play --task Isaac-Nero-Reach-v0 +# 也可以加载指定的检查点文件 +uv run play --task Isaac-Nero-Reach-v0 --checkpoint /path/to/your/checkpoint.pt +``` + +这时候你就能看到，Nero 机械臂可以自主地识别方块的位置，移动夹爪，完成抓取，然后把方块放到目标位置，整个过程完全自主，不需要人工干预。 + +![](./img/nero_rl.gif) + diff --git "a/third_party/Agilex-College/isaac_sim/agx_arm_IsaacLab/Nero\345\256\236\347\224\250\346\241\210\344\276\213--\345\237\272\344\272\216 Isaac Lab \344\275\277\347\224\250\345\274\272\345\214\226\345\255\246\344\271\240\345\256\236\347\216\260\346\212\223\345\217\226\346\226\271\345\235\227.md" "b/third_party/Agilex-College/isaac_sim/agx_arm_IsaacLab/Nero\345\256\236\347\224\250\346\241\210\344\276\213--\345\237\272\344\272\216 Isaac Lab \344\275\277\347\224\250\345\274\272\345\214\226\345\255\246\344\271\240\345\256\236\347\216\260\346\212\223\345\217\226\346\226\271\345\235\227.md" new file mode 100644 index 0000000000000000000000000000000000000000..d6c7674926abd2513575faccbc97491115923da2 --- /dev/null +++ "b/third_party/Agilex-College/isaac_sim/agx_arm_IsaacLab/Nero\345\256\236\347\224\250\346\241\210\344\276\213--\345\237\272\344\272\216 Isaac Lab \344\275\277\347\224\250\345\274\272\345\214\226\345\255\246\344\271\240\345\256\236\347\216\260\346\212\223\345\217\226\346\226\271\345\235\227.md" @@ -0,0 +1,715 @@ +# Nero实用案例--基于 Isaac Lab 使用强化学习实现抓取方块到达目标点 + +在机器人研究领域，机械臂的智能控制一直是具身智能研究的核心方向之一。传统的运动学控制方案虽然稳定，但面对复杂的非结构化环境往往束手无策，而强化学习技术的出现，为机械臂实现自主适应环境、完成复杂任务提供了全新的可能。 + +本项目在原有 [SO-ARM101](https://github.com/MuammerBay/isaac_so_arm101) 项目的基础上，适配了nero机械臂，让开发者可以快速基于 NVIDIA Isaac Lab 平台，开展机械臂的强化学习训练与验证。 + +## 一、项目安装与环境准备 + +### 1.1 安装IsaacLab + +IsaacLab的安装方法可以参考官方给出的[教程](https://isaac-sim.github.io/IsaacLab/main/source/setup/installation/pip_installation.html)，本教程是使用pip 安装的，pip安装需要conda虚拟环境，大家可以自行安装 + +![](./img/isaaclab.png) + +### 1.2 安装 uv 包管理工具 + +项目采用了`uv`作为包管理工具，这是一款新一代的 Python 包管理工具，相比传统的 pip，它的安装速度更快，依赖解析更高效，还能自动管理虚拟环境，彻底解决了环境依赖混乱的问题。 + +首先我们需要安装 uv，只需要一行命令即可完成： + +```bash +curl -LsSf https://astral.sh/uv/install.sh | sh +``` + +安装完成后，重启终端或者执行`source $HOME/.cargo/env`即可让 uv 命令生效。 + +### 1.3 克隆项目并安装依赖 + +接下来克隆本项目的仓库，然后进入项目目录，使用 uv 一键安装所有依赖： + +```bash +git clone https://github.com/smalleha/isaac_so_arm101.git +cd isaac_so_arm101 +uv sync +``` + +uv 会自动创建虚拟环境，并且下载安装所有需要的依赖包，整个过程只需要几分钟，比传统的 pip 安装快了数倍。 + +## 二、环境测试 + +安装完成后，我们可以先测试一下环境是否正常，首先可以列出所有已经适配好的环境，确认我们的 Nero 和 Piper 环境都在其中： + +```bash +uv run list_envs +``` + +如果一切正常，你会在输出中看到`Isaac-Nero-Reach-v0`和`Isaac-Piper-Reach-v0`这两个我们需要的环境。 + + + +接下来，我们可以用虚拟智能体来测试一下环境是否可以正常运行，这一步可以帮我们验证仿真环境的加载是否正常： + +```bash +# 测试Piper环境，发送零动作 +uv run zero_agent --task Isaac-SO-ARM100-Reach-v0 +``` + +如果仿真窗口正常弹出，机械臂可以正常运动，说明我们的环境已经准备就绪了。 + +![](./img/zero_agent.png) + +## 三、项目文件结构 + +``` +isaac_so_arm101/ +├── CITATION.cff # 项目引用信息配置文件，用于规范项目的学术引用格式 +├── CONTRIBUTING.md # 项目贡献指南，说明如何参与项目开发、提交PR的规范 +├── CONTRIBUTORS.md # 项目贡献者列表，记录所有参与项目开发的人员信息 +├── LICENSE # BSD-3-Clause开源许可证，定义项目的开源使用规则 +├── README.md # 项目核心说明文档，包含安装步骤、快速启动、任务介绍等内容 +├── pyproject.toml # Python项目元数据配置，定义项目的依赖包、构建配置等 +├── uv.lock # uv包管理器的依赖锁文件，锁定所有依赖的版本，保障环境可复现 +└── src/ # 项目源码根目录，存放所有项目的核心源码 + └── isaac_so_arm101/ # 项目主Python包，所有业务代码都封装在此包中 + ├── __init__.py # Python包初始化文件，标记该目录为可导入的Python模块 + ├── robots/ # 机器人模型模块：存放SO-ARM100/101两款机械臂的仿真模型配置 + ├── scripts/ # 运行脚本模块：存放项目的调试、训练、回放等可运行脚本 + ├── tasks/ # 仿真任务模块：存放项目支持的reach/lift两个仿真任务的定义 + └── ui_extension_example.py # Omniverse UI扩展示例：演示如何为仿真环境添加自定义界面扩展 +``` + +通过这个树状文件结构图，能清楚看各个文件夹下存放的内容，方便之后添加nero案例。 + +## 四、下载URDF模型 + +agx_arm_urdf仓库中有关于松灵所有机械臂的URDF模型，下载下来之后需要单独将nero的模型拿出来放到robots文件夹中 + +``` +git clone https://github.com/agilexrobotics/agx_arm_urdf.git +cd agx_arm_urdf/ +cp -r nero/ isaac_so_arm101/robots +``` + +成功将nero/复制到isaac_so_arm101/robots后，需要修改一下nero_description.urdf，因为其中所使用的路径是ROS中常用的索引路径，在IsaacLab中识别不到，将所有link的mesh 文件的路径修改为相对路径；拿其中的base_link作为例子 + +**修改前** + +```xml + + + + + + + + + + + + + + + + + + + +``` + +**修改后** + +```xml + + + + + + + + + + + + + + + + + + + +``` + +## 五、配置IsaacLab文件 + +### 导入URDF + +修改完urdf之后，需要编写一个python文件导入URDF模型，设置机械臂的电机属性，刚度，阻尼等参数，这个文件一般放置在nero 目录下src/isaac_so_arm101/robots/nero/nero.py；文件内容如下 + +```python +from pathlib import Path + +import isaaclab.sim as sim_utils +from isaaclab.actuators import ImplicitActuatorCfg +from isaaclab.assets.articulation import ArticulationCfg + +TEMPLATE_ASSETS_DATA_DIR = Path(__file__).resolve().parent + +## +# Configuration +## + +NERO_CFG = ArticulationCfg( + spawn=sim_utils.UrdfFileCfg( + fix_base=True, + replace_cylinders_with_capsules=True, + asset_path=f"{TEMPLATE_ASSETS_DATA_DIR}/urdf/nero_gripper.urdf", + activate_contact_sensors=False, # set as false while waiting for capsule implementation + rigid_props=sim_utils.RigidBodyPropertiesCfg( + disable_gravity=False, + max_depenetration_velocity=5.0, + ), + articulation_props=sim_utils.ArticulationRootPropertiesCfg( + enabled_self_collisions=True, + solver_position_iteration_count=8, + solver_velocity_iteration_count=0, + ), + joint_drive=sim_utils.UrdfConverterCfg.JointDriveCfg( + gains=sim_utils.UrdfConverterCfg.JointDriveCfg.PDGainsCfg(stiffness=0, damping=0) + ), + ), + init_state=ArticulationCfg.InitialStateCfg( + rot=(1.0, 0.0, 0.0, 0.0), + joint_pos={ + "joint1": 0.0, + "joint2": 0.0, + "joint3": 0.0, + "joint4": 2.0, + "joint5": 0.0, + "joint6": 0.0, + "joint7": 0.0, + "gripper_joint1": 0.05, + "gripper_joint2": -0.05 + }, + # Set initial joint velocities to zero + joint_vel={".*": 0.0}, + ), + actuators={ + "arm": ImplicitActuatorCfg( + joint_names_expr=["joint.*"], + effort_limit=25.0, # 稍微限制出力，防止瞬间冲击 + velocity_limit=1.5, + + # 刚度 (Stiffness)：针对轻型臂 Piper 优化，不再追求极致硬度 + stiffness={ + "joint1": 200.0, + "joint2": 170.0, + "joint3": 120.0, + "joint4": 80.0, + "joint5": 50.0, + "joint6": 20.0, + "joint7": 10.0 + }, + + # 阻尼 (Damping)：采用临界阻尼思路，比例设在 10% 左右 + damping={ + "joint1": 100.0, + "joint2": 60.0, + "joint3": 70.0, + "joint4": 24.0, + "joint5": 20.0, + "joint6": 10.0, + "joint7": 5, + }, + ), + "gripper": ImplicitActuatorCfg( + joint_names_expr=["gripper_joint1","gripper_joint2"], + effort_limit_sim=22, # Increased from 1.9 to 2.5 for stronger grip + velocity_limit_sim=1.5, + stiffness=800.0, # Increased from 25.0 to 60.0 for more reliable closing + damping=20.0, # Increased from 10.0 to 20.0 for stability + ), + + }, + + + soft_joint_pos_limit_factor=0.9, +) +``` + +然后还需要创建一个__ int__.py文件，初始化文件，标记该目录为Python子模块 + +### 创建tasks任务 + +在tasks/lift目录下创建两个文件nero_joint_pos_env_cfg.py和nero_lift_env_cfg.py + +nero_joint_pos_env_cfg.py包含关节位置控制的环境配置，其中需要明确可控制关节和机械臂末端link，以及方块的基本信息 + +```python +# Copyright (c) 2024-2025, Muammer Bay (LycheeAI), Louis Le Lay +# All rights reserved. +# +# SPDX-License-Identifier: BSD-3-Clause +# +# Copyright (c) 2022-2025, The Isaac Lab Project Developers. +# All rights reserved. +# +# SPDX-License-Identifier: BSD-3-Clause + +import isaaclab_tasks.manager_based.manipulation.lift.mdp as mdp +from isaaclab.assets import RigidObjectCfg + +# from isaaclab.managers NotImplementedError +from isaaclab.sensors.frame_transformer.frame_transformer_cfg import ( + FrameTransformerCfg, + OffsetCfg, +) +from isaaclab.sim.schemas.schemas_cfg import RigidBodyPropertiesCfg +from isaaclab.sim.spawners.from_files.from_files_cfg import UsdFileCfg +from isaaclab.utils import configclass +from isaaclab.utils.assets import ISAAC_NUCLEUS_DIR +from isaac_so_arm101.robots import SO_ARM100_CFG, SO_ARM101_CFG # noqa: F401 +# from isaac_so_arm101.tasks.lift.lift_env_cfg import LiftEnvCfg +from isaac_so_arm101.tasks.lift.nero_lift_env_cfg import LiftEnvCfg +from isaaclab.markers.config import FRAME_MARKER_CFG # isort: skip +# from isaac_so_arm101.robots.piper_description.piper import PIPER_CFG +from isaac_so_arm101.robots.nero_description.nero import NERO_CFG +@configclass +class NeroLiftCubeEnvCfg(LiftEnvCfg): + def __post_init__(self): + # post init of parent + super().__post_init__() + + # Set so arm as robot + self.scene.robot = NERO_CFG.replace(prim_path="{ENV_REGEX_NS}/Robot") + + # override actions + self.actions.arm_action = mdp.JointPositionActionCfg( + asset_name="robot", + joint_names=["joint1", "joint2", "joint3", "joint4", "joint5", "joint6","joint7" ], + scale=0.5, + use_default_offset=True, + ) + self.actions.gripper_action = mdp.BinaryJointPositionActionCfg( + asset_name="robot", + joint_names=["gripper_joint1","gripper_joint2"], + open_command_expr={"gripper_joint2": -0.05,"gripper_joint1":0.05}, + close_command_expr={"gripper_joint2": -0.001,"gripper_joint1":0.0}, + ) + # Set the body name for the end effector + self.commands.object_pose.body_name = ["gripper_base"] + + # Set Cube as object + self.scene.object = RigidObjectCfg( + prim_path="{ENV_REGEX_NS}/Object", + init_state=RigidObjectCfg.InitialStateCfg(pos=[0.2, 0.0, 0.015], rot=[1, 0, 0, 0]), + spawn=UsdFileCfg( + usd_path=f"{ISAAC_NUCLEUS_DIR}/Props/Blocks/DexCube/dex_cube_instanceable.usd", + scale=(0.5, 0.5, 0.5), + rigid_props=RigidBodyPropertiesCfg( + solver_position_iteration_count=16, + solver_velocity_iteration_count=1, + max_angular_velocity=1000.0, + max_linear_velocity=1000.0, + max_depenetration_velocity=5.0, + disable_gravity=False, + ), + ), + ) + + # Listens to the required transforms + marker_cfg = FRAME_MARKER_CFG.copy() + marker_cfg.markers["frame"].scale = (0.05, 0.05, 0.05) + marker_cfg.prim_path = "/Visuals/FrameTransformer" + self.scene.ee_frame = FrameTransformerCfg( + prim_path="{ENV_REGEX_NS}/Robot/base_link", + debug_vis=True, + visualizer_cfg=marker_cfg, + target_frames=[ + FrameTransformerCfg.FrameCfg( + prim_path="{ENV_REGEX_NS}/Robot/gripper_base", + name="end_effector", + offset=OffsetCfg( + pos=[0.0, 0.0, 0.125], + ), + ), + ], + ) + + +@configclass +class NeroLiftCubeEnvCfg_PLAY(NeroLiftCubeEnvCfg): + def __post_init__(self): + # post init of parent + super().__post_init__() + # make a smaller scene for play + self.scene.num_envs = 50 + self.scene.env_spacing = 2.5 + # disable randomization for play + self.observations.policy.enable_corruption = False + + +``` + +nero_lift_env_cfg.py包含任务的基础环境配置，任务奖励、惩罚、策略、目标点位置、方块位置等都是在这里设置 + +```python +# Copyright (c) 2024-2025, Muammer Bay (LycheeAI), Louis Le Lay +# All rights reserved. +# +# SPDX-License-Identifier: BSD-3-Clause +# +# Copyright (c) 2022-2025, The Isaac Lab Project Developers. +# All rights reserved. +# +# SPDX-License-Identifier: BSD-3-Clause + +from dataclasses import MISSING + +import isaaclab.sim as sim_utils + +# from . import mdp +import isaac_so_arm101.tasks.lift.mdp as mdp +from isaaclab.assets import ( + ArticulationCfg, + AssetBaseCfg, + DeformableObjectCfg, + RigidObjectCfg, +) +from isaaclab.envs import ManagerBasedRLEnvCfg +from isaaclab.managers import CurriculumTermCfg as CurrTerm +from isaaclab.managers import EventTermCfg as EventTerm +from isaaclab.managers import ObservationGroupCfg as ObsGroup +from isaaclab.managers import ObservationTermCfg as ObsTerm +from isaaclab.managers import RewardTermCfg as RewTerm +from isaaclab.managers import SceneEntityCfg +from isaaclab.managers import TerminationTermCfg as DoneTerm +from isaaclab.scene import InteractiveSceneCfg +from isaaclab.sensors.frame_transformer.frame_transformer_cfg import FrameTransformerCfg +from isaaclab.sim.spawners.from_files.from_files_cfg import GroundPlaneCfg, UsdFileCfg +from isaaclab.utils import configclass +from isaaclab.utils.assets import ISAAC_NUCLEUS_DIR + +# from isaaclab.utils.offset import OffsetCfg +# from isaaclab.utils.noise import AdditiveUniformNoiseCfg as Unoise +# from isaaclab.utils.visualizer import FRAME_MARKER_CFG +# from isaaclab.utils.assets import RigidBodyPropertiesCfg + + +## +# Scene definition +## + + +@configclass +class ObjectTableSceneCfg(InteractiveSceneCfg): + """Configuration for the lift scene with a robot and a object. + This is the abstract base implementation, the exact scene is defined in the derived classes + which need to set the target object, robot and end-effector frames + """ + + # robots: will be populated by agent env cfg + robot: ArticulationCfg = MISSING + # end-effector sensor: will be populated by agent env cfg + ee_frame: FrameTransformerCfg = MISSING + # target object: will be populated by agent env cfg + object: RigidObjectCfg | DeformableObjectCfg = MISSING + + # Table + table = AssetBaseCfg( + prim_path="{ENV_REGEX_NS}/Table", + init_state=AssetBaseCfg.InitialStateCfg(pos=[0.5, 0, 0], rot=[0.707, 0, 0, 0.707]), + spawn=UsdFileCfg(usd_path=f"{ISAAC_NUCLEUS_DIR}/Props/Mounts/SeattleLabTable/table_instanceable.usd"), + ) + + # plane + plane = AssetBaseCfg( + prim_path="/World/GroundPlane", + init_state=AssetBaseCfg.InitialStateCfg(pos=[0, 0, -1.05]), + spawn=GroundPlaneCfg(), + ) + + # lights + light = AssetBaseCfg( + prim_path="/World/light", + spawn=sim_utils.DomeLightCfg(color=(0.75, 0.75, 0.75), intensity=3000.0), + ) + + +## +# MDP settings +## + + +@configclass +class CommandsCfg: + """Command terms for the MDP.""" + + object_pose = mdp.UniformPoseCommandCfg( + asset_name="robot", + body_name=MISSING, # will be set by agent env cfg + resampling_time_range=(5.0, 5.0), + debug_vis=True, + ranges=mdp.UniformPoseCommandCfg.Ranges( + pos_x=(0.3, 0.35), + pos_y=(-0.2, 0.2), + pos_z=(0.2, 0.35), + roll=(0.0, 0.0), + pitch=(0.0, 0.0), + yaw=(0.0, 0.0), + ), + ) + + +@configclass +class ActionsCfg: + """Action specifications for the MDP.""" + + # will be set by agent env cfg + arm_action: mdp.JointPositionActionCfg | mdp.DifferentialInverseKinematicsActionCfg = MISSING + gripper_action: mdp.BinaryJointPositionActionCfg = MISSING + + +@configclass +class ObservationsCfg: + """Observation specifications for the MDP.""" + + @configclass + class PolicyCfg(ObsGroup): + """Observations for policy group.""" + + joint_pos = ObsTerm(func=mdp.joint_pos_rel) + joint_vel = ObsTerm(func=mdp.joint_vel_rel) + object_position = ObsTerm(func=mdp.object_position_in_robot_root_frame) + target_object_position = ObsTerm(func=mdp.generated_commands, params={"command_name": "object_pose"}) + actions = ObsTerm(func=mdp.last_action) + + def __post_init__(self): + self.enable_corruption = True + self.concatenate_terms = True + + # observation groups + policy: PolicyCfg = PolicyCfg() + + +@configclass +class EventCfg: + """Configuration for events.""" + + reset_all = EventTerm(func=mdp.reset_scene_to_default, mode="reset") + + reset_object_position = EventTerm( + func=mdp.reset_root_state_uniform, + mode="reset", + params={ + "pose_range": {"x": (0.1, 0.2), "y": (-0.1, 0.2), "z": (0.0, 0.0)}, + "velocity_range": {}, + "asset_cfg": SceneEntityCfg("object", body_names="Object"), + }, + ) + + +@configclass +class RewardsCfg: + """Reward terms for the MDP.""" + + reaching_object = RewTerm(func=mdp.object_ee_distance, params={"std": 0.05}, weight=1.0) + + lifting_object = RewTerm(func=mdp.object_is_lifted, params={"minimal_height": 0.025}, weight=15.0) + + object_goal_tracking = RewTerm( + func=mdp.object_goal_distance, + params={"std": 0.3, "minimal_height": 0.025, "command_name": "object_pose"}, + weight=16.0, + ) + + object_goal_tracking_fine_grained = RewTerm( + func=mdp.object_goal_distance, + params={"std": 0.05, "minimal_height": 0.025, "command_name": "object_pose"}, + weight=5.0, + ) + + # action penalty + action_rate = RewTerm(func=mdp.action_rate_l2, weight=-1e-4) + + joint_vel = RewTerm( + func=mdp.joint_vel_l2, + weight=-1e-4, + params={"asset_cfg": SceneEntityCfg("robot")}, + ) + + +@configclass +class TerminationsCfg: + """Termination terms for the MDP.""" + + time_out = DoneTerm(func=mdp.time_out, time_out=True) + + object_dropping = DoneTerm( + func=mdp.root_height_below_minimum, params={"minimum_height": -0.05, "asset_cfg": SceneEntityCfg("object")} + ) + + +@configclass +class CurriculumCfg: + """Curriculum terms for the MDP.""" + + action_rate = CurrTerm( + func=mdp.modify_reward_weight, params={"term_name": "action_rate", "weight": -1e-1, "num_steps": 10000} + ) + + joint_vel = CurrTerm( + func=mdp.modify_reward_weight, params={"term_name": "joint_vel", "weight": -1e-1, "num_steps": 10000} + ) + + +## +# Environment configuration +## + + +@configclass +class LiftEnvCfg(ManagerBasedRLEnvCfg): + """Configuration for the lifting environment.""" + + # Scene settings + scene: ObjectTableSceneCfg = ObjectTableSceneCfg(num_envs=4096, env_spacing=2.5) + # Basic settings + observations: ObservationsCfg = ObservationsCfg() + actions: ActionsCfg = ActionsCfg() + commands: CommandsCfg = CommandsCfg() + # MDP settings + rewards: RewardsCfg = RewardsCfg() + terminations: TerminationsCfg = TerminationsCfg() + events: EventCfg = EventCfg() + curriculum: CurriculumCfg = CurriculumCfg() + + def __post_init__(self): + """Post initialization.""" + # general settings + self.decimation = 2 + self.episode_length_s = 5.0 + self.viewer.eye = (2.5, 2.5, 1.5) + # simulation settings + self.sim.dt = 0.01 # 100Hz + self.sim.render_interval = self.decimation + + self.sim.physx.bounce_threshold_velocity = 0.2 + self.sim.physx.bounce_threshold_velocity = 0.01 + self.sim.physx.gpu_found_lost_aggregate_pairs_capacity = 1024 * 1024 * 4 + self.sim.physx.gpu_total_aggregate_pairs_capacity = 16 * 1024 + self.sim.physx.friction_correlation_distance = 0.00625 +``` + +然后需要在src/isaac_so_arm101/tasks/reach/__ init__.py中注册nero reach任务 + +```python +# Copyright (c) 2024-2025, Muammer Bay (LycheeAI), Louis Le Lay +# All rights reserved. +# +# SPDX-License-Identifier: BSD-3-Clause +# +# Copyright (c) 2022-2025, The Isaac Lab Project Developers. +# All rights reserved. +# +# SPDX-License-Identifier: BSD-3-Clause + +import gymnasium as gym + +from . import agents + +## +# Register Gym environments. +## + +gym.register( + id="Isaac-SO-ARM100-Lift-Cube-v0", + entry_point="isaaclab.envs:ManagerBasedRLEnv", + kwargs={ + "env_cfg_entry_point": f"{__name__}.joint_pos_env_cfg:SoArm100LiftCubeEnvCfg", + "rsl_rl_cfg_entry_point": f"{agents.__name__}.rsl_rl_ppo_cfg:LiftCubePPORunnerCfg", + }, + disable_env_checker=True, +) + +gym.register( + id="Isaac-SO-ARM100-Lift-Cube-Play-v0", + entry_point="isaaclab.envs:ManagerBasedRLEnv", + kwargs={ + "env_cfg_entry_point": f"{__name__}.joint_pos_env_cfg:SoArm100LiftCubeEnvCfg_PLAY", + "rsl_rl_cfg_entry_point": f"{agents.__name__}.rsl_rl_ppo_cfg:LiftCubePPORunnerCfg", + }, + disable_env_checker=True, +) + +gym.register( + id="Isaac-SO-ARM101-Lift-Cube-v0", + entry_point="isaaclab.envs:ManagerBasedRLEnv", + kwargs={ + "env_cfg_entry_point": f"{__name__}.joint_pos_env_cfg:SoArm101LiftCubeEnvCfg", + "rsl_rl_cfg_entry_point": f"{agents.__name__}.rsl_rl_ppo_cfg:LiftCubePPORunnerCfg", + }, + disable_env_checker=True, +) + +gym.register( + id="Isaac-SO-ARM101-Lift-Cube-Play-v0", + entry_point="isaaclab.envs:ManagerBasedRLEnv", + kwargs={ + "env_cfg_entry_point": f"{__name__}.joint_pos_env_cfg:SoArm101LiftCubeEnvCfg_PLAY", + "rsl_rl_cfg_entry_point": f"{agents.__name__}.rsl_rl_ppo_cfg:LiftCubePPORunnerCfg", + }, + disable_env_checker=True, +) + +gym.register( + id="Isaac-Nero-Lift-Cube-v0", + entry_point="isaaclab.envs:ManagerBasedRLEnv", + kwargs={ + "env_cfg_entry_point": f"{__name__}.nero_joint_pos_env_cfg:NeroLiftCubeEnvCfg", + "rsl_rl_cfg_entry_point": f"{agents.__name__}.rsl_rl_ppo_cfg:LiftCubePPORunnerCfg", + "rl_games_cfg_entry_point": f"{agents.__name__}:rl_games_ppo_cfg.yaml", + + }, + disable_env_checker=True, +) + +``` + +## 六、训练Lift任务 + +激活conda 环境 + +``` +conda activate env_isaaclab +``` + +进入isaac_so_arm101目录 + +``` +cd isaac_so_arm101 +``` + +执行训练指令，采用无头模式，减小资源消耗 + +``` +uv run train --task Isaac-Nero-Lift-Cube-v0 --headless +``` + +如果显卡性能比较强的可以使用以下命令时时查看训练效果 + +``` +uv run train --task Isaac-Nero-Lift-Cube-v0 +``` + +训练次数是1000次，当训练完成之后可以使用以下命令查看效果 + +``` +uv run play --task Isaac-Nero-Lift-Cube-v0 +``` + +![](./img/nero_rl.gif) + + + diff --git "a/third_party/Agilex-College/limo/RDA_planner/RDA_planner \351\203\250\347\275\262\344\270\216\345\256\236\347\216\260.md" "b/third_party/Agilex-College/limo/RDA_planner/RDA_planner \351\203\250\347\275\262\344\270\216\345\256\236\347\216\260.md" new file mode 100644 index 0000000000000000000000000000000000000000..daad644463cc3e0cbcfe7228e768ea2864d4bb10 --- /dev/null +++ "b/third_party/Agilex-College/limo/RDA_planner/RDA_planner \351\203\250\347\275\262\344\270\216\345\256\236\347\216\260.md" @@ -0,0 +1,140 @@ +# RDA_planner 部署与实现 + +## 摘要 + +RDA_planner复现 + +## 标签 + +limo、RDA_planner、路径规划 + +## 仓库 + +- **导航仓库**: https://github.com/agilexrobotics/Agilex-College +- **项目仓库**: https://github.com/agilexrobotics/limo/RDA_planner.git + +## 使用环境 + +系统：ubuntu 20.04 + +ROS版本：noetic + +python版本：python3.9 + +## 部署过程 + +1、下载安装conda + +[下载链接](https://www.anaconda.com/download/success) + +根据系统空间大小选择下载Anaconda或者是Miniconda + +![](img/img_1.png) + +下载完之后，输入以下命令安装 + +- Miniconda: + + ``` + bash Miniconda3-latest-Linux-x86_64.sh + ``` + +- Anaconda: + + ``` + bash Anaconda-latest-Linux-x86_64.sh + ``` + +2、创建conda环境并激活 + +```python +conda create -n rda python=3.9 +conda activate rda +``` + +3、下载RDA_planner + +```python +mkdir -p ~/rda_ws/src +cd ~/rda_ws/src +git clone https://github.com/hanruihua/RDA_planner +cd RDA_planner +pip install -e . +``` + +4、下载仿真器 +```python +pip install ir-sim +``` + +5、运行RDA_planner中的例子 +```python +cd RDA_planner/example/lidar_nav +python lidar_path_track_diff.py +``` + +运行之后和官方readme的效果相同 + +![](img/img_2.gif) + +# rda_ros部署过程 + +1、在conda环境下载依赖 +```python +conda activate rda +sudo apt install python3-empy +sudo apt install ros-noetic-costmap-converter +pip install empy==3.3.4 +pip install rospkg +pip install catkin_pkg +``` + +2、下载代码 +```python +cd ~/rda_ws/src +git clone https://github.com/hanruihua/rda_ros +cd ~/rda_ws && catkin_make +cd ~/rda_ws/src/rda_ros +sh source_setup.sh && source ~/rda_ws/devel/setup.sh && rosdep install rda_ros +``` + +3、下载仿真需要的组件 + +这里会下载两个仓库limo_ros和rvo_ros + +limo_ros：仿真需要用的机器人模型 + +rvo_ros：仿真环境中使用到的圆柱障碍 + +```python +cd rda_ros/example/dynamic_collision_avoidance +sh gazebo_example_setup.sh +``` + +4、运行gazebo仿真 + +**使用脚本运行** + +```python +cd rda_ros/example/dynamic_collision_avoidance +sh run_rda_gazebo_scan.sh +``` + +**使用单独命令运行** + +启动仿真环境 + +``` +roslaunch rda_ros gazebo_limo_env10.launch +``` + +启动rda_planner + +``` +roslaunch rda_ros rda_gazebo_limo_scan.launch +``` + + + + + diff --git a/third_party/Agilex-College/mujoco_demo/README.md b/third_party/Agilex-College/mujoco_demo/README.md new file mode 100644 index 0000000000000000000000000000000000000000..1b7f3f3a22b80aaab6d17ff8de476b609e1d0f74 --- /dev/null +++ b/third_party/Agilex-College/mujoco_demo/README.md @@ -0,0 +1 @@ +# 注意在python脚本里面修改.xml文件的路径 diff --git a/third_party/Agilex-College/mujoco_demo/limo_pro/README.md b/third_party/Agilex-College/mujoco_demo/limo_pro/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b79faf50e57733e9c093554fd52c1be4cd0e2586 --- /dev/null +++ b/third_party/Agilex-College/mujoco_demo/limo_pro/README.md @@ -0,0 +1,545 @@ +## **【标题】LIMO PRO实现Mujoco仿真** +| | 作者 | 复核 | 排版 | 发布 | +| --- | :---: | :---: | :---: | :---: | +| 人 员 | Khalil | XXX（英文名） | XXX（英文名） | XXX（英文名） | +| 更新时间 | 2025年8月5日 | 2025年XX月XX日 | 2025年XX月XX日 | 2025年XX月XX日 | + + +## 摘要 +本章将会一步步展示Limo Pro底盘从处理URDF、导出Mujoco XML格式、仿真数据调试最后到mujoco自定义控制器的完整实现步骤。 + +## 标签 +Mujoco仿真、Mujoco控制器、URDF、松灵Limo + +## 代码仓库 +github链接：[**https://github.com/agilexrobotics/Agilex-College.git**](https://github.com/agilexrobotics/Agilex-College.git) + +## 功能演示 +[此处为语雀卡片，点击链接查看](https://www.yuque.com/docs/231105255#OurNT) + +--- + +# 使用前准备 +## 硬件准备 ++ 松灵底盘系列任选一款 ++ 个人电脑 + +## 软件环境配置 +1. 配置Mujoco环境 + +```bash +# 创建mujoco默认路径 +cd ~ +mkdir .mujoco +cd .mujoco +# 下载mujoco +wget https://github.com/google-deepmind/mujoco/releases/download/2.1.0/mujoco210-linux-x86_64.tar.gz +# 解压 +tar -zxvf mujoco210-linux-x86_64.tar.gz -C ~/.mujoco +# 添加环境变量 +echo "export LD_LIBRARY_PATH=~/.mujoco/mujoco200/bin${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}" >> ~/.bashrc +echo "export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/dlut/.mujoco/mujoco200/bin" >> ~/.bashrc +echo "export MUJOCO_KEY_PATH=~/.mujoco${MUJOCO_KEY_PATH}" >> ~/.bashrc +echo "export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/lib/nvidia" >> ~/.bashrc +``` + +2. 测试mujoco是否安装正常 + +```bash +cd ~/.mujoco/mujoco2000/bin +./simulate ../model/humanoid.xml +``` + +3. 安装mujoco-py + +```bash +git clone https://github.com/openai/mujoco-py.git +cd ~/mujoco-py +pip3 install -U 'mujoco-py<2.2,>=2.1' +pip3 install -r requirements.txt +pip3 install -r requirements.dev.txt +python3 setup.py install +sudo apt install libosmesa6-dev +sudo apt install patchelf +``` + +4. 测试mujoco-py是否安装正常 + +```python +import mujoco_py +import os +mj_path = mujoco_py.utils.discover_mujoco() +xml_path = os.path.join(mj_path, 'model', 'humanoid.xml') +model = mujoco_py.load_model_from_path(xml_path) +sim = mujoco_py.MjSim(model) +print(sim.data.qpos) +sim.step() +print(sim.data.qpos) +``` + +5. 获取Limo pro的URDF + +```bash +cd your_ws/src +git clone https://github.com/agilexrobotics/ugv_gazebo_sim.git +cd .. +catkin_make +``` + +--- + +# 准备Mujoco XML +## 转换XACRO为URDF +1. 观察Limo pro的描述文件以及模型文件，因为描述文件全部用xacro组织的，所有需要将描述文件转换为一个包含描述完整机器人的URDF文件 + +```bash +urdf/ +├── limo_four_diff.gazebo +├── limo_four_diff.xacro +├── limo_gazebo.gazebo +├── limo_steering_hinge.xacro +└── limo_xacro.xacro +meshes/ +├── limo_base.dae +├── limo_base.stl +├── limo_wheel.dae +└── limo_wheel.stl +``` + +2. 找到最顶层的xacro文件，本期使用的Limo Pro为`limo_four_diff.xacro` +3. 然后执行`xacro-->>urdf`的转换命令 + +```bash +rosrun xacro xacro limo_four_diff.xacro > limo_four_diff.urdf +``` + +4. 修改转换后的`limo_four_diff.urdf`，主要是去掉其中的gazebo插件，还需要将加载DAE模型改为加载STL模型文件 + +![](https://cdn.nlark.com/yuque/0/2025/png/51431964/1754386067183-48698297-3b84-4d1f-97f2-9b265d0cdbb3.png) + +## 转换DEA到STL并减少模型面数 +1. Mujoco最大支持单个模型19999个面，对于Limo pro的模型我们需要先利用`meshlab`处理模型 + +```bash +# 安装meshlab +sudo apt install meshlab +``` + +2. 启动meshlab修改模型，执行下面的命令后会弹出meshlab的操作界面 + +```bash +meshlab +``` + +![](https://cdn.nlark.com/yuque/0/2025/png/51431964/1754387288860-e1be202d-e4cc-461d-8d3b-427384fd8fdf.png) + +3. 点击左上角第一个按钮`File`，选择`Import Mesh`按钮或者按`ctrl+i`导入dea文件 +4. 导入dea后，选择左上角第三个`Filter`，展开后选择`Remeshing，Simplification and Reconstruction`，再展开后选择`Simplification Quadric Edge Collapse Decimation` + +![](https://cdn.nlark.com/yuque/0/2025/png/51431964/1754387662169-c43df37b-ae06-4fcd-aad0-cd63672e98c0.png) + +5. 然后输入目标面数，我们需要减少到mujoco接受的19999,然后点击`Apply` + +![](https://cdn.nlark.com/yuque/0/2025/png/51431964/1754387776248-87edc270-cdcc-4802-b45d-800eca57e4c9.png) + +6. 然后再次点击左上角第一个按钮`File`，选择`Export Mesh as...`后会弹出文件管理器，在文件名后面修改文件格式后缀为`.stl` + +![](https://cdn.nlark.com/yuque/0/2025/png/51431964/1754388083214-3dd92454-379b-453c-9283-dc0436aa4b3b.png) + +7. 按上面的操作再处理车轮的模型文件 + +## 转换URDF为Mujoco XML +1. 使用Mujoco提供的工具来转换，工具路径为： + +```bash +~/.mujoco/mujoco210/bin/compile +``` + +2. 使用转换工具转换为Mujoco XML + +```bash +./compile ~/your_ws/src/package/urdf/limo_four_diff.urdf ~/your_ws/src/package/urdf/limo_four_diff.xml +``` + +3. 转换成功后可以看到下面的文件 + +```xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +``` + +4. 检查转换是否正确，如果转换成功可以看到Mujoco仿真界面 + +```xml +./simulate ~/your_ws/src/limo/limo_description/urdf/limo_four_diff.xml +``` + +![](https://cdn.nlark.com/yuque/0/2025/png/51431964/1754385871618-a1d18326-a363-4750-8f1f-436d8f0da164.png) + +## 完善Mujoco XML以仿真 +1. 此时的Mujoco XML只能查看模型，我们无法控制它，所以需要为XML添加动作执行器和传感器，下面展示完善后的XML文件 + +```xml + + + + + + + + + + + +``` + +2. 再次启动仿真程序，拖动Control面板的滑条控制小车移动 + +```xml +./simulate limo/limo_description/urdf/limo_four_diff.xml +``` + +![](https://cdn.nlark.com/yuque/0/2025/png/51431964/1754388705858-c4dacec4-fb16-499b-8e05-786211b1d41b.png) + +# 编写Mujoco控制器与ROS接口 +## 完成程序代码 +```python +#!/usr/bin/env python3 +import mujoco +import mujoco.viewer +import numpy as np +import time +import math +from pynput import keyboard +import rospy +from geometry_msgs.msg import Twist +from sensor_msgs.msg import JointState + +class LimoControl: + def __init__(self): + # 加载模型 + self.model = mujoco.MjModel.from_xml_path('/home/khalillee/sim1_ws/src/limo/limo_description/urdf/test.xml') + self.data = mujoco.MjData(self.model) + + # 控制参数 + self.MAX_SPEED = 10.0 # 最大速度 (rad/s) + self.LINEAR_VEL = 2.0 # 线性速度 (m/s) + self.ANGULAR_VEL = 10.0 # 角速度 (rad/s) + + # ROS参数 + self.use_ros_control = rospy.get_param('~use_ros_control', False) + self.wheel_radius = rospy.get_param('~wheel_radius', 0.05) + self.wheel_separation = rospy.get_param('~wheel_separation', 0.13) + self.base_width = rospy.get_param('~base_width', 0.2) + + # 初始化ROS节点 + rospy.init_node('limo_mujoco_control') + + if self.use_ros_control: + self.cmd_vel_sub = rospy.Subscriber('/cmd_vel', Twist, self.cmd_vel_callback) + rospy.loginfo("使用ROS cmd_vel控制模式") + else: + self.start_keyboard_listener() + rospy.loginfo("使用键盘控制模式") + + # 初始化传感器数据发布 + self.joint_state_pub = rospy.Publisher('/joint_states', JointState, queue_size=10) + self.joint_state_msg = JointState() + self.joint_state_msg.name = [ + 'front_left_wheel', + 'front_right_wheel', + 'rear_left_wheel', + 'rear_right_wheel' + ] + + # 控制变量 + self.ros_cmd_vel = None + self.current_keys = set() + + def cmd_vel_callback(self, msg): + """ROS cmd_vel回调函数""" + self.ros_cmd_vel = msg + + def set_motor_velocity(self, vel_fl, vel_fr, vel_rl, vel_rr): + """设置四个电机的速度""" + self.data.ctrl[0] = vel_fl # 左前轮 + self.data.ctrl[1] = vel_fr # 右前轮 + self.data.ctrl[2] = vel_rl # 左后轮 + self.data.ctrl[3] = vel_rr # 右后轮 + + def stop(self): + """停止""" + self.set_motor_velocity(0, 0, 0, 0) + + def differential_drive(self, v, w): + """ + 差速驱动控制 + v: 线速度 (m/s) + w: 角速度 (rad/s) + """ + # 计算四个轮子的速度 (rad/s) + vel_fl = (v - w * (self.wheel_separation + self.base_width)/2) / self.wheel_radius + vel_fr = (v + w * (self.wheel_separation + self.base_width)/2) / self.wheel_radius + vel_rl = (v - w * (self.wheel_separation + self.base_width)/2) / self.wheel_radius + vel_rr = (v + w * (self.wheel_separation + self.base_width)/2) / self.wheel_radius + + # 限制最大速度 + vel_fl = np.clip(vel_fl, -self.MAX_SPEED, self.MAX_SPEED) + vel_fr = np.clip(vel_fr, -self.MAX_SPEED, self.MAX_SPEED) + vel_rl = np.clip(vel_rl, -self.MAX_SPEED, self.MAX_SPEED) + vel_rr = np.clip(vel_rr, -self.MAX_SPEED, self.MAX_SPEED) + + self.set_motor_velocity(vel_fl, vel_fr, vel_rl, vel_rr) + + def publish_joint_states(self): + """发布关节状态""" + self.joint_state_msg.header.stamp = rospy.Time.now() + self.joint_state_msg.header.frame_id = "base_link" + + # 从模型获取关节位置 + self.joint_state_msg.position = [ + self.data.joint('front_left_wheel').qpos[0], + self.data.joint('front_right_wheel').qpos[0], + self.data.joint('rear_left_wheel').qpos[0], + self.data.joint('rear_right_wheel').qpos[0] + ] + + # 从传感器获取轮速 + self.joint_state_msg.velocity = [ + self.data.sensor('front_left_wheel_vel_sensor').data[0], + self.data.sensor('front_right_wheel_vel_sensor').data[0], + self.data.sensor('rear_left_wheel_vel_sensor').data[0], + self.data.sensor('rear_right_wheel_vel_sensor').data[0] + ] + + # 发布关节状态 + self.joint_state_pub.publish(self.joint_state_msg) + + def on_press(self, key): + """键盘按下事件""" + try: + self.current_keys.add(key.char) + except AttributeError: + self.current_keys.add(key) + + def on_release(self, key): + """键盘释放事件""" + try: + self.current_keys.remove(key.char) + except AttributeError: + try: + self.current_keys.remove(key) + except KeyError: + pass + + def handle_keyboard_control(self): + """处理键盘控制""" + linear = 0.0 + angular = 0.0 + + if '8' in self.current_keys or keyboard.Key.up in self.current_keys: + linear += self.LINEAR_VEL + if '2' in self.current_keys or keyboard.Key.down in self.current_keys: + linear -= self.LINEAR_VEL + if '4' in self.current_keys or keyboard.Key.left in self.current_keys: + angular += self.ANGULAR_VEL + if '6' in self.current_keys or keyboard.Key.right in self.current_keys: + angular -= self.ANGULAR_VEL + if ' ' in self.current_keys: # 空格键停止 + linear = 0.0 + angular = 0.0 + + self.differential_drive(linear, angular) + + def start_keyboard_listener(self): + """启动键盘监听""" + self.listener = keyboard.Listener( + on_press=self.on_press, + on_release=self.on_release) + self.listener.start() + rospy.loginfo("键盘控制已启用: 8/↑: 前进, 2/↓: 后退, 4/←: 左转, 6/→: 右转, 空格: 停止") + + def run(self): + """主运行循环""" + try: + with mujoco.viewer.launch_passive(self.model, self.data) as viewer: + while not rospy.is_shutdown() and viewer.is_running(): + step_start = time.time() + + # 处理控制输入 + if self.use_ros_control and self.ros_cmd_vel is not None: + self.differential_drive(self.ros_cmd_vel.linear.x, self.ros_cmd_vel.angular.z) + else: + self.handle_keyboard_control() + + # 步进模拟 + mujoco.mj_step(self.model, self.data) + + # 发布传感器数据 + self.publish_joint_states() + + # 同步视图 + viewer.sync() + + # 控制循环频率 + time_until_next_step = self.model.opt.timestep - (time.time() - step_start) + if time_until_next_step > 0: + time.sleep(time_until_next_step) + + except KeyboardInterrupt: + rospy.loginfo("Simulation stopped by user") + finally: + self.stop() + rospy.loginfo("Final robot state published") + +if __name__ == "__main__": + control = LimoControl() + control.run() +``` + +## 启动控制器 +1. 启动Mujoco控制器 + +```python +rosrun limo_description test_mujoco.py _use_ros_control:=False +``` + +2. 或者启动ROS控制器 + +```python +rosrun limo_description test_mujoco.py _use_ros_control:=True +``` + +3. 启动成功后可以看到Mojuco界面，使用上下左右键或者8、2、4、6键进行控制如果使用ROS控制器，还需要启动键盘控制节点 + +```python +rosrun teleop_twist_keyboard teleop_twist_keyboard.py +``` + +4. 在RVIZ中同步小车车轮运动 + +```python +roslaunch limo_description display_models.launch +``` + diff --git a/third_party/GraspGen/README.md b/third_party/GraspGen/README.md new file mode 100644 index 0000000000000000000000000000000000000000..478e74263bc46be76a08493b7cc62d33428d254c --- /dev/null +++ b/third_party/GraspGen/README.md @@ -0,0 +1,169 @@ +# GrabGen-位姿生成与抓取 + +本文通过SAM3与位姿生成工具，实现了任意物体的识别、分割、位姿生成与抓取。 + +## 仓库 + +- GraspGen:[https://github.com/vanstrong12138/GraspGen](https://github.com/vanstrong12138/GraspGen) +- Agilex-Collge:[https://github.com/agilexrobotics/Agilex-College/tree/master](https://github.com/agilexrobotics/Agilex-College/tree/master) + +## 硬件要求 + +- x86桌面平台 +- 显存不少于16G的英伟达显卡 +- realsense + +### 项目部署平台 + +- Ubuntu24.04 +- ROS jazzy +- RTX 5090 +- NVIDIA Driver Version 570.195.03 +- CUDA Version 12.8 + +1. 安装NVIDIA显卡驱动 +```bash +sudo apt update +sudo apt upgrade +sudo add-apt-repository ppa:graphics-drivers/ppa +sudo apt update +sudo apt install nvidia-driver-570 +#重启 +reboot +``` + +1. 安装CUDA Toolkit 12.8 + +- 先前往[NVIDIA官网](https://developer.nvidia.com/cuda-12-8-1-download-archive?target_os=Linux&target_arch=x86_64&Distribution=Ubuntu&target_version=24.04&target_type=runfile_local)下载CUDA的runfile文件 +![alt text](doc/cuda.png) + +- 执行安装命令 +```bash +wget https://developer.download.nvidia.com/compute/cuda/12.8.1/local_installers/cuda_12.8.1_570.124.06_linux.run +sudo sh cuda_12.8.1_570.124.06_linux.run +``` +- 安装时取消勾选第一项driver，因为我们第一步已经安装过显卡驱动了 + +3. 添加环境变量 +```bash +echo 'export PATH=/usr/local/cuda-12.8/bin:$PATH' >> ~/.bashrc +echo 'export LD_LIBRARY_PATH=/usr/local/cuda-12.8/lib64:$LD_LIBRARY_PATH' >> ~/.bashrc +source ~/.bashrc +``` + +4. 安装后可以执行nvcc -V查看CUDA信息 +```bash +nvcc -V +``` + +5. 安装cuDnn +- 去[NVIDIA官网](https://developer.nvidia.com/cudnn-downloads?target_os=Linux&target_arch=x86_64&Distribution=Agnostic&cuda_version=12&Configuration=Full)下载cuDnn的tar文件，解压后对文件进行拷贝 +![alt text](doc/cudnn.jpg) + +- 解压后执行下面的命令把cuDNN拷贝到CUDA的安装目录下 +```bash +sudo cp cuda/include/cudnn*.h /usr/local/cuda/include +sudo cp cuda/lib/libcudnn* /usr/local/cuda/lib64 +sudo chmod a+r /usr/local/cuda/include/cudnn*.h /usr/local/cuda/lib64/libcudnn* +``` + +1. 安装TensorRT，去[NVIDIA官网](https://developer.nvidia.com/nvidia-tensorrt-8x-download)下载TensorRT的tar文件，解压后对文件进行拷贝 +![alt text](doc/tensorrt.png) + +- 解压后执行下面的命令把TensorRT拷贝到/usr/local目录下 + +```bash +#解压 +tar -xvf TensorRT-10.16.0.72.Linux.x86_64-gnu.cuda-12.9.tar.gz + +#进入TensorRT-10.16.0.72.Linux.x86_64-gnu.cuda-12.9 +cd TensorRT-10.16.0.72.Linux.x86_64-gnu.cuda-12.9/ + +#拷贝到/usr/local目录下 +sudo mv TensorRT-10.16.0.72/ /usr/local/ +``` + +- 测试TensorRT是否安装成功 +```bash +#进入MNIST手写数字识别的目录下 +cd /usr/local/TensorRT-10.16.0.72/samples/sampleOnnxMNIST + +#编译 +make + +#在/usr/local/TensorRT-10.16.0.72/bin找到可执行文件sample_onnx_mnist +cd /usr/local/TensorRT-10.16.0.72/bin +./sample_onnx_mnist +``` + +### SAM3部署 + +- Python 3.12 or higher +- PyTorch 2.7 or higher +- CUDA-compatible GPU with CUDA 12.6 or higher + +1. 创建conda虚拟环境 +```bash +conda create -n sam3 python=3.12 +conda deactivate +conda activate sam3 +``` + +2. 安装与cuda版本兼容的pytorch +```bash +# 50系列显卡推荐用cuda12.8 torch2.8 +# CUDA 12.8 +# numpy建议降级到<1.23 +pip install torch==2.8.0 torchvision==0.23.0 torchaudio==2.8.0 --index-url https://download.pytorch.org/whl/cu128 + +cd sam3 + +pip install -e . + +``` + +2. 模型下载 + 1. 提交表格获取HugginFace模型下载资格[https://huggingface.co/facebook/sam3](https://huggingface.co/facebook/sam3) + 2. 国内镜像站搜索 + +### 机械臂驱动部署 +项目发布的是target_pose末端位姿，可以手动修改为其他机械臂 + +1. 以PiPER机械臂为例 +```bash +pip install python-can + +git clone https://github.com/agilexrobotics/pyAgxArm.git + +cd pyAgxArm +pip install . +``` + +## 克隆 + +- 克隆此项目到本地 + +```bash +cd YOUR_PATH + +git clone -b ros2_jazzy_version https://github.com/AgilexRobotics/GraspGen.git +``` + +## 运行 + +1. 抓取节点 +```bash +python YOUR_PATH/sam3/realsense-sam.py --prompt "目标物体英文名称" +``` + +2. 执行抓取任务 + +``` plaintext +A=主臂零力 D=普通模式+记录位姿 S=回零 X=复现位姿 Q=夹爪开 E=夹爪合 p=点云/抓取 t=改提示词 g=下发抓取 Esc=退出 +``` + +3. 自动抓取任务 +```bash +python YOUR_PATH/sam3/realsense-sam.py --prompt "目标物体英文名称" --auto +``` + diff --git a/third_party/tuntunclaw/.env.example b/third_party/tuntunclaw/.env.example new file mode 100644 index 0000000000000000000000000000000000000000..200b05661878b64a85fd1625cd1e23f45b78c46c --- /dev/null +++ b/third_party/tuntunclaw/.env.example @@ -0,0 +1,24 @@ +# Option A: OpenAI-compatible provider +OPENAI_API_KEY=your_api_key +OPENAI_BASE_URL= +VLM_MODEL=qwen-vl-plus + +# Option B: Gemini via OpenAI-compatible endpoint +# GEMINI_API_KEY=your_gemini_key +# GEMINI_BASE_URL=https://generativelanguage.googleapis.com/v1beta/openai/ +# GEMINI_MODEL=gemini-3-flash + +# OpenClaw web + inventory integration +OPENCLAW_WEB_HOST=127.0.0.1 +OPENCLAW_WEB_PORT=8000 +OPENCLAW_PUBLIC_BASE_URL=http://127.0.0.1:8000 + +# Feishu notification for low-stock alerts +OPENCLAW_FEISHU_APP_ID= +OPENCLAW_FEISHU_APP_SECRET= +OPENCLAW_FEISHU_NOTIFY_TARGET= +OPENCLAW_FEISHU_NOTIFY_RECEIVE_ID_TYPE=chat_id +OPENCLAW_FEISHU_NOTIFY_ENABLED=1 + +# Optional collaboration webhook for your own robot backend +OPENCLAW_ROBOT_WEBHOOK_URL= diff --git a/third_party/tuntunclaw/.gitignore b/third_party/tuntunclaw/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..0768b5ec45cc4e990f6db468796faad2a6ba4c49 --- /dev/null +++ b/third_party/tuntunclaw/.gitignore @@ -0,0 +1,53 @@ +# Python +__pycache__/ +*.py[cod] +*.pyo +*.pyd +.pytest_cache/ +.mypy_cache/ +.ruff_cache/ + +# Virtual environments and local config +.env +.env.* +!.env.example +.venv/ +venv/ + +# Large local artifacts +sam_b.pt +*.tar +*.ckpt +*.pth +*.pt + +# Runtime outputs +temp/ +trash/ +logs/ +MJDATA.TXT +debug_*.png +mask*.png +robocasa_scene_*.png +*.layout_poses.json +*.view.json + +# Local state +*.log +*.tmp +*.bak + +# OS / editor +.DS_Store +Thumbs.db +.vscode/ +.idea/ + +# Private tooling not included in the open-source release +scene_layout_editor.py +SCENE_LAYOUT_EDITOR_README.md + +# Large assets hosted on Hugging Face +assets/fig.png +manipulator_grasp/assets/target_basket_medium/materials/textures/texture.png +manipulator_grasp/assets/libero_basket/texture.png diff --git a/third_party/tuntunclaw/README.md b/third_party/tuntunclaw/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a25c220debd2fc72ddc5d60caf0be5aa965b2d3a --- /dev/null +++ b/third_party/tuntunclaw/README.md @@ -0,0 +1,203 @@ +# TuntunClaw + +
+ fig1 +
+ +# 囤囤钳 TuntunClaw + +囤囤钳（TuntunClaw）是一款面向真实家庭生活场景打造的全屋具身家庭小助手。项目基于 OpenClaw 人工智能操作系统构建，将自然语言交互、视觉理解、目标分割、抓取推理、MuJoCo 仿真执行与网页端实时可视化整合到同一条工作链路中，用于展示“从一句中文指令到机械臂完成家庭物资整理任务”的完整闭环。 + +## 1. 项目背景与定位 + +在快节奏的现代生活中，家庭物资的管理，例如记住琐碎物品的存放位置、时刻留意日常消耗品的余量，往往会成为人类隐形的认知负担。传统的智能家居设备虽然能够执行单点、明确的命令，却普遍缺乏主动为人类分忧的“管家意识”，也缺乏与人类自然交流、自然协作的能力。 + +为了将人类从繁琐的记忆与记录工作中解放出来，本项目立足于真实家庭生活赛道，依托 OpenClaw 人工智能操作系统，打造了一款名为“囤囤钳”的全屋具身家庭小助手。它不仅是一个执行物理动作的机器人系统，更是一个懂生活、能与人类自然交流的家庭伙伴。通过陪伴式的语音互动与全屋物资的智能化统筹，它致力于接管家庭中的后勤琐事，重塑温馨、便捷、自然的未来家庭生活方式。 + +从系统定位上看，囤囤钳并不是单一的抓取演示程序，而是一个围绕 OpenClaw 展开的家庭服务型具身智能应用原型。OpenClaw 在这里承担的是底层智能操作系统与能力底座的角色，而囤囤钳则面向真实家庭需求，围绕“找物、整理、归位、补货提醒、自然交互”这些生活化任务进行体验设计与能力编排。 + +## 2. 项目亮点 + +### 2.1 面向家庭场景的自然交互 + +系统支持直接输入中文自然语言任务，例如： + +- `请把巧克力放到盘里` +- `将菜板上的苹果放置有苹果的架子上保存` +- `请把玻璃杯扔到地上`（系统支持安全交互，OpenClaw 会直接拒绝这种指令。） + +用户不需要记忆复杂指令格式，只需要用接近日常表达的方式下达任务，系统就会自动完成任务解析、目标理解和动作执行。 + +### 2.2 OpenClaw 驱动的具身执行链路 + +本项目将 OpenClaw 的交互式智能操作理念延伸到家庭物资管理场景，在统一系统中串联起： + +- 自然语言命令输入 +- VLM 目标理解 +- SAM 目标分割 +- GraspNet 抓取候选推理 +- MuJoCo 中的机械臂动作执行 +- 网页端实时可视化反馈 + +这使得囤囤钳既具备“懂指令”的能力，也具备“真正去做”的能力。 + +### 2.3 面向演示与展示优化的前端 + +网页端提供完整的任务展示界面，包括： + +- 中文指令输入区 +- 快捷预设按钮 +- 场景实时预览 +- 执行时间线 +- 调试输出区 + +因此，项目不仅适合本地开发调试，也适合面向比赛、答辩、展示和视频录制。 + +### 2.4 连续任务执行 + +系统支持连续任务工作流。后一条命令会在前一条命令执行后的场景状态上继续运行，而不是每次都重置仿真环境。 + +例如： + +1. 先执行 `请把巧克力放到盘里` +2. 巧克力完成放置后保留在盘中 +3. 再执行 `将菜板上的苹果放置有苹果的架子上保存` +4. 第二条任务会基于第一条任务完成后的场景继续执行 + +这一能力对于“家庭整理”类任务尤其重要，因为真实家庭中的整理过程本身就是连续的。 + +## 3. 系统架构 + +当前系统可以概括为四层： + +1. 交互展示层 +2. Web 服务与会话层 +3. 感知理解层 +4. 仿真执行层 + +```mermaid +flowchart TD + A["前端页面
frontend/index.html + frontend/app.js"] --> B["FastAPI 入口
main.py"] + B --> C["会话状态管理
SessionRecord + SSE"] + C --> D["MuJoCo 调度器
MuJoCoCommandRunner"] + D --> E["环境与渲染
UR5GraspEnv"] + D --> F["VLM / SAM 分割
vlm_process.py"] + D --> G["抓取与放置推理
grasp_process.py"] + G --> H["GraspNet / 点云 / IK / 动作执行"] + C --> I["库存与通知
workflow_hooks.py / inventory.py / integrations.py"] +``` + +这套架构使 OpenClaw 能力从底层执行扩展到完整的家庭服务交互闭环。 + +## 4. 核心能力 + +### 4.1 中文任务理解 + +系统能够将自然语言任务解析为结构化执行目标，例如： + +- 源物体 +- 目标容器 +- 空间关系 +- 是否批量执行 + +### 4.2 目标分割与定位 + +系统结合 VLM 与 SAM，在仿真相机图像中定位目标物体与放置区域，并生成中间分割结果用于调试与可视化。 + +### 4.3 抓取推理 + +系统通过 GraspNet 对目标区域点云生成抓取候选，并结合碰撞过滤、几何约束和场景先验，选择适合当前任务的抓取姿态。 + +### 4.4 家庭场景中的专用逻辑 + +项目针对家庭常见整理任务做了专门适配。例如： + +- 巧克力会优先识别特定包装目标 +- 苹果会区分菜板上的苹果与果篮中的苹果 +- 放置位置不是简单的“架子中心”，而是更符合生活整理逻辑的容器内部有效区域 + +### 4.5 物资管理与提醒链路 + +除了机械臂动作执行，系统还引入了库存与通知能力，围绕家庭日常物资管理进行扩展。这使囤囤钳不仅能“搬运物体”，还具备了面向家庭后勤管理的服务潜力。 + +## 5. 项目目录 + +```text +tuntunclaw/ +├─ frontend/ # Web 前端 +├─ manipulator_grasp/ # MuJoCo 环境、机械臂与场景资源 +├─ graspnet-baseline/ # GraspNet 相关代码 +├─ openclaw_like/ # 轻量策略与交互封装 +├─ main.py # FastAPI 与统一入口 +├─ grasp_process.py # 抓取、放置、IK、动作执行 +├─ vlm_process.py # VLM / SAM 分割逻辑 +├─ inventory.py # 库存状态管理 +├─ integrations.py # 外部通知与 webhook +├─ workflow_hooks.py # 成功任务后的业务副作用 +└─ 项目开发流程与系统架构说明.md # 详细架构说明 +``` + +## 6. 快速开始 + +### 6.1 环境 + +当前默认环境为 `vlm_grasp311`。 + +### 6.2 大文件资产 + +为了避免 Git 仓库过大，以下大文件放在 Hugging Face： + +- `assets/fig.png` +- `manipulator_grasp/assets/target_basket_medium/materials/textures/texture.png` +- `manipulator_grasp/assets/libero_basket/texture.png` + +首次运行前，在项目根目录执行： + +```powershell +python scripts/download_large_assets.py +``` + +脚本会从 [Datawhale/tuntunclaw-assets](https://huggingface.co/datasets/Datawhale/tuntunclaw-assets) 下载这些文件并恢复到原始路径。如果 Hugging Face 仓库需要鉴权，请先设置 `HF_TOKEN` 或 `HUGGINGFACE_HUB_TOKEN`。 + +### 6.3 启动 + +```powershell +micromamba run -n vlm_grasp311 python main.py +``` + +启动后默认打开： + +```text +http://127.0.0.1:8000/ +``` + +### 6.4 示例任务 + +可以直接在网页端输入： + +```text +请把巧克力放到盘里 +将菜板上的苹果放置有苹果的架子上保存 +请把玻璃杯扔到地上（系统支持安全交互，OpenClaw 会直接拒绝这种指令。） +``` + +## 7. 典型演示流程 + +一个完整的家庭整理演示可以这样进行： + +1. 在网页端输入 `请把巧克力放到盘里` +2. 系统完成巧克力识别、抓取与放置 +3. 再输入 `将菜板上的苹果放置有苹果的架子上保存` +4. 系统继续在当前场景中完成苹果整理 +5. 前端同步展示执行过程、当前状态与调试信息 + +这一流程体现的不是单一物体抓取，而是“面向生活任务的连续协助”。 + + + +--- + +囤囤钳希望呈现的不是“机械臂完成一个动作”这么简单，而是一个更贴近家庭日常生活的具身智能愿景：让机器人真正成为家庭成员的协作伙伴，承担那些繁琐、琐碎、需要长期记忆和重复劳动的后勤工作。 + +在这一意义上，囤囤钳是 OpenClaw 面向家庭场景的一次具体落地尝试，也是具身智能从实验室演示走向生活服务的一步探索。 + diff --git a/third_party/tuntunclaw/build_robocasa_scene.py b/third_party/tuntunclaw/build_robocasa_scene.py new file mode 100644 index 0000000000000000000000000000000000000000..e348e910d85ebec8f2f644cddf11b701d5934600 --- /dev/null +++ b/third_party/tuntunclaw/build_robocasa_scene.py @@ -0,0 +1,522 @@ +import copy +import sys +import xml.etree.ElementTree as ET +from pathlib import Path + + +WORKSPACE_ROOT = Path(r"C:\oc\openclaw_ws") +ASCII_REPO_ROOT = Path(r"C:\openclaw_ascii") +PROJECT_ROOT = Path(r"C:\oc\VLM_Grasp_Interactive") +ROBOCASA_XML = ( + PROJECT_ROOT + / "manipulator_grasp" + / "assets" + / "scenes" + / "robocasa_layout51_style34_full.xml" +) +TEMPLATE_XML = ( + PROJECT_ROOT + / "manipulator_grasp" + / "assets" + / "scenes" + / "scene_simple_table.xml" +) +OUTPUT_XML = ( + PROJECT_ROOT + / "manipulator_grasp" + / "assets" + / "scenes" + / "scene_robocasa_layout51_style34.xml" +) +OBJECTS_REPO_ROOT = ASCII_REPO_ROOT if ASCII_REPO_ROOT.exists() else WORKSPACE_ROOT +ROBOCASA_OBJECTS_ROOT = ( + OBJECTS_REPO_ROOT + / "sim" + / "robocasa" + / "robocasa" + / "models" + / "assets" + / "objects" +) +TABLE_SURFACE_Z = 0.92 +ROBOCASA_APPLE_MODEL = ( + ROBOCASA_OBJECTS_ROOT / "aigen_objs" / "apple" / "apple_0" / "model.xml" +) +ROBOCASA_PLATE_MODEL = ( + ROBOCASA_OBJECTS_ROOT / "objaverse" / "plate" / "plate_4" / "model.xml" +) +ADDITIONAL_OBJECTS = [ + { + "instance": "DigitalScale", + "model": ROBOCASA_OBJECTS_ROOT + / "lightwheel" + / "digital_scale" + / "DigitalScale004" + / "model.xml", + "pos_xy": (4.18, -3.44), + "euler": "0 0 0.25", + }, + { + "instance": "FlourBag", + "model": ROBOCASA_OBJECTS_ROOT + / "lightwheel" + / "flour_bag" + / "FlourBag008" + / "model.xml", + "pos_xy": (3.86, -3.46), + "euler": "0 0 0.55", + }, + { + "instance": "FlowerVase", + "model": ROBOCASA_OBJECTS_ROOT + / "lightwheel" + / "flower_vase" + / "FlowerVase002" + / "model.xml", + "pos_xy": (4.92, -3.43), + "euler": "0 0 0.0", + }, + { + "instance": "FruitBowl", + "model": ROBOCASA_OBJECTS_ROOT + / "lightwheel" + / "fruit_bowl" + / "FruitBowl001" + / "model.xml", + "pos_xy": (3.60, -3.70), + "euler": "0 0 0.1", + }, + { + "instance": "GlassCup", + "model": ROBOCASA_OBJECTS_ROOT + / "lightwheel" + / "glass_cup" + / "GlassCup016" + / "model.xml", + "pos_xy": (4.45, -3.43), + "euler": "0 0 0.0", + }, + { + "instance": "KnifeBlock", + "model": ROBOCASA_OBJECTS_ROOT + / "lightwheel" + / "knife_block" + / "KnifeBlock019" + / "model.xml", + "pos_xy": (4.90, -3.68), + "euler": "0 0 -0.2", + }, + { + "instance": "MugTree", + "model": ROBOCASA_OBJECTS_ROOT + / "lightwheel" + / "mug_tree" + / "MugTree020" + / "model.xml", + "pos_xy": (3.63, -3.46), + "euler": "0 0 0.15", + }, + { + "instance": "Shelf", + "model": ROBOCASA_OBJECTS_ROOT + / "lightwheel" + / "tiered_shelf" + / "Shelf010" + / "model.xml", + "pos_xy": (5.00, -3.83), + "euler": "0 0 -1.57", + }, +] + + +def ensure_robocasa_scene(): + if ROBOCASA_XML.exists(): + return + + sys.path.insert(0, str(WORKSPACE_ROOT / "sim" / "robosuite")) + sys.path.insert(0, str(WORKSPACE_ROOT / "sim" / "robocasa")) + + from robocasa.models.scenes.kitchen_arena import KitchenArena + from robosuite.models.tasks import ManipulationTask + + arena = KitchenArena(layout_id=51, style_id=34, clutter_mode=0) + model = ManipulationTask( + mujoco_arena=arena, + mujoco_robots=[], + mujoco_objects=list(arena.fixtures.values()), + ) + model.save_model(str(ROBOCASA_XML), pretty=False) + + +def unique_key(elem): + return (elem.tag, elem.get("name"), elem.get("file")) + + +def append_unique_children(dst_parent, src_parent): + seen = {unique_key(child) for child in dst_parent} + for child in src_parent: + key = unique_key(child) + if key in seen: + continue + dst_parent.append(copy.deepcopy(child)) + seen.add(key) + + +def remove_matching_children(parent, predicate): + for child in list(parent): + if predicate(child): + parent.remove(child) + + +def strip_robocasa_debug_visuals(node): + for child in list(node): + if child.tag == "geom": + name = child.get("name", "") + if "_reg_" in name or name.startswith("reg_") or name.endswith("_tray"): + node.remove(child) + continue + if child.tag == "site": + name = child.get("name", "") + if ( + name.endswith("_default_site") + or "_int_" in name + or "_ext_" in name + or name.endswith("_p2") + ): + node.remove(child) + continue + strip_robocasa_debug_visuals(child) + + +def parse_vec(value): + return [float(v) for v in value.split()] + + +def absolutize_asset_files(node, base_dir): + for elem in list(node.iter()): + file_attr = elem.get("file") + if not file_attr: + continue + file_path = Path(file_attr) + resolved_path = None + if file_path.is_absolute(): + if file_path.exists(): + resolved_path = file_path + else: + candidate = base_dir / file_path + if candidate.exists(): + resolved_path = candidate + + if resolved_path is not None: + elem.set("file", str(resolved_path)) + continue + + parent = None + for maybe_parent in node.iter(): + if elem in list(maybe_parent): + parent = maybe_parent + break + if parent is not None: + parent.remove(elem) + + valid_texture_names = { + child.get("name") for child in node if child.tag == "texture" and child.get("name") + } + remove_matching_children( + node, + lambda child: child.tag == "material" + and child.get("texture") + and child.get("texture") not in valid_texture_names, + ) + + +def collect_class_defaults(default_node): + class_defaults = {} + if default_node is None: + return class_defaults + for default in default_node.findall(".//default"): + class_name = default.get("class") + if not class_name: + continue + class_defaults[class_name] = {} + geom = default.find("geom") + site = default.find("site") + if geom is not None: + class_defaults[class_name]["geom"] = dict(geom.attrib) + if site is not None: + class_defaults[class_name]["site"] = dict(site.attrib) + return class_defaults + + +def apply_class_defaults(node, class_defaults): + for elem in node.iter(): + class_name = elem.attrib.pop("class", None) + if not class_name: + continue + defaults = class_defaults.get(class_name, {}) + elem_defaults = defaults.get(elem.tag, {}) + for key, value in elem_defaults.items(): + elem.attrib.setdefault(key, value) + + +def strip_object_helper_geoms(node): + for child in list(node): + if child.tag == "geom": + class_name = child.get("class", "") + name = child.get("name", "") + if class_name in {"region", "spawn"} or name.startswith("reg_") or name in { + "liquid", + "reg_int", + }: + node.remove(child) + continue + if child.tag == "site": + node.remove(child) + continue + strip_object_helper_geoms(child) + + +def prefix_body_names(node, prefix): + for elem in node.iter(): + name = elem.get("name") + if not name: + continue + elem.set("name", f"{prefix}_{name}") + + +def prefix_asset_names(asset_node, body_node, prefix): + name_map = {} + for elem in asset_node.iter(): + if elem.tag not in {"mesh", "material", "texture"}: + continue + name = elem.get("name") + if not name: + continue + new_name = f"{prefix}_{name}" + name_map[(elem.tag, name)] = new_name + elem.set("name", new_name) + + ref_attrs = { + "geom": ("mesh", "material"), + "material": ("texture",), + } + for node in (asset_node, body_node): + for elem in node.iter(): + for attr in ref_attrs.get(elem.tag, ()): + value = elem.get(attr) + if not value: + continue + key_tag = "texture" if attr == "texture" else attr + new_value = name_map.get((key_tag, value)) + if new_value: + elem.set(attr, new_value) + + +def import_object_body(asset_parent, model_path, instance_name, pos_xy, euler=None): + obj_tree = ET.parse(model_path) + obj_root = obj_tree.getroot() + obj_asset = copy.deepcopy(obj_root.find("asset")) + class_defaults = collect_class_defaults(obj_root.find("default")) + object_body = obj_root.find("./worldbody/body/body[@name='object']") + body = copy.deepcopy(object_body) + absolutize_asset_files(obj_asset, model_path.parent) + prefix_asset_names(obj_asset, body, instance_name) + append_unique_children(asset_parent, obj_asset) + bbox = object_body.find("./geom[@name='reg_bbox']") + if bbox is None: + raise RuntimeError(f"reg_bbox not found in {model_path}") + bbox_pos = parse_vec(bbox.get("pos")) + bbox_size = parse_vec(bbox.get("size")) + min_z = bbox_pos[2] - bbox_size[2] + body_z = TABLE_SURFACE_Z - min_z + + prefix_body_names(body, instance_name) + body.set("name", instance_name) + body.set("pos", f"{pos_xy[0]:.6f} {pos_xy[1]:.6f} {body_z:.6f}") + if euler is not None: + body.set("euler", euler) + body.attrib.pop("quat", None) + strip_object_helper_geoms(body) + apply_class_defaults(body, class_defaults) + return body + + +def import_free_object_body(asset_parent, model_path, instance_name, pos_xy, euler=None): + obj_tree = ET.parse(model_path) + obj_root = obj_tree.getroot() + obj_asset = copy.deepcopy(obj_root.find("asset")) + class_defaults = collect_class_defaults(obj_root.find("default")) + object_body = obj_root.find("./worldbody/body/body[@name='object']") + body = copy.deepcopy(object_body) + absolutize_asset_files(obj_asset, model_path.parent) + prefix_asset_names(obj_asset, body, instance_name) + append_unique_children(asset_parent, obj_asset) + bbox = object_body.find("./geom[@name='reg_bbox']") + if bbox is None: + raise RuntimeError(f"reg_bbox not found in {model_path}") + bbox_pos = parse_vec(bbox.get("pos")) + bbox_size = parse_vec(bbox.get("size")) + min_z = bbox_pos[2] - bbox_size[2] + body_z = TABLE_SURFACE_Z - min_z + 0.002 + + prefix_body_names(body, instance_name) + body.set("name", instance_name) + body.set("pos", f"{pos_xy[0]:.6f} {pos_xy[1]:.6f} {body_z:.6f}") + if euler is not None: + body.set("euler", euler) + body.attrib.pop("quat", None) + body.insert( + 0, + ET.Element( + "joint", + {"name": f"{instance_name}_joint", "type": "free", "damping": "0.1"}, + ), + ) + strip_object_helper_geoms(body) + apply_class_defaults(body, class_defaults) + return body + + +def remove_children(parent): + for child in list(parent): + parent.remove(child) + + +def set_body_pose(body, pos, quat=None, euler=None): + body.set("pos", " ".join(f"{v:.6f}" for v in pos)) + if quat is not None: + body.set("quat", quat) + body.attrib.pop("euler", None) + if euler is not None: + body.set("euler", euler) + body.attrib.pop("quat", None) + + +def build_scene(): + ensure_robocasa_scene() + + robo_tree = ET.parse(ROBOCASA_XML) + robo_root = robo_tree.getroot() + template_tree = ET.parse(TEMPLATE_XML) + root = template_tree.getroot() + + root.set("model", "scene_robocasa_layout51_style34") + + compiler = root.find("compiler") + compiler.set("inertiagrouprange", "0 0") + + size = root.find("size") + if size is None: + size = ET.Element("size") + root.insert(list(root).index(root.find("option")) + 1, size) + size.set("nconmax", "5000") + size.set("njmax", "5000") + + statistic = root.find("statistic") + statistic.set("center", "4.45 -2.90 1.30") + statistic.set("extent", "5.20") + statistic.set("meansize", "0.08") + + visual = root.find("visual") + remove_children(visual) + global_node = ET.SubElement(visual, "global") + global_node.set("azimuth", "145") + global_node.set("elevation", "-22") + global_node.set("offheight", "1280") + global_node.set("offwidth", "1280") + + for include in root.findall("include"): + if include.get("file") == "../universal_robots_ur5e/ur5e.xml": + include.set("file", "../universal_robots_ur5e/ur5e_robocasa.xml") + + asset = root.find("asset") + remove_matching_children( + asset, + lambda child: child.tag == "texture" + and child.get("builtin") in {"gradient", "checker"}, + ) + remove_matching_children( + asset, + lambda child: child.tag == "material" and child.get("name") == "groundplane", + ) + append_unique_children(asset, robo_root.find("asset")) + + worldbody = root.find("worldbody") + template_worldbody = ET.parse(TEMPLATE_XML).getroot().find("worldbody") + + remove_children(worldbody) + robo_worldbody = robo_root.find("worldbody") + for child in robo_worldbody: + name = child.get("name", "") + if name in {"left_eef_target", "right_eef_target"}: + continue + if name.startswith("stool_"): + continue + worldbody.append(copy.deepcopy(child)) + + strip_robocasa_debug_visuals(worldbody) + + camera = ET.Element( + "camera", + { + "name": "cam", + "mode": "targetbody", + "target": "island_island_group_1_main", + "pos": "4.65 -5.55 2.15", + }, + ) + worldbody.append(camera) + + mocap = template_worldbody.find("./body[@name='mocap']") + set_body_pose(mocap, (4.05, -4.02, 0.92)) + worldbody.append(copy.deepcopy(mocap)) + + custom_positions = { + "Banana": ((4.52, -3.54, 1.04), "0 1 0 0", None), + "Hammer": ((4.70, -3.69, 1.04), "0 0 1 0", None), + "Knife": ((4.62, -3.79, 1.04), None, "0 0 0"), + "Duck": ((4.82, -3.84, 1.04), None, "0 0 2.2"), + } + for name, (pos, quat, euler) in custom_positions.items(): + body = template_worldbody.find(f"./body[@name='{name}']") + set_body_pose(body, pos, quat=quat, euler=euler) + worldbody.append(copy.deepcopy(body)) + + worldbody.append( + import_free_object_body( + asset, + ROBOCASA_APPLE_MODEL, + "Apple", + (4.28, -3.46), + euler="0 0 0.35", + ) + ) + + worldbody.append( + import_object_body( + asset, + ROBOCASA_PLATE_MODEL, + "Plate", + (4.74, -3.50), + euler="0 0 0", + ) + ) + + for spec in ADDITIONAL_OBJECTS: + worldbody.append( + import_object_body( + asset, + spec["model"], + spec["instance"], + spec["pos_xy"], + euler=spec.get("euler"), + ) + ) + + tree = ET.ElementTree(root) + tree.write(OUTPUT_XML, encoding="utf-8", xml_declaration=False) + print(OUTPUT_XML) + + +if __name__ == "__main__": + build_scene() diff --git a/third_party/tuntunclaw/camera_view.py b/third_party/tuntunclaw/camera_view.py new file mode 100644 index 0000000000000000000000000000000000000000..bd9467db8088892fbc6161a178c2f03fa92eabfc --- /dev/null +++ b/third_party/tuntunclaw/camera_view.py @@ -0,0 +1,45 @@ +import json +from pathlib import Path + + +def view_config_path(scene_path: str | Path) -> Path: + scene_path = Path(scene_path) + return scene_path.with_name(scene_path.stem + ".view.json") + + +def load_view_config(scene_path: str | Path): + config_path = view_config_path(scene_path) + if not config_path.exists(): + return None + try: + data = json.loads(config_path.read_text(encoding="utf-8")) + lookat = data.get("lookat") + if not isinstance(lookat, list) or len(lookat) != 3: + return None + return { + "lookat": [float(v) for v in lookat], + "azimuth": float(data["azimuth"]), + "elevation": float(data["elevation"]), + "distance": float(data["distance"]), + } + except Exception: + return None + + +def save_view_config( + scene_path: str | Path, + *, + lookat, + azimuth: float, + elevation: float, + distance: float, +) -> Path: + config_path = view_config_path(scene_path) + payload = { + "lookat": [float(v) for v in lookat], + "azimuth": float(azimuth), + "elevation": float(elevation), + "distance": float(distance), + } + config_path.write_text(json.dumps(payload, indent=2), encoding="utf-8") + return config_path diff --git a/third_party/tuntunclaw/environment-py311.mamba.yml b/third_party/tuntunclaw/environment-py311.mamba.yml new file mode 100644 index 0000000000000000000000000000000000000000..16572bf8493239a009034b2a6a941a587edf60bd --- /dev/null +++ b/third_party/tuntunclaw/environment-py311.mamba.yml @@ -0,0 +1,13 @@ +name: vlm_grasp311 +channels: + - conda-forge + - pytorch + - nvidia +dependencies: + - python=3.11 + - pip + - cmake + - ninja + - cudatoolkit + - pip: + - -r requirements-py311.txt diff --git a/third_party/tuntunclaw/frontend/README.md b/third_party/tuntunclaw/frontend/README.md new file mode 100644 index 0000000000000000000000000000000000000000..5ea7ba5bc066e529e2c35daaa7dbca91ebdeadc8 --- /dev/null +++ b/third_party/tuntunclaw/frontend/README.md @@ -0,0 +1,27 @@ +# 前端说明 + +这里是 OpenClaw 的静态网页前端。 + +## 文件 + +- `index.html` +- `styles.css` +- `app.js` + +## 使用方式 + +你可以直接在浏览器里打开 `index.html`，也可以通过仓库根目录的 `main.py` +启动一个本地 FastAPI 服务后访问网页。 + +默认状态是 mock 模式。以后要接真实后端时，可以通过顶部的 `API` 按钮设置后端基址。 +前端预期会调用： + +- `POST /api/command` +- `GET /api/session/:id` +- `GET /api/session/:id/events` + +## 说明 + +- 页面采用深色背景和高亮文字。 +- 命令输入支持 `Enter` 提交，`Shift+Enter` 换行。 +- 已预置常用测试命令，方便快速试用。 diff --git a/third_party/tuntunclaw/frontend/app.js b/third_party/tuntunclaw/frontend/app.js new file mode 100644 index 0000000000000000000000000000000000000000..12c98ca06f484e9628a600f8277aa7116b2507fa --- /dev/null +++ b/third_party/tuntunclaw/frontend/app.js @@ -0,0 +1,1037 @@ +const STORAGE_KEY = "openclaw.apiBase"; +const DEFAULT_API_BASE = "/api"; + +const PRESETS = [ + "请把玻璃杯扔到地上", + "请把巧克力放到盘里", + "将菜板上的苹果放置有苹果的架子上保存", +]; + +const BLOCKLIST = ["self-harm", "suicide", "weapon", "bomb"]; + +const OBJECT_ALIASES = { + apple: ["apple", "pingguo", "苹果", "apple_2"], + banana: ["banana", "bananas", "xiangjiao", "香蕉"], + chocolate: ["chocolate", "choco", "chocolate bar", "巧克力", "巧克力棒", "巧克力块"], + duck: ["duck", "yellow duck", "toy duck", "duckie", "鸭子"], + hammer: ["hammer", "锤子"], + knife: ["knife", "刀", "小刀"], + plate: ["plate", "dish", "saucer", "盘子", "盘里", "盘中", "盘上"], + shelf: ["shelf", "rack", "架子", "搁架"], + glass_cup: ["glass cup", "glass", "cup", "玻璃杯", "杯子"], + flower_vase: ["flower vase", "vase", "花瓶"], +}; + +const RELATION_ALIASES = [ + { key: "in", terms: ["in", "into", "inside", "里面", "里", "放进", "放入", "放到里", "放到里面"] }, + { key: "on_top_of", terms: ["on top of", "on", "upon", "放到上", "放到桌面上", "放到盘子上", "放到盘上"] }, + { key: "next_to", terms: ["next to", "beside", "near", "旁边", "附近"] }, + { key: "left_of", terms: ["left of", "to the left of", "左边"] }, + { key: "right_of", terms: ["right of", "to the right of", "右边"] }, + { key: "in_front_of", terms: ["in front of", "front of", "前面"] }, + { key: "behind", terms: ["behind", "at the back of", "后面"] }, +]; + +const STEP_LIBRARY = { + grasp: [ + "收到用户输入", + "语言解析", + "任务调度", + "场景采集", + "抓取目标估计", + "IK 求解", + "动作执行", + "结果", + ], + pick_place: [ + "收到用户输入", + "语言解析", + "任务调度", + "目标分割", + "抓取目标估计", + "放置目标估计", + "IK 求解", + "动作执行", + "结果", + ], + teleop: ["收到用户输入", "语言解析", "任务调度", "遥操作切换", "结果"], + dance: ["收到用户输入", "语言解析", "任务调度", "轨迹回放", "结果"], + blocked: ["收到用户输入", "策略检查", "结果"], + interrupted: ["收到用户输入", "任务调度", "会话结束"], +}; + +const refs = {}; +const state = { + apiBase: readApiBase(), + connection: "mock", + envBadge: inferEnvBadge(), + mode: "idle", + sessionId: "-", + task: null, + command: "", + trace: [], + logs: [], + result: "暂无结果。", + dispatch: "等待中", + preview: null, + livePreviewUrl: "", + previewImageStatus: "idle", + inventory: { + items: [ + { + key: "chocolate", + label: "巧克力", + count: 12, + threshold: 3, + reorder_qty: 10, + unit: "块", + status: "ok", + low_stock: false, + alert_sent: false, + order_pending: false, + order_url: "", + last_updated_at: "", + last_alert_at: "", + last_alert_token: "", + last_order_at: "", + }, + ], + alerts: [], + orders: [], + history: [], + updated_at: "", + }, + isRunning: false, + stopRequested: false, + lastError: "", +}; + +const sleep = (ms) => new Promise((resolve) => window.setTimeout(resolve, ms)); + +function readApiBase() { + try { + return window.localStorage.getItem(STORAGE_KEY) || DEFAULT_API_BASE; + } catch { + return DEFAULT_API_BASE; + } +} + +function resolveApiBase(base) { + const value = (base || "").trim() || DEFAULT_API_BASE; + if (value === "/api" && window.location.origin && window.location.origin !== "null") { + return `${window.location.origin}/api`; + } + return value; +} + +function writeApiBase(value) { + const next = (value || "").trim() || DEFAULT_API_BASE; + try { + window.localStorage.setItem(STORAGE_KEY, next); + } catch { + // Ignore storage failures in file:// or restricted browser contexts. + } + state.apiBase = next; + renderConnection(); +} + +async function probeBackend() { + try { + const base = resolveApiBase(state.apiBase).replace(/\/api$/, ""); + const response = await fetch(`${base}/healthz`, { cache: "no-store" }); + if (!response.ok) { + return; + } + state.connection = "live"; + renderConnection(); + } catch { + // Keep mock mode if the backend is not running yet. + } +} + +function inferEnvBadge() { + if (window.location.protocol === "file:") { + return "本地文件"; + } + if (window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1") { + return "本地"; + } + return "开发"; +} + +function normalizeText(value) { + return (value || "").trim().toLowerCase(); +} + +function checkBlocked(command) { + const text = normalizeText(command); + return BLOCKLIST.find((token) => text.includes(token)) || ""; +} + +function extractObjects(text) { + const hits = []; + for (const [canonical, aliases] of Object.entries(OBJECT_ALIASES)) { + for (const alias of aliases) { + const idx = text.indexOf(alias); + if (idx >= 0) { + hits.push({ idx, canonical }); + break; + } + } + } + hits.sort((a, b) => a.idx - b.idx); + return [...new Set(hits.map((item) => item.canonical))]; +} + +function inferTask(command) { + const text = normalizeText(command); + if (!text) { + return { type: "idle", source: null, destination: null, relation: null }; + } + if (text === "exit" || text === "quit") { + return { type: "interrupted", source: null, destination: null, relation: null }; + } + if (text.includes("teleop") || text.includes("manual") || text.includes("keyboard") || text.includes("遥操作") || text.includes("手动")) { + return { type: "teleop", source: null, destination: null, relation: null }; + } + if (text.includes("dance") || text.includes("wave") || text.includes("跳舞") || text.includes("挥手")) { + return { type: "dance", source: null, destination: null, relation: null }; + } + + const relation = RELATION_ALIASES.find((item) => item.terms.some((term) => text.includes(term)))?.key || "place"; + const objects = extractObjects(text); + + if (objects.length >= 2 || text.includes("place") || text.includes("put") || text.includes("move") || text.includes("放") || text.includes("移")) { + return { + type: "pick_place", + source: objects[0] || "object", + destination: objects[1] || "target", + relation, + }; + } + + return { + type: "grasp", + source: objects[0] || "object", + destination: null, + relation: null, + }; +} + +function stepDetail(step, task, blockedReason) { + const parts = []; + if (task.type === "pick_place") { + parts.push(`source=${task.source}`); + parts.push(`destination=${task.destination}`); + parts.push(`relation=${task.relation}`); + } else if (task.source) { + parts.push(`target=${task.source}`); + } + if (blockedReason && step === "policy gate") { + parts.push(`blocked by ${blockedReason}`); + } + if (step === "result") { + parts.push("awaiting execution summary"); + } + return parts.join(" | ") || "queued"; +} + +function buildTrace(task, status = "pending", blockedReason = "") { + const steps = STEP_LIBRARY[task.type] || STEP_LIBRARY.grasp; + return steps.map((name, index) => ({ + name, + status: + status === "blocked" + ? index === 1 + ? "failed" + : index === 0 + ? "done" + : "pending" + : index === 0 + ? "done" + : index === 1 + ? "running" + : "pending", + detail: stepDetail(name, task, blockedReason), + })); +} + +function logLine(level, message) { + const stamp = new Date().toLocaleTimeString([], { + hour: "2-digit", + minute: "2-digit", + second: "2-digit", + }); + return `[${stamp}] ${level.toUpperCase()}: ${message}`; +} + +function setConnection(mode, label) { + state.connection = mode; + refs.connectionDot.className = `status-dot status-${mode}`; + refs.connectionLabel.textContent = label; +} + +function renderConnection() { + refs.envBadge.textContent = state.envBadge; + refs.sessionChip.textContent = `会话：${state.sessionId || "-"}`; + if (state.connection === "live") { + setConnection("live", "真实接口"); + } else if (state.connection === "fail") { + setConnection("fail", "接口离线"); + } else { + setConnection("mock", "模拟模式就绪"); + } +} + +function renderPresets() { + const chips = refs.presetList.querySelectorAll(".preset-chip"); + if (chips.length) { + chips.forEach((chip, index) => { + const preset = PRESETS[index] || chip.textContent.trim(); + chip.dataset.preset = preset; + chip.textContent = preset; + }); + return; + } + + refs.presetList.innerHTML = PRESETS + .map((preset) => ``) + .join(""); +} + +function applyPresetToInput(preset) { + refs.commandInput.value = preset; + refs.commandInput.focus(); + refs.commandInput.setSelectionRange(preset.length, preset.length); + refs.commandInput.dispatchEvent(new Event("input", { bubbles: true })); +} + +function renderTrace() { + const template = document.getElementById("trace-template"); + refs.traceList.innerHTML = ""; + + refs.traceCount.textContent = `${state.trace.length} events`; + refs.traceEmpty.style.display = state.trace.length ? "none" : "block"; + + state.trace.forEach((entry, index) => { + const node = template.content.firstElementChild.cloneNode(true); + node.querySelector(".trace-index").textContent = String(index + 1).padStart(2, "0"); + node.querySelector(".trace-name").textContent = entry.name; + node.querySelector(".trace-state").textContent = entry.status; + node.querySelector(".trace-detail").textContent = entry.detail; + node.classList.add(`is-${entry.status}`); + refs.traceList.appendChild(node); + }); +} + +function renderLogs() { + refs.logsCount.textContent = `${state.logs.length} 行`; + refs.logsView.textContent = state.logs.length ? state.logs.join("\n") : "暂无调试输出。"; +} + +function escapeHtml(value) { + return String(value ?? "") + .replace(/&/g, "&") + .replace(//g, ">") + .replace(/"/g, """) + .replace(/'/g, "'"); +} + +function renderInventory() { + const snapshot = state.inventory || {}; + const items = Array.isArray(snapshot.items) ? snapshot.items : []; + const updatedText = snapshot.updated_at ? new Date(snapshot.updated_at).toLocaleString() : "未加载"; + refs.inventoryUpdated.textContent = updatedText; + + if (!items.length) { + refs.inventoryAlert.classList.remove("hidden"); + refs.inventoryAlert.textContent = "当前没有可展示的库存数据。"; + refs.inventoryList.innerHTML = '
暂无库存记录。
'; + return; + } + + const lowItems = items.filter((item) => item.low_stock || item.status === "low_stock"); + if (lowItems.length) { + refs.inventoryAlert.classList.remove("hidden"); + refs.inventoryAlert.textContent = + `库存预警：${lowItems + .map((item) => `${item.label} 剩余 ${item.count}${item.unit}`) + .join("，")}。`; + } else { + refs.inventoryAlert.classList.add("hidden"); + refs.inventoryAlert.textContent = ""; + } + + refs.inventoryList.innerHTML = items + .map((item) => { + const low = item.low_stock || item.status === "low_stock"; + const stateText = low ? "低库存" : "正常"; + const orderUrl = item.order_url ? escapeHtml(item.order_url) : ""; + const orderButton = orderUrl + ? `一键下单` + : ""; + const orderHint = item.order_pending ? "订单处理中" : low ? "建议补货" : "库存正常"; + return ` +
+
+
${escapeHtml(item.label || item.key || "物资")}
+ ${stateText} +
+
+ 剩余 ${escapeHtml(item.count)} ${escapeHtml(item.unit || "")} + 阈值 ${escapeHtml(item.threshold)} + 补货 ${escapeHtml(item.reorder_qty)} + ${escapeHtml(orderHint)} +
+
+ 最近更新 ${escapeHtml(item.last_updated_at || snapshot.updated_at || "-")} + ${orderButton} +
+
+ `; + }) + .join(""); +} + +function figureTitle() { + if (!state.task) { + return "等待指令"; + } + if (state.mode === "running") { + return `正在处理 ${state.task.type}`; + } + if (state.mode === "failure") { + return "指令失败"; + } + if (state.mode === "interrupted") { + return "会话中断"; + } + return `任务 ${state.task.type} 完成`; +} + +function figureCopy() { + if (!state.task) { + return "提交指令后，这里会切换为实时场景数据、叠层和目标标记。"; + } + if (state.livePreviewUrl && state.previewImageStatus !== "loaded") { + return state.previewImageStatus === "error" + ? "实时画面加载失败，已回退到占位画布。" + : "实时画面正在加载中，请稍候。"; + } + const base = { + grasp: `当前流程正在跟踪单一目标：${state.task.source}。`, + pick_place: `当前流程正在将 ${state.task.source} 调度到 ${state.task.destination}，关系为 ${state.task.relation}。`, + teleop: "遥操作切换已激活。", + dance: "动作轨迹正在回放。", + interrupted: "会话已在执行前结束。", + }[state.task.type] || "场景正在更新。"; + return base; +} + +function modeNoteFor(mode) { + switch (mode) { + case "running": + return "正在实时执行。"; + case "success": + return "指令执行成功。"; + case "failure": + return "错误或策略拦截导致执行停止。"; + case "interrupted": + return "会话已关闭或中断。"; + default: + return "等待下一条指令。"; + } +} + +function taskNoteFor(task) { + if (!task) { + return "尚未解析。"; + } + if (task.type === "pick_place") { + return `${task.source} -> ${task.destination}`; + } + if (task.type === "interrupted") { + return "收到退出指令。"; + } + return `${task.type} 路由已选定。`; +} + +function renderOverlay() { + refs.overlayLayer.innerHTML = ""; + const preview = state.preview; + if ( + !preview || + !preview.boxes || + !preview.boxes.length || + (state.livePreviewUrl && state.previewImageStatus === "loaded") + ) { + return; + } + + for (const box of preview.boxes) { + const rect = document.createElement("div"); + rect.className = "box-rect"; + rect.style.left = `${box.x}%`; + rect.style.top = `${box.y}%`; + rect.style.width = `${box.w}%`; + rect.style.height = `${box.h}%`; + + const label = document.createElement("div"); + label.className = "box-label"; + label.textContent = box.label; + rect.appendChild(label); + + refs.overlayLayer.appendChild(rect); + } +} + +function makeMockPreview(task) { + if (task.type === "pick_place") { + return { + boxes: [ + { label: task.source, x: 16, y: 56, w: 18, h: 14 }, + { label: task.destination, x: 63, y: 24, w: 20, h: 16 }, + ], + }; + } + if (task.type === "grasp") { + return { + boxes: [{ label: task.source, x: 54, y: 40, w: 18, h: 16 }], + }; + } + if (task.type === "teleop") { + return { + boxes: [{ label: "teleop target", x: 42, y: 36, w: 18, h: 18 }], + }; + } + return { boxes: [] }; +} + +function renderPreview() { + refs.previewState.textContent = state.mode; + refs.modeValue.textContent = state.mode; + refs.modeNote.textContent = modeNoteFor(state.mode); + refs.taskValue.textContent = state.task ? state.task.type : "-"; + refs.taskNote.textContent = taskNoteFor(state.task); + refs.resultValue.textContent = state.result; + refs.dispatchValue.textContent = state.dispatch; + + const imageReady = Boolean(state.livePreviewUrl && state.previewImageStatus === "loaded"); + refs.previewFigure.classList.toggle("hidden", imageReady); + refs.previewImage.classList.toggle( + "hidden", + !state.livePreviewUrl || state.previewImageStatus !== "loaded" + ); + + refs.appShell.classList.toggle("running", state.mode === "running"); + refs.appShell.classList.toggle("success-state", state.mode === "success"); + refs.appShell.classList.toggle("error-state", state.mode === "failure"); + refs.appShell.classList.toggle("interrupted-state", state.mode === "interrupted"); + + if (state.livePreviewUrl) { + if (refs.previewImage.dataset.currentSrc !== state.livePreviewUrl) { + refs.previewImage.dataset.currentSrc = state.livePreviewUrl; + refs.previewImage.src = state.livePreviewUrl; + state.previewImageStatus = "loading"; + } + refs.previewImage.alt = `Scene preview for ${state.command}`; + } else { + refs.previewImage.dataset.currentSrc = ""; + state.previewImageStatus = "idle"; + } + + refs.previewFigure.querySelector(".figure-title").textContent = figureTitle(); + refs.previewFigure.querySelector(".figure-copy").textContent = figureCopy(); + refs.previewFigure.querySelector(".figure-stats").innerHTML = [ + `状态：${state.mode}`, + `轨迹：${state.trace.length} 步`, + ].join(""); + + renderOverlay(); +} + +async function refreshInventory() { + const base = resolveApiBase(state.apiBase).replace(/\/$/, ""); + if (!base) { + return; + } + try { + const response = await fetch(`${base}/inventory`, { cache: "no-store" }); + if (!response.ok) { + return; + } + const snapshot = await response.json(); + state.inventory = snapshot || state.inventory; + render(); + } catch { + // Inventory is optional when the backend is offline. + } +} + +function setState(next) { + Object.assign(state, next); + render(); +} + +function render() { + renderConnection(); + renderTrace(); + renderLogs(); + renderPreview(); + renderInventory(); +} + +function buildDebugPayload(task, trace, extra = {}) { + return { + session_id: state.sessionId, + command: state.command, + task, + trace, + state: state.mode, + api_base: state.apiBase, + ...extra, + }; +} + +function extractPreviewUrl(payload) { + const candidate = + payload.preview?.image_url || + payload.preview?.url || + payload.preview_url || + payload.image_url || + payload.imageUrl || + payload.image; + + if (!candidate || typeof candidate !== "string") { + return ""; + } + + if (/^data:|^https?:|^blob:/.test(candidate)) { + return candidate; + } + + try { + return new URL(candidate, `${window.location.href}`).toString(); + } catch { + return candidate; + } +} + +function normalizeTerminalMode(value) { + const text = String(value || "").toLowerCase(); + if (text.includes("fail") || text.includes("error")) { + return "failure"; + } + if (text.includes("interrupt") || text.includes("cancel")) { + return "interrupted"; + } + if (text.includes("run")) { + return "running"; + } + return "success"; +} + +function normalizeStepStatus(status, index, length) { + const text = String(status || "").toLowerCase(); + if (text.includes("fail") || text.includes("error") || text.includes("block") || text.includes("cancel")) return "failed"; + if (text.includes("run")) return "running"; + if (text.includes("pend")) return "pending"; + if (text.includes("done") || text.includes("ok") || text.includes("complete")) return "done"; + return index === length - 1 ? "running" : "done"; +} + +function normalizeTrace(input) { + if (!Array.isArray(input)) { + return []; + } + return input.map((step, index) => { + if (typeof step === "string") { + return { + name: step, + status: index === input.length - 1 ? "running" : "done", + detail: "", + }; + } + return { + name: step.name || step.step || `step ${index + 1}`, + status: normalizeStepStatus(step.status, index, input.length), + detail: step.detail || step.message || "", + }; + }); +} + +function extractLogs(payload) { + const logs = payload.logs || payload.debug || payload.events || []; + if (Array.isArray(logs)) { + return logs.map((entry) => (typeof entry === "string" ? entry : JSON.stringify(entry))); + } + if (typeof logs === "string") { + return logs.split(/\r?\n/).filter(Boolean); + } + return []; +} + +function previewFromPayload(payload, task) { + const preview = payload.preview || {}; + if (Array.isArray(preview.boxes) && preview.boxes.length) { + return { boxes: preview.boxes }; + } + if (task?.type === "pick_place") { + return makeMockPreview(task); + } + return preview?.boxes ? preview : makeMockPreview(task); +} + +function applyServerPayload(payload, task) { + const nextSession = payload.session_id || payload.sessionId || payload.id || state.sessionId; + const parsed = payload.parsed || payload.intent || payload.task || {}; + const steps = normalizeTrace(payload.trace || payload.steps || payload.stage_trace || []); + const terminalStatus = payload.status || payload.state || (steps.at(-1)?.status === "failed" ? "failure" : "success"); + const previewUrl = extractPreviewUrl(payload); + + state.sessionId = nextSession || state.sessionId; + state.task = { + type: parsed.type || task.type, + source: parsed.source || task.source, + destination: parsed.destination || task.destination, + relation: parsed.relation || task.relation, + }; + state.trace = steps.length ? steps : buildTrace(state.task, "running"); + state.logs = extractLogs(payload); + state.preview = previewFromPayload(payload, state.task); + state.inventory = payload.inventory || state.inventory; + if (payload.inventory_event) { + state.logs = [ + ...state.logs, + logLine("库存", `sku=${payload.inventory_event.sku || "-"} remaining=${payload.inventory_event.remaining ?? "-"}`), + ]; + } + if (previewUrl) { + if (previewUrl !== state.livePreviewUrl) { + state.previewImageStatus = "loading"; + } + state.livePreviewUrl = previewUrl; + } + state.dispatch = payload.current_step || payload.currentStep || "服务端响应"; + state.result = + payload.result || + payload.message || + (normalizeTerminalMode(terminalStatus) === "running" + ? "指令正在执行中..." + : `指令已完成，状态：${terminalStatus}`); + state.mode = normalizeTerminalMode(terminalStatus); + state.isRunning = state.mode === "running"; + render(); + + if (state.mode === "running" && state.sessionId && state.sessionId !== "-") { + maybeSubscribeToEvents(state.sessionId); + } +} + +async function tryLiveCommand(command, task) { + const base = resolveApiBase(state.apiBase).replace(/\/$/, ""); + if (!base) { + return { ok: false, reason: "默认模拟模式" }; + } + + try { + state.connection = "live"; + const response = await fetch(`${base}/command`, { + method: "POST", + headers: { + "Content-Type": "application/json", + }, + body: JSON.stringify({ + command, + session_id: state.sessionId === "-" ? null : state.sessionId, + }), + }); + + if (!response.ok) { + throw new Error(`HTTP ${response.status}`); + } + + const payload = await response.json(); + applyServerPayload(payload, task); + await refreshInventory(); + return { ok: true }; + } catch (error) { + state.connection = "mock"; + state.lastError = String(error?.message || error); + return { ok: false, reason: state.lastError }; + } +} + +function createSessionId() { + return `local-${Math.random().toString(36).slice(2, 8)}`; +} + +function buildMockSequence(command, task) { + const base = STEP_LIBRARY[task.type] || STEP_LIBRARY.grasp; + return base.map((name, index) => ({ + name, + status: index === base.length - 1 ? "done" : index === 1 ? "running" : "done", + detail: mockDetail(name, task, command), + delay: index === 0 ? 240 : index === base.length - 1 ? 220 : 360, + })); +} + +function mockDetail(step, task, command) { + const snippets = []; + if (task.source) snippets.push(`source=${task.source}`); + if (task.destination) snippets.push(`destination=${task.destination}`); + if (task.relation) snippets.push(`relation=${task.relation}`); + if (step === "language parse") snippets.push(`command="${command}"`); + if (step === "result" && task.type === "interrupted") snippets.push("closed by exit command"); + if (step === "policy gate") snippets.push("blocked by local policy"); + return snippets.join(" | ") || "处理中"; +} + +function finishInterrupted(task, logEntries) { + state.mode = "interrupted"; + state.dispatch = "会话已关闭"; + state.result = "指令已被用户中断。"; + state.trace = buildTrace({ ...task, type: "interrupted" }, "interrupted"); + state.logs = [...logEntries, logLine("警告", "会话已中断")]; + state.isRunning = false; + render(); +} + +async function runMockFlow(command, task) { + const sequence = buildMockSequence(command, task); + const logEntries = [...state.logs, logLine("模拟", "后端不可用，使用本地轨迹模拟")]; + state.logs = logEntries; + state.connection = "mock"; + state.sessionId = state.sessionId === "-" ? createSessionId() : state.sessionId; + render(); + + for (let index = 0; index < sequence.length; index += 1) { + if (state.stopRequested) { + finishInterrupted(task, logEntries); + return; + } + + const step = sequence[index]; + state.dispatch = step.name; + state.trace = state.trace.map((item, traceIndex) => { + if (traceIndex < index) { + return { ...item, status: "done" }; + } + if (traceIndex === index) { + return { ...item, status: step.status }; + } + return { ...item, status: "pending" }; + }); + state.logs = [...logEntries, logLine("trace", `${step.name}: ${step.detail}`)]; + render(); + await sleep(step.delay); + } + + const success = task.type !== "interrupted"; + state.mode = success ? "success" : "interrupted"; + state.result = success ? `已通过模拟流程完成 ${task.type}。` : "会话已关闭。"; + state.dispatch = success ? "结果" : "会话结束"; + state.trace = state.trace.map((item) => ({ ...item, status: item.status === "running" ? "done" : item.status })); + state.logs = [...logEntries, logLine("完成", success ? "模拟流程已完成" : "会话已中断")]; + state.isRunning = false; + state.livePreviewUrl = ""; + state.previewImageStatus = "idle"; + render(); + refs.commandInput.focus(); +} + +function stopCommand() { + if (!state.isRunning) { + state.mode = "idle"; + state.result = "暂无结果。"; + state.dispatch = "等待中"; + render(); + refs.commandInput.focus(); + return; + } + state.stopRequested = true; + state.result = "已请求停止。"; + state.dispatch = "正在中断"; + state.logs = [...state.logs, logLine("警告", "用户请求停止")]; + render(); + refs.commandInput.focus(); +} + +function configureApi() { + const next = window.prompt("请输入接口基址", state.apiBase); + if (next === null) { + return; + } + writeApiBase(next); + state.connection = "mock"; + state.logs = [...state.logs, logLine("信息", `接口基址已更新：${state.apiBase}`)]; + render(); + refs.commandInput.focus(); +} + +function applyLiveResponseFromEvent(event) { + try { + const data = JSON.parse(event.data); + if (!data || !data.session_id || !data.status) { + return; + } + applyServerPayload(data, state.task || inferTask(state.command)); + } catch (error) { + state.logs = [...state.logs, logLine("警告", `事件解析失败：${String(error.message || error)}`)]; + render(); + } +} + +function maybeSubscribeToEvents(sessionId) { + const base = resolveApiBase(state.apiBase).replace(/\/$/, ""); + if (!base || !sessionId || sessionId === "-") { + return; + } + try { + const source = new EventSource(`${base}/session/${sessionId}/events`); + source.onmessage = applyLiveResponseFromEvent; + source.onerror = () => { + source.close(); + }; + } catch { + // Streaming is optional. Fall back to the static response. + } +} + +async function submitCommand(value) { + const command = (value ?? refs.commandInput.value).trim(); + if (!command || state.isRunning) { + return; + } + + const blockedReason = checkBlocked(command); + const task = inferTask(command); + const traceStatus = blockedReason ? "blocked" : "running"; + const trace = buildTrace(task, traceStatus, blockedReason); + const logs = [ + logLine("信息", `已接收指令：${command}`), + logLine("信息", `接口基址：${resolveApiBase(state.apiBase)}`), + ]; + + refs.commandInput.value = command; + state.command = command; + state.task = task; + state.trace = trace; + state.logs = logs; + state.preview = makeMockPreview(task); + state.livePreviewUrl = ""; + state.previewImageStatus = "idle"; + state.mode = blockedReason ? "failure" : "running"; + state.result = blockedReason ? `已被策略关键字拦截：${blockedReason}` : "正在调度指令..."; + state.dispatch = blockedReason ? "策略检查" : "解析中"; + state.isRunning = !blockedReason; + state.stopRequested = false; + state.lastError = ""; + render(); + + if (blockedReason) { + state.logs = [...logs, logLine("警告", `策略拦截关键字：${blockedReason}`)]; + render(); + refs.commandInput.focus(); + return; + } + + const live = await tryLiveCommand(command, task); + if (live.ok) { + state.logs = [...logs, logLine("信息", "已提交到真实后端，等待仿真响应...")]; + render(); + refs.commandInput.focus(); + return; + } + + state.logs = [...logs, logLine("模拟", `后端不可用：${live.reason}`)]; + render(); + await runMockFlow(command, task); +} + +function render() { + renderConnection(); + renderTrace(); + renderLogs(); + renderPreview(); +} + +function wireEvents() { + refs.commandInput.focus(); + refs.commandInput.addEventListener("keydown", (event) => { + if (event.isComposing) { + return; + } + if (event.key === "Enter" && !event.shiftKey) { + event.preventDefault(); + submitCommand(); + } + }); + + refs.submitButton.addEventListener("click", () => submitCommand()); + refs.stopButton.addEventListener("click", stopCommand); + refs.apiButton.addEventListener("click", configureApi); + + window.addEventListener("keydown", (event) => { + if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === "enter") { + event.preventDefault(); + submitCommand(); + } + }); +} + +function bootstrap() { + refs.appShell = document.querySelector(".app-shell"); + refs.connectionDot = document.getElementById("connection-dot"); + refs.connectionLabel = document.getElementById("connection-label"); + refs.envBadge = document.getElementById("env-badge"); + refs.apiButton = document.getElementById("api-button"); + refs.sessionChip = document.getElementById("session-chip"); + refs.commandInput = document.getElementById("command-input"); + refs.submitButton = document.getElementById("submit-button"); + refs.stopButton = document.getElementById("stop-button"); + refs.presetList = document.getElementById("preset-list"); + refs.modeValue = document.getElementById("mode-value"); + refs.modeNote = document.getElementById("mode-note"); + refs.taskValue = document.getElementById("task-value"); + refs.taskNote = document.getElementById("task-note"); + refs.inventoryUpdated = document.getElementById("inventory-updated"); + refs.inventoryAlert = document.getElementById("inventory-alert"); + refs.inventoryList = document.getElementById("inventory-list"); + refs.previewState = document.getElementById("preview-state"); + refs.previewFigure = document.getElementById("preview-figure"); + refs.previewImage = document.getElementById("preview-image"); + refs.overlayLayer = document.getElementById("overlay-layer"); + refs.resultValue = document.getElementById("result-value"); + refs.dispatchValue = document.getElementById("dispatch-value"); + refs.traceCount = document.getElementById("trace-count"); + refs.traceEmpty = document.getElementById("trace-empty"); + refs.traceList = document.getElementById("trace-list"); + refs.logsCount = document.getElementById("logs-count"); + refs.logsView = document.getElementById("logs-view"); + + refs.previewImage.onload = () => { + if (refs.previewImage.dataset.currentSrc === state.livePreviewUrl && state.livePreviewUrl) { + state.previewImageStatus = "loaded"; + render(); + } + }; + refs.previewImage.onerror = () => { + if (refs.previewImage.dataset.currentSrc === state.livePreviewUrl && state.livePreviewUrl) { + state.previewImageStatus = "error"; + render(); + } + }; + + state.sessionId = "-"; + state.apiBase = resolveApiBase(state.apiBase); + renderPresets(); + probeBackend(); + refreshInventory(); + window.__openclawSubmitCommand = submitCommand; + window.__openclawApplyPreset = applyPresetToInput; + render(); +} + +bootstrap(); diff --git a/third_party/tuntunclaw/frontend/index.html b/third_party/tuntunclaw/frontend/index.html new file mode 100644 index 0000000000000000000000000000000000000000..4e603b35d3a7feb41f9af71f681686acf5ea5c6c --- /dev/null +++ b/third_party/tuntunclaw/frontend/index.html @@ -0,0 +1,396 @@ + + + + + + + OpenClaw 仿真可视化前端 + + + +
+
+ +
+
+
+ +
+
OpenClaw 仿真可视化前端
+

嵌入式机器人可视化界面

+
+
+ +
+
+ + 模拟模式就绪 +
+
+ 环境 + 本地 +
+ +
+
+ +
+
+
+
+

指令

+

发送机器人指令

+
+ 会话：- +
+ + + +
+ + + Enter 提交，Shift+Enter 换行。 +
+ +
+
快捷预设
+
+ + + +
+
+ +
+
+ 当前状态 + 空闲 + 等待下一条指令。 +
+
+ 解析任务 + - + 尚未解析。 +
+
+ +
+
+
+

库存

+

剩余物资与下单

+
+ 未加载 +
+ +
+
+
+ +
+
+
+

预览

+

场景状态画布

+
+ 空闲 +
+ +
+
+
+
+
+
+
+
+
相机画面
+
分割叠层
+
+
等待指令
+
提交指令后，这里会切换为实时场景数据、叠层和目标标记。
+
+ 状态：空闲 + 轨迹：0 步 +
+
+ +
+
+ +
+
+ 结果 + 暂无结果。 +
+
+ 调度 + 等待中 +
+
+
+ +
+
+
+

轨迹

+

执行时间线

+
+ 0 条事件 +
+ +
+
尚未执行
+

输入一条指令或点击预设，可以看到解析、调度、抓取估计和最终执行状态的动态流程。

+
    +
  • 提交后输入框会保持焦点。
    • +
  • 没有后端时也可以使用模拟模式。
    • +
  • 接入真实后端时将通过 /api/command 连接。
    • +
+
+ +
    + +
    +
    + 调试输出 + 0 行 +
    + 
    暂无调试输出。
    +
    +
    +
    +
    + + + + + + + + + + diff --git a/third_party/tuntunclaw/frontend/styles.css b/third_party/tuntunclaw/frontend/styles.css new file mode 100644 index 0000000000000000000000000000000000000000..e3b67b2cbcb7f469ea898ee62d4276d54348e841 --- /dev/null +++ b/third_party/tuntunclaw/frontend/styles.css @@ -0,0 +1,1067 @@ +:root { + color-scheme: light; + --bg: #f4f7fb; + --bg-deep: #e8eef6; + --panel: #ffffff; + --panel-strong: #f0f4fa; + --border: #d5e0ec; + --border-soft: rgba(115, 140, 165, 0.18); + --text: #182433; + --text-soft: #44576d; + --text-dim: #6b7d92; + --cyan: #44d7ff; + --cyan-soft: rgba(68, 215, 255, 0.18); + --amber: #ffb84d; + --amber-soft: rgba(255, 184, 77, 0.16); + --green: #57e389; + --green-soft: rgba(87, 227, 137, 0.16); + --red: #ff6b6b; + --red-soft: rgba(255, 107, 107, 0.16); + --shadow: 0 18px 40px rgba(40, 58, 75, 0.12); + --radius: 22px; + --radius-sm: 14px; + --line: linear-gradient(135deg, rgba(68, 215, 255, 0.16), rgba(255, 184, 77, 0.14)); + font-family: "Segoe UI", "Aptos", sans-serif; +} + +* { + box-sizing: border-box; +} + +html, +body { + min-height: 100%; +} + +body { + margin: 0; + color: var(--text); + background: + radial-gradient(circle at top left, rgba(68, 215, 255, 0.18), transparent 26%), + radial-gradient(circle at 85% 8%, rgba(255, 184, 77, 0.15), transparent 22%), + linear-gradient(180deg, var(--bg) 0%, var(--bg-deep) 100%); + overflow-x: hidden; +} + +body::before { + content: ""; + position: fixed; + inset: 0; + background-image: + linear-gradient(rgba(30, 45, 62, 0.05) 1px, transparent 1px), + linear-gradient(90deg, rgba(30, 45, 62, 0.05) 1px, transparent 1px); + background-size: 42px 42px; + mask-image: linear-gradient(180deg, rgba(0, 0, 0, 0.8), transparent 95%); + pointer-events: none; + opacity: 0.22; +} + +.ambient { + position: fixed; + width: 32rem; + height: 32rem; + border-radius: 50%; + filter: blur(72px); + opacity: 0.18; + pointer-events: none; +} + +.ambient-a { + top: -10rem; + left: -8rem; + background: rgba(68, 215, 255, 0.24); +} + +.ambient-b { + right: -11rem; + bottom: -11rem; + background: rgba(255, 184, 77, 0.2); +} + +.app-shell { + position: relative; + z-index: 1; + width: min(1600px, calc(100vw - 32px)); + margin: 20px auto 32px; + display: grid; + gap: 18px; +} + +.panel { + position: relative; + background: + linear-gradient(180deg, rgba(255, 255, 255, 0.85), transparent 28%), + var(--panel); + border: 1px solid var(--border); + border-radius: var(--radius); + box-shadow: var(--shadow); + backdrop-filter: blur(10px); + overflow: hidden; + isolation: isolate; + transition: + border-color 180ms ease, + box-shadow 180ms ease, + transform 180ms ease, + background 180ms ease; +} + +.panel::before { + content: ""; + position: absolute; + inset: -1px; + border-radius: inherit; + background: linear-gradient( + 135deg, + rgba(68, 215, 255, 0), + rgba(68, 215, 255, 0) 35%, + rgba(68, 215, 255, 0.12) 52%, + rgba(255, 184, 77, 0.08) 72%, + rgba(68, 215, 255, 0) + ); + opacity: 0; + filter: blur(12px); + transition: opacity 180ms ease, transform 180ms ease; + pointer-events: none; + z-index: 0; +} + +.panel > * { + position: relative; + z-index: 1; +} + +.panel:hover { + border-color: rgba(68, 215, 255, 0.5); + box-shadow: + 0 0 0 1px rgba(68, 215, 255, 0.1), + 0 18px 44px rgba(40, 58, 75, 0.1), + 0 0 28px rgba(68, 215, 255, 0.12); + transform: translateY(-2px); +} + +.panel:hover::before { + opacity: 1; + transform: scale(1.01); +} + +.panel:hover .section-tag, +.panel:hover .info-label, +.panel:hover .status-item-label, +.panel:hover .input-label, +.panel:hover .preset-title { + color: #4b6177; +} + +.panel:hover .panel-head h2, +.panel:hover .brand-copy h1 { + color: #1f3143; + text-shadow: 0 0 10px rgba(68, 215, 255, 0.08); +} + +.topbar { + display: flex; + align-items: center; + justify-content: space-between; + gap: 16px; + padding: 18px 22px; +} + +.brand { + display: flex; + align-items: center; + gap: 16px; + min-width: 0; +} + +.logo-mark { + width: 46px; + height: 46px; + display: grid; + place-items: center; + border-radius: 14px; + background: linear-gradient(180deg, rgba(245, 249, 253, 0.96), rgba(232, 239, 247, 0.98)); + border: 1px solid var(--border); + box-shadow: + inset 0 1px 0 rgba(255, 255, 255, 0.04), + 0 0 0 1px rgba(68, 215, 255, 0.08); + flex: 0 0 auto; + overflow: hidden; +} + +.logo-mark img { + width: 100%; + height: 100%; + object-fit: cover; + display: block; +} + +.brand-copy { + min-width: 0; +} + +.eyebrow, +.section-tag, +.info-label, +.status-item-label, +.input-label, +.preset-title { + text-transform: uppercase; + letter-spacing: 0.16em; + font-size: 0.72rem; + color: var(--text-dim); +} + +.brand-copy h1, +.panel-head h2 { + margin: 4px 0 0; + font-family: "Microsoft YaHei", "微软雅黑", "PingFang SC", "Noto Sans CJK SC", "Segoe UI", sans-serif; + font-weight: 700; + letter-spacing: 0.02em; +} + +.brand-copy h1 { + font-size: 1.35rem; + line-height: 1.05; + letter-spacing: 0.03em; + color: #17212c; + text-shadow: + 0 1px 0 rgba(255, 255, 255, 0.82), + 0 0 10px rgba(71, 102, 134, 0.08); + font-style: normal; + font-weight: 800; + -webkit-text-stroke: 0.2px rgba(23, 33, 44, 0.08); +} + +.brand-copy .eyebrow { + color: #8aa0b6; + font-weight: 600; + letter-spacing: 0.18em; +} + +.panel-head h2 { + font-size: 1.02rem; +} + +.status-strip { + display: flex; + align-items: center; + gap: 10px; + flex-wrap: wrap; + justify-content: flex-end; +} + +.status-card, +.ghost-button, +.mini-chip, +.badge, +.preset-chip, +.secondary-button, +.primary-button { + border-radius: 999px; + border: 1px solid var(--border-soft); + background: rgba(247, 250, 253, 0.96); + color: var(--text); +} + +.status-card { + display: inline-flex; + align-items: center; + gap: 8px; + padding: 10px 14px; + font-size: 0.92rem; +} + +.status-label.dim { + color: var(--text-dim); +} + +.status-dot { + width: 10px; + height: 10px; + border-radius: 50%; + box-shadow: 0 0 0 4px rgba(255, 255, 255, 0.04); +} + +.status-live { + background: var(--green); + box-shadow: 0 0 16px rgba(87, 227, 137, 0.45); +} + +.status-mock { + background: var(--amber); + box-shadow: 0 0 16px rgba(255, 184, 77, 0.42); +} + +.status-fail { + background: var(--red); + box-shadow: 0 0 16px rgba(255, 107, 107, 0.42); +} + +.badge, +.mini-chip { + padding: 8px 12px; + font-size: 0.75rem; + letter-spacing: 0.1em; + text-transform: uppercase; +} + +.badge { + color: var(--cyan); +} + +.ghost-button, +.secondary-button, +.primary-button { + cursor: pointer; + padding: 10px 15px; + font: inherit; + transition: + transform 0.15s ease, + border-color 0.2s ease, + background 0.2s ease, + box-shadow 0.2s ease; +} + +.ghost-button:hover, +.secondary-button:hover { + border-color: rgba(68, 215, 255, 0.45); + background: rgba(236, 243, 250, 1); +} + +.primary-button { + background: linear-gradient(135deg, rgba(229, 245, 255, 0.98), rgba(224, 235, 248, 0.98)); + border-color: rgba(68, 215, 255, 0.28); + box-shadow: 0 0 0 1px rgba(68, 215, 255, 0.06); +} + +.primary-button:hover { + transform: translateY(-1px); + box-shadow: + 0 12px 28px rgba(68, 215, 255, 0.12), + 0 0 0 1px rgba(68, 215, 255, 0.14); +} + +.secondary-button { + color: var(--text-soft); +} + +.dashboard { + display: grid; + grid-template-columns: minmax(280px, 1fr) minmax(340px, 1.2fr) minmax(320px, 0.95fr); + gap: 18px; +} + +.control-panel, +.preview-panel, +.trace-panel { + padding: 20px; + display: flex; + flex-direction: column; + gap: 18px; + min-height: 640px; +} + +.panel-head { + display: flex; + align-items: flex-start; + justify-content: space-between; + gap: 14px; +} + +.input-wrap { + display: grid; + gap: 10px; +} + +.input-wrap textarea { + width: 100%; + resize: vertical; + min-height: 148px; + border-radius: 18px; + border: 1px solid var(--border); + background: + linear-gradient(180deg, rgba(255, 255, 255, 0.9), transparent 26%), + var(--panel-strong); + color: var(--text); + padding: 16px 16px 18px; + outline: none; + font: inherit; + line-height: 1.55; + box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.03); +} + +.input-wrap textarea:focus { + border-color: rgba(68, 215, 255, 0.55); + box-shadow: + 0 0 0 4px rgba(68, 215, 255, 0.08), + inset 0 1px 0 rgba(255, 255, 255, 0.4); +} + +.input-actions { + display: flex; + gap: 10px; + flex-wrap: wrap; + align-items: center; +} + +.hint { + color: var(--text-dim); + font-size: 0.88rem; +} + +.preset-block { + display: grid; + gap: 12px; +} + +.preset-list { + display: flex; + flex-wrap: wrap; + gap: 10px; +} + +.preset-chip { + cursor: pointer; + padding: 9px 13px; + font-size: 0.9rem; + color: var(--text-soft); + background: rgba(241, 246, 251, 0.98); +} + +.preset-chip:hover { + border-color: rgba(255, 184, 77, 0.42); + color: var(--text); + box-shadow: 0 0 0 1px rgba(255, 184, 77, 0.08); +} + +.info-grid { + display: grid; + gap: 12px; + grid-template-columns: repeat(2, minmax(0, 1fr)); +} + +.inventory-panel { + display: grid; + gap: 14px; +} + +.inventory-head { + align-items: center; +} + +.inventory-alert { + padding: 14px 16px; + border-radius: 18px; + border: 1px solid rgba(255, 184, 77, 0.28); + background: linear-gradient(180deg, rgba(255, 247, 230, 0.98), rgba(255, 240, 214, 0.94)); + color: #6c4c12; + line-height: 1.6; +} + +.inventory-list { + display: grid; + gap: 12px; +} + +.inventory-card { + border-radius: 18px; + border: 1px solid var(--border-soft); + background: + linear-gradient(180deg, rgba(255, 255, 255, 0.96), transparent 24%), + rgba(244, 248, 252, 0.98); + padding: 14px 16px; + display: grid; + gap: 10px; +} + +.inventory-card.low-stock { + border-color: rgba(255, 107, 107, 0.35); + box-shadow: 0 0 0 1px rgba(255, 107, 107, 0.08); +} + +.inventory-card-head { + display: flex; + align-items: center; + justify-content: space-between; + gap: 12px; +} + +.inventory-name { + font-size: 1rem; + font-weight: 700; + color: var(--text); +} + +.inventory-meta { + color: var(--text-dim); + font-size: 0.88rem; + display: flex; + flex-wrap: wrap; + gap: 10px; +} + +.inventory-stats { + display: flex; + gap: 8px; + flex-wrap: wrap; +} + +.inventory-pill { + display: inline-flex; + align-items: center; + gap: 6px; + padding: 6px 10px; + border-radius: 999px; + font-size: 0.78rem; + border: 1px solid rgba(68, 215, 255, 0.14); + background: rgba(246, 250, 253, 0.96); + color: var(--text-soft); +} + +.inventory-pill.low { + border-color: rgba(255, 107, 107, 0.26); + background: rgba(255, 240, 240, 0.96); + color: #a34848; +} + +.inventory-pill.ok { + border-color: rgba(87, 227, 137, 0.22); + background: rgba(238, 252, 243, 0.96); + color: #2f7d52; +} + +.inventory-actions { + display: flex; + gap: 10px; + flex-wrap: wrap; +} + +.inventory-order-button { + display: inline-flex; + align-items: center; + justify-content: center; + text-decoration: none; +} + +.inventory-empty { + padding: 12px 14px; + border-radius: 16px; + border: 1px dashed rgba(115, 140, 165, 0.28); + color: var(--text-dim); + background: rgba(247, 250, 253, 0.8); +} + +.info-card { + border-radius: 18px; + padding: 16px; + background: + linear-gradient(180deg, rgba(255, 255, 255, 0.95), transparent 24%), + rgba(244, 248, 252, 0.96); + border: 1px solid var(--border-soft); + display: grid; + gap: 8px; + transition: + border-color 180ms ease, + box-shadow 180ms ease, + transform 180ms ease, + background 180ms ease; +} + +.info-card:hover { + border-color: rgba(68, 215, 255, 0.38); + box-shadow: + 0 0 0 1px rgba(68, 215, 255, 0.08), + 0 0 20px rgba(68, 215, 255, 0.08); + transform: translateY(-1px); + background: + linear-gradient(180deg, rgba(255, 255, 255, 0.98), transparent 24%), + rgba(238, 244, 250, 0.98); +} + +.info-card strong, +.status-item strong, +.figure-title { + font-size: 1rem; +} + +.info-note { + color: var(--text-dim); + font-size: 0.88rem; + line-height: 1.45; +} + +.preview-stage { + position: relative; + flex: 1; + min-height: 420px; + border-radius: 24px; + overflow: hidden; + border: 1px solid rgba(68, 215, 255, 0.14); + background: + radial-gradient(circle at 20% 20%, rgba(68, 215, 255, 0.12), transparent 24%), + radial-gradient(circle at 85% 22%, rgba(255, 184, 77, 0.12), transparent 22%), + linear-gradient(180deg, rgba(252, 253, 255, 1), rgba(242, 247, 252, 1)); + transition: + border-color 180ms ease, + box-shadow 180ms ease, + transform 180ms ease; +} + +.preview-stage::after { + content: ""; + position: absolute; + inset: 0; + border-radius: inherit; + background: + radial-gradient(circle at 50% 50%, rgba(68, 215, 255, 0.1), transparent 42%), + linear-gradient(135deg, rgba(68, 215, 255, 0.06), rgba(255, 184, 77, 0.03)); + opacity: 0; + transition: opacity 180ms ease; + pointer-events: none; +} + +.preview-panel:hover .preview-stage { + border-color: rgba(68, 215, 255, 0.4); + box-shadow: + 0 0 0 1px rgba(68, 215, 255, 0.14), + 0 0 28px rgba(68, 215, 255, 0.1), + 0 0 48px rgba(68, 215, 255, 0.04); + transform: translateY(-1px); +} + +.preview-panel:hover .preview-stage::after { + opacity: 1; +} + +.grid-overlay, +.glow-ring, +.overlay-layer, +.preview-image, +.preview-figure { + position: absolute; + inset: 0; +} + +.grid-overlay { + background-image: + linear-gradient(rgba(149, 175, 209, 0.08) 1px, transparent 1px), + linear-gradient(90deg, rgba(149, 175, 209, 0.08) 1px, transparent 1px); + background-size: 40px 40px; + opacity: 0.55; + mask-image: linear-gradient(180deg, rgba(0, 0, 0, 0.92), transparent 96%); +} + +.glow-ring { + background: + radial-gradient(circle at 50% 45%, rgba(68, 215, 255, 0.16), transparent 15%), + radial-gradient(circle at 48% 52%, rgba(255, 184, 77, 0.09), transparent 24%); + pointer-events: none; +} + +.robot-arm, +.scene-pod, +.scene-label { + position: absolute; +} + +.robot-arm { + background: linear-gradient(180deg, rgba(68, 215, 255, 0.24), rgba(68, 215, 255, 0.06)); + border: 1px solid rgba(68, 215, 255, 0.32); + box-shadow: 0 0 22px rgba(68, 215, 255, 0.08); +} + +.arm-a { + width: 220px; + height: 18px; + left: 7%; + top: 67%; + transform: rotate(-26deg); + border-radius: 999px; +} + +.arm-b { + width: 148px; + height: 18px; + left: 18%; + top: 56%; + transform: rotate(34deg); + border-radius: 999px; +} + +.scene-pod { + border-radius: 50%; + filter: drop-shadow(0 0 18px rgba(255, 184, 77, 0.16)); +} + +.pod-a { + width: 102px; + height: 102px; + right: 12%; + top: 18%; + background: radial-gradient(circle at 35% 35%, rgba(255, 184, 77, 0.34), rgba(255, 184, 77, 0.08)); + border: 1px solid rgba(255, 184, 77, 0.34); +} + +.pod-b { + width: 74px; + height: 74px; + left: 26%; + bottom: 18%; + background: radial-gradient(circle at 35% 35%, rgba(87, 227, 137, 0.34), rgba(87, 227, 137, 0.08)); + border: 1px solid rgba(87, 227, 137, 0.32); +} + +.pod-c { + width: 48px; + height: 48px; + left: 12%; + top: 20%; + background: radial-gradient(circle at 35% 35%, rgba(68, 215, 255, 0.34), rgba(68, 215, 255, 0.08)); + border: 1px solid rgba(68, 215, 255, 0.34); +} + +.scene-label { + padding: 8px 11px; + border-radius: 999px; + background: rgba(247, 250, 253, 0.9); + border: 1px solid rgba(68, 215, 255, 0.18); + color: var(--text-soft); + font-size: 0.8rem; + backdrop-filter: blur(6px); +} + +.label-a { + left: 16px; + bottom: 16px; +} + +.label-b { + right: 16px; + top: 16px; +} + +.preview-figure { + inset: auto 18px 18px 18px; + top: auto; + z-index: 2; + max-width: 320px; + margin-top: auto; + border-radius: 20px; + padding: 18px; + background: + linear-gradient(180deg, rgba(255, 255, 255, 0.95), transparent 28%), + rgba(245, 249, 253, 0.96); + border: 1px solid rgba(68, 215, 255, 0.14); + box-shadow: 0 18px 34px rgba(0, 0, 0, 0.34); +} + +.figure-title { + margin-bottom: 8px; +} + +.figure-copy { + color: var(--text-soft); + line-height: 1.55; + font-size: 0.95rem; +} + +.figure-stats { + display: flex; + gap: 8px; + flex-wrap: wrap; + margin-top: 14px; +} + +.figure-stat { + padding: 7px 10px; + border-radius: 999px; + background: rgba(238, 244, 250, 0.95); + color: var(--text-dim); + border: 1px solid rgba(255, 255, 255, 0.06); + font-size: 0.78rem; +} + +.preview-image { + object-fit: contain; + object-position: center center; + width: 100%; + height: 100%; + background: rgba(250, 253, 255, 0.96); +} + +.hidden { + display: none; +} + +.overlay-layer { + pointer-events: none; +} + +.box-rect { + position: absolute; + border: 1.5px solid var(--cyan); + border-radius: 12px; + background: rgba(68, 215, 255, 0.05); + box-shadow: 0 0 0 1px rgba(68, 215, 255, 0.06), 0 0 18px rgba(68, 215, 255, 0.14); +} + +.box-label { + position: absolute; + left: 0; + top: -22px; + padding: 3px 8px; + border-radius: 999px; + background: rgba(249, 251, 254, 0.95); + border: 1px solid rgba(68, 215, 255, 0.28); + color: var(--text); + font-size: 0.72rem; + white-space: nowrap; +} + +.status-row { + display: grid; + gap: 12px; + grid-template-columns: repeat(2, minmax(0, 1fr)); +} + +.status-item { + padding: 16px; + border-radius: 18px; + background: rgba(246, 249, 253, 0.98); + border: 1px solid var(--border-soft); + display: grid; + gap: 8px; +} + +.empty-state { + border: 1px dashed rgba(68, 215, 255, 0.24); + background: + linear-gradient(180deg, rgba(255, 255, 255, 0.9), transparent 24%), + rgba(247, 250, 253, 0.98); + border-radius: 20px; + padding: 20px; + color: var(--text-soft); +} + +.empty-title { + color: var(--text); + font-size: 1rem; + margin-bottom: 10px; +} + +.empty-state p { + margin: 0 0 12px; + line-height: 1.6; +} + +.empty-state ul { + margin: 0; + padding-left: 20px; + display: grid; + gap: 8px; +} + +.trace-list { + list-style: none; + margin: 0; + padding: 0; + display: grid; + gap: 12px; + flex: 1; +} + +.trace-item { + display: grid; + grid-template-columns: 32px 1fr; + gap: 12px; + align-items: start; + padding: 14px 14px 14px 12px; + border-radius: 18px; + border: 1px solid rgba(68, 215, 255, 0.1); + background: rgba(246, 249, 253, 0.98); + transition: + border-color 180ms ease, + box-shadow 180ms ease, + transform 180ms ease, + background 180ms ease; +} + +.trace-item:hover { + border-color: rgba(68, 215, 255, 0.42); + box-shadow: + 0 0 0 1px rgba(68, 215, 255, 0.08), + 0 0 22px rgba(68, 215, 255, 0.08); + transform: translateY(-1px); + background: rgba(15, 25, 34, 0.88); +} + +.trace-index { + width: 32px; + height: 32px; + border-radius: 50%; + display: grid; + place-items: center; + border: 1px solid rgba(68, 215, 255, 0.18); + color: var(--text-soft); + font-size: 0.78rem; + background: rgba(255, 255, 255, 0.03); +} + +.trace-headline { + display: flex; + justify-content: space-between; + gap: 12px; + align-items: center; +} + +.trace-name { + font-weight: 600; +} + +.trace-state { + font-size: 0.76rem; + text-transform: uppercase; + letter-spacing: 0.14em; + color: var(--text-dim); +} + +.trace-detail { + margin-top: 6px; + color: var(--text-soft); + line-height: 1.55; + font-size: 0.92rem; +} + +.trace-item.is-done { + border-color: rgba(87, 227, 137, 0.22); +} + +.trace-item.is-done .trace-index { + background: var(--green-soft); + color: var(--green); + border-color: rgba(87, 227, 137, 0.28); +} + +.trace-item.is-running { + border-color: rgba(68, 215, 255, 0.34); + box-shadow: 0 0 0 1px rgba(68, 215, 255, 0.07), 0 0 22px rgba(68, 215, 255, 0.08); + animation: pulse 1.8s ease-in-out infinite; +} + +.trace-item.is-running .trace-index { + background: var(--cyan-soft); + color: var(--cyan); + border-color: rgba(68, 215, 255, 0.3); +} + +.trace-item.is-pending .trace-index { + color: var(--text-dim); +} + +.trace-item.is-failed { + border-color: rgba(255, 107, 107, 0.26); +} + +.trace-item.is-failed .trace-index { + background: var(--red-soft); + color: var(--red); + border-color: rgba(255, 107, 107, 0.34); +} + +.logs-card { + display: grid; + gap: 12px; + padding: 16px; + border-radius: 18px; + background: rgba(246, 249, 253, 0.98); + border: 1px solid var(--border-soft); +} + +.logs-head { + display: flex; + justify-content: space-between; + gap: 10px; + align-items: center; +} + +.logs-view { + margin: 0; + min-height: 150px; + max-height: 220px; + overflow: auto; + white-space: pre-wrap; + color: #24364a; + font-size: 0.86rem; + line-height: 1.55; +} + +.running .primary-button { + box-shadow: + 0 0 0 1px rgba(68, 215, 255, 0.2), + 0 0 20px rgba(68, 215, 255, 0.08); +} + +.success-state .preview-stage { + box-shadow: 0 0 0 1px rgba(87, 227, 137, 0.1), 0 0 24px rgba(87, 227, 137, 0.08); +} + +.error-state .preview-stage { + box-shadow: 0 0 0 1px rgba(255, 107, 107, 0.14), 0 0 24px rgba(255, 107, 107, 0.08); +} + +.interrupted-state .preview-stage { + opacity: 0.82; + filter: saturate(0.72); +} + +@keyframes pulse { + 0%, + 100% { + transform: translateY(0); + } + 50% { + transform: translateY(-1px); + } +} + +@media (max-width: 1240px) { + .dashboard { + grid-template-columns: 1fr; + } + + .control-panel, + .preview-panel, + .trace-panel { + min-height: auto; + } + + .preview-stage { + min-height: 360px; + } +} + +@media (max-width: 780px) { + .app-shell { + width: min(100vw - 18px, 1600px); + margin-top: 9px; + margin-bottom: 18px; + } + + .topbar { + flex-direction: column; + align-items: stretch; + } + + .status-strip { + justify-content: flex-start; + } + + .info-grid, + .status-row { + grid-template-columns: 1fr; + } + + .panel-head { + flex-direction: column; + } +} diff --git a/third_party/tuntunclaw/grasp_process.py b/third_party/tuntunclaw/grasp_process.py new file mode 100644 index 0000000000000000000000000000000000000000..880610c89210acb3fafcbfa9cdab25b35c359fc6 --- /dev/null +++ b/third_party/tuntunclaw/grasp_process.py @@ -0,0 +1,1420 @@ +import os +import sys + +import mujoco +import numpy as np +import open3d as o3d +import spatialmath as sm +import torch +from PIL import Image +from functools import lru_cache + +ROOT_DIR = os.path.dirname(os.path.abspath(__file__)) +CHECKPOINT_PATH = os.path.join(ROOT_DIR, "temp", "logs", "log_rs", "checkpoint-rs.tar") +sys.path.append(os.path.join(ROOT_DIR, "graspnet-baseline", "models")) +sys.path.append(os.path.join(ROOT_DIR, "graspnet-baseline", "dataset")) +sys.path.append(os.path.join(ROOT_DIR, "graspnet-baseline", "utils")) +sys.path.append(os.path.join(ROOT_DIR, "manipulator_grasp")) +sys.path.append(os.path.join(ROOT_DIR, "graspnet-baseline", "graspnetAPI")) + +from manipulator_grasp.arm.motion_planning import ( + JointParameter, + QuinticVelocityParameter, + TrajectoryParameter, + TrajectoryPlanner, +) +from manipulator_grasp.utils import mj as mj_utils + +from graspnet import GraspNet, pred_decode +from graspnetAPI import GraspGroup +from collision_detector import ModelFreeCollisionDetector +from data_utils import CameraInfo, create_point_cloud_from_depth_image + + +SCENE_BODY_NAMES = { + "apple": "apple_6", + "apple_rack": "TieredBasket008", + "banana": "Banana", + # The visible SNICKERS-style chocolate bar the user points at is bar_2_1. + "chocolate": "bar_2_1", + "chocolate_bar": "bar_2_1", + "snickers": "bar_2_1", + "sponge": "sponge_7_1", + "sponge_rack": "TieredBasket008", + "hammer": "Hammer", + "knife": "Knife", + "duck": "Duck", + "plate": "Plate", + "shelf": "Shelf", +} + +SCENE_OBJECT_RADII = { + "apple": 0.035, + "apple_rack": 0.18, + "banana": 0.055, + "hammer": 0.07, + "knife": 0.07, + "duck": 0.04, + "plate": 0.10, + "sponge": 0.04, + "shelf": 0.18, + "sponge_rack": 0.18, +} + +TABLE_SURFACE_Z = float(os.getenv("OPENCLAW_TABLE_SURFACE_Z", "0.92")) +OPENCLAW_MAX_GRASP_DEPTH = float(os.getenv("OPENCLAW_MAX_GRASP_DEPTH", "6.0")) +OPENCLAW_MAX_MASK_DEPTH = float(os.getenv("OPENCLAW_MAX_MASK_DEPTH", "6.0")) +OPENCLAW_TRAVEL_Z = float(os.getenv("OPENCLAW_TRAVEL_Z", "1.26")) +OPENCLAW_PREGRASP_CLEARANCE = float( + os.getenv("OPENCLAW_PREGRASP_CLEARANCE", "0.12") +) +OPENCLAW_PLACE_CLEARANCE = float(os.getenv("OPENCLAW_PLACE_CLEARANCE", "0.10")) +OPENCLAW_CONTACT_TOL = float(os.getenv("OPENCLAW_CONTACT_TOL", "0.003")) +OPENCLAW_TABLE_MARGIN = float(os.getenv("OPENCLAW_TABLE_MARGIN", "0.07")) +OPENCLAW_ENABLE_SCENE_COLLISION = os.getenv( + "OPENCLAW_ENABLE_SCENE_COLLISION", "0" +).strip().lower() in {"1", "true", "yes"} + +ROBOT_ROOT_BODIES = ("ur5e_base", "2f85_base") +ISLAND_BODY_NAME = "island_island_group_1_main" +STATIC_TABLETOP_OBSTACLES = { + "Shelf", + "MugTree", + "KnifeBlock", + "FlowerVase", + "DigitalScale", + "FlourBag", + "FruitBowl", + "GlassCup", + "Plate", +} + +TABLE_SPONGE_BODIES = ("sponge_7", "sponge_7_1") +RACK_SPONGE_BODIES = ("sponge_7_2", "sponge_7_3") +RACK_APPLE_BODIES = ("apple_6_1", "apple_6_2") + + +@lru_cache(maxsize=1) +def get_net(): + net = GraspNet( + input_feature_dim=0, + num_view=300, + num_angle=12, + num_depth=4, + cylinder_radius=0.05, + hmin=-0.02, + hmax_list=[0.01, 0.02, 0.03, 0.04], + is_training=False, + ) + device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") + net.to(device) + if not os.path.exists(CHECKPOINT_PATH): + raise FileNotFoundError(f"GraspNet checkpoint not found: {CHECKPOINT_PATH}") + checkpoint = torch.load(CHECKPOINT_PATH) + net.load_state_dict(checkpoint["model_state_dict"]) + net.eval() + return net + + +def get_and_process_data(color_path, depth_path, mask_path, camera_fovy_deg: float = 45.0): + if isinstance(color_path, str): + color = np.array(Image.open(color_path), dtype=np.float32) / 255.0 + elif isinstance(color_path, np.ndarray): + color = color_path.astype(np.float32) / 255.0 + else: + raise TypeError("color_path must be a path or numpy array") + + if isinstance(depth_path, str): + depth = np.array(Image.open(depth_path)) + elif isinstance(depth_path, np.ndarray): + depth = depth_path + else: + raise TypeError("depth_path must be a path or numpy array") + + if isinstance(mask_path, str): + workspace_mask = np.array(Image.open(mask_path)) + elif isinstance(mask_path, np.ndarray): + workspace_mask = mask_path + else: + raise TypeError("mask_path must be a path or numpy array") + + height, width = color.shape[:2] + fovy = np.deg2rad(float(camera_fovy_deg)) + focal = height / (2.0 * np.tan(fovy / 2.0)) + c_x = width / 2.0 + c_y = height / 2.0 + factor_depth = 1.0 + + camera = CameraInfo(width, height, focal, focal, c_x, c_y, factor_depth) + cloud = create_point_cloud_from_depth_image(depth, camera, organized=True) + + mask = (workspace_mask > 0) & np.isfinite(depth) & (depth > 0.0) & ( + depth < OPENCLAW_MAX_GRASP_DEPTH + ) + cloud_masked = cloud[mask] + color_masked = color[mask] + + if len(cloud_masked) == 0: + valid_depth = depth[np.isfinite(depth) & (depth > 0.0)] + depth_summary = "no valid depth values" + if valid_depth.size > 0: + depth_summary = ( + f"depth range=[{valid_depth.min():.3f}, {valid_depth.max():.3f}], " + f"median={np.median(valid_depth):.3f}, " + f"threshold={OPENCLAW_MAX_GRASP_DEPTH:.3f}" + ) + raise RuntimeError( + "No valid masked point cloud points after depth filtering; " + + depth_summary + ) + + num_point = 5000 + if len(cloud_masked) >= num_point: + idxs = np.random.choice(len(cloud_masked), num_point, replace=False) + else: + idxs1 = np.arange(len(cloud_masked)) + idxs2 = np.random.choice( + len(cloud_masked), num_point - len(cloud_masked), replace=True + ) + idxs = np.concatenate([idxs1, idxs2], axis=0) + + cloud_sampled = cloud_masked[idxs] + color_sampled = color_masked[idxs] + + cloud_o3d = o3d.geometry.PointCloud() + cloud_o3d.points = o3d.utility.Vector3dVector(cloud_masked.astype(np.float32)) + cloud_o3d.colors = o3d.utility.Vector3dVector(color_masked.astype(np.float32)) + + device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") + cloud_sampled = torch.from_numpy( + cloud_sampled[np.newaxis].astype(np.float32) + ).to(device) + + end_points = { + "point_clouds": cloud_sampled, + "cloud_colors": color_sampled, + } + return end_points, cloud_o3d + + +def run_grasp_inference(color_path, depth_path, sam_mask_path=None, camera_fovy_deg: float = 45.0): + net = get_net() + end_points, cloud_o3d = get_and_process_data( + color_path, + depth_path, + sam_mask_path, + camera_fovy_deg=camera_fovy_deg, + ) + + with torch.no_grad(): + end_points = net(end_points) + grasp_preds = pred_decode(end_points) + + gg = GraspGroup(grasp_preds[0].detach().cpu().numpy()) + gg = gg.nms().sort_by_score() + + max_candidates = int(os.getenv("OPENCLAW_GRASP_MAX_CANDIDATES", "256")) + if len(gg) > max_candidates: + gg = gg[:max_candidates] + print(f"[grasp] capped candidates to top {max_candidates} before collision check.") + + collision_thresh = 0.01 + if collision_thresh > 0: + try: + mfcdetector = ModelFreeCollisionDetector( + np.asarray(cloud_o3d.points, dtype=np.float32), voxel_size=0.01 + ) + collision_mask = mfcdetector.detect( + gg, approach_dist=0.05, collision_thresh=collision_thresh + ) + gg = gg[~collision_mask] + except Exception as exc: + print(f"[grasp] collision check skipped: {exc}") + + gg = gg.sort_by_score() + + all_grasps = list(gg) + vertical = np.array([0.0, 0.0, 1.0], dtype=np.float64) + angle_threshold = np.deg2rad(30) + filtered = [] + for grasp in all_grasps: + approach_dir = grasp.rotation_matrix[:, 0] + cos_angle = np.clip(np.dot(approach_dir, vertical), -1.0, 1.0) + angle = np.arccos(cos_angle) + if angle < angle_threshold: + filtered.append(grasp) + + if len(filtered) == 0: + print("\n[warning] No vertical grasps found. Using all predictions.") + filtered = all_grasps + else: + print( + f"\n[DEBUG] Filtered {len(filtered)} grasps within 卤30掳 of vertical out of " + f"{len(all_grasps)} total predictions." + ) + + points = np.asarray(cloud_o3d.points) + object_center = np.mean(points, axis=0) if len(points) > 0 else np.zeros(3) + distances = [np.linalg.norm(grasp.translation - object_center) for grasp in filtered] + grasp_with_distances = list(zip(filtered, distances)) + max_distance = max(distances) if distances else 1.0 + + scored_grasps = [] + for grasp, distance in grasp_with_distances: + distance_score = 1 - (distance / max_distance) + composite_score = grasp.score * 0.1 + distance_score * 0.9 + scored_grasps.append((grasp, composite_score)) + + scored_grasps.sort(key=lambda item: item[1], reverse=True) + best_grasp = scored_grasps[0][0] + + new_gg = GraspGroup() + new_gg.add(best_grasp) + + visual = os.getenv("OPENCLAW_SHOW_GRASP", "0").lower() in {"1", "true", "yes"} + if visual: + grippers = new_gg.to_open3d_geometry_list() + o3d.visualization.draw_geometries([cloud_o3d, *grippers]) + + return new_gg + + +def _normalize(vec: np.ndarray) -> np.ndarray: + norm = np.linalg.norm(vec) + if norm < 1e-8: + return vec + return vec / norm + + +def _camera_info_from_depth(env, depth: np.ndarray) -> CameraInfo: + height, width = depth.shape[:2] + fovy = np.deg2rad(float(getattr(env, "camera_fovy_deg", 45.0))) + focal = height / (2.0 * np.tan(fovy / 2.0)) + c_x = width / 2.0 + c_y = height / 2.0 + return CameraInfo(width, height, focal, focal, c_x, c_y, 1.0) + + +def _camera_pose(env) -> sm.SE3: + cam_id = mujoco.mj_name2id(env.mj_model, mujoco.mjtObj.mjOBJ_CAMERA, "cam") + if cam_id < 0: + raise RuntimeError("Camera 'cam' not found in MuJoCo scene.") + cam_pos = np.array(env.mj_data.cam_xpos[cam_id], dtype=np.float64) + cam_rot = np.array(env.mj_data.cam_xmat[cam_id], dtype=np.float64).reshape(3, 3) + return sm.SE3.Rt(sm.SO3(cam_rot), cam_pos) + + +def _camera_intrinsics(env, height: int, width: int) -> CameraInfo: + fovy = np.deg2rad(float(getattr(env, "camera_fovy_deg", 45.0))) + focal = height / (2.0 * np.tan(fovy / 2.0)) + c_x = width / 2.0 + c_y = height / 2.0 + return CameraInfo(width, height, focal, focal, c_x, c_y, 1.0) + + +def mask_to_world_points(env, depth_img: np.ndarray, mask: np.ndarray) -> np.ndarray: + if mask is None: + return np.zeros((0, 3), dtype=np.float64) + + camera = _camera_intrinsics(env, depth_img.shape[0], depth_img.shape[1]) + cloud = create_point_cloud_from_depth_image(depth_img, camera, organized=True) + valid_mask = ( + (mask > 0) + & np.isfinite(depth_img) + & (depth_img > 0.0) + & (depth_img < OPENCLAW_MAX_MASK_DEPTH) + ) + if not np.any(valid_mask): + return np.zeros((0, 3), dtype=np.float64) + + camera_points = cloud[valid_mask].astype(np.float64) + camera_to_mujoco = np.diag([1.0, -1.0, -1.0]) + camera_points = (camera_to_mujoco @ camera_points.T).T + + T_wc = _camera_pose(env) + world_points = (T_wc.R @ camera_points.T).T + T_wc.t + return world_points + + +def estimate_mask_world_geometry(env, depth_img: np.ndarray, mask: np.ndarray) -> dict: + world_points = mask_to_world_points(env, depth_img, mask) + if len(world_points) == 0: + raise RuntimeError("Failed to estimate world geometry from mask.") + + centroid = np.mean(world_points, axis=0) + planar_offsets = world_points[:, :2] - centroid[:2] + planar_radii = np.linalg.norm(planar_offsets, axis=1) + planar_radius = float(np.percentile(planar_radii, 90)) if len(planar_radii) else 0.04 + z_top = float(np.percentile(world_points[:, 2], 90)) + z_bottom = float(np.percentile(world_points[:, 2], 10)) + return { + "centroid": centroid, + "planar_radius": max(planar_radius, 0.02), + "z_top": z_top, + "z_bottom": z_bottom, + "height": max(z_top - z_bottom, 0.02), + "points": world_points, + } + + +def estimate_body_image_bbox( + env, + name: str, + image_shape: tuple[int, int], + padding_px: int = 8, +) -> list[int] | None: + body_name = _resolve_scene_body_name(env, name) + if body_name is None: + return None + body_id = mujoco.mj_name2id(env.mj_model, mujoco.mjtObj.mjOBJ_BODY, body_name) + if body_id < 0: + return None + + height, width = image_shape[:2] + camera = _camera_intrinsics(env, height, width) + T_wc = _camera_pose(env) + camera_to_mujoco = np.diag([1.0, -1.0, -1.0]) + mujoco_to_camera = camera_to_mujoco + + geom_adr = int(env.mj_model.body_geomadr[body_id]) + geom_num = int(env.mj_model.body_geomnum[body_id]) + if geom_num <= 0: + return None + + x_mins, y_mins, x_maxs, y_maxs = [], [], [], [] + for geom_id in range(geom_adr, geom_adr + geom_num): + center_world = np.array(env.mj_data.geom_xpos[geom_id], dtype=np.float64) + radius = float(env.mj_model.geom_rbound[geom_id]) + if radius <= 1e-6: + size = np.array(env.mj_model.geom_size[geom_id], dtype=np.float64) + radius = float(np.linalg.norm(size)) + if radius <= 1e-6: + radius = 0.01 + + point_mujoco = T_wc.R.T @ (center_world - T_wc.t) + point_camera = mujoco_to_camera @ point_mujoco + if point_camera[2] <= 0.03: + continue + + u = camera.fx * (point_camera[0] / point_camera[2]) + camera.cx + v = camera.fy * (point_camera[1] / point_camera[2]) + camera.cy + pixel_radius = max(camera.fx * radius / point_camera[2], 2.0) + + x_mins.append(u - pixel_radius) + y_mins.append(v - pixel_radius) + x_maxs.append(u + pixel_radius) + y_maxs.append(v + pixel_radius) + + if not x_mins: + return None + + x1 = max(0, int(np.floor(min(x_mins) - padding_px))) + y1 = max(0, int(np.floor(min(y_mins) - padding_px))) + x2 = min(width - 1, int(np.ceil(max(x_maxs) + padding_px))) + y2 = min(height - 1, int(np.ceil(max(y_maxs) + padding_px))) + if x2 <= x1 or y2 <= y1: + return None + return [x1, y1, x2, y2] + + +def _resolve_scene_body_name(env, name: str) -> str | None: + hint = SCENE_BODY_NAMES.get(name, name) + if not hint: + return None + + body_names = [ + mujoco.mj_id2name(env.mj_model, mujoco.mjtObj.mjOBJ_BODY, body_id) + for body_id in range(env.mj_model.nbody) + ] + body_names = [body_name for body_name in body_names if body_name] + + for candidate in (hint, name): + if candidate and candidate in body_names: + return candidate + + hint_lower = hint.lower() + exact_ci = [body_name for body_name in body_names if body_name.lower() == hint_lower] + if exact_ci: + return exact_ci[0] + + prefix_matches = [ + body_name + for body_name in body_names + if body_name.lower().startswith(hint_lower + "_") + or body_name.lower().startswith(hint_lower) + ] + if prefix_matches: + return sorted(prefix_matches, key=len)[0] + + substring_matches = [ + body_name for body_name in body_names if hint_lower in body_name.lower() + ] + if substring_matches: + return sorted(substring_matches, key=len)[0] + + return None + + +def get_named_scene_geometry(env, name: str) -> dict | None: + body_name = _resolve_scene_body_name(env, name) + if body_name is None: + return None + geometry = _estimate_body_geometry(env, body_name) + if geometry is None: + return None + radius = SCENE_OBJECT_RADII.get(name) + if radius is not None: + geometry["planar_radius"] = max(float(radius), geometry["planar_radius"] * 0.6) + return geometry + + +def get_named_body_world_pose(env, name: str) -> tuple[np.ndarray, np.ndarray] | None: + body_name = _resolve_scene_body_name(env, name) + if body_name is None: + return None + body_id = mujoco.mj_name2id(env.mj_model, mujoco.mjtObj.mjOBJ_BODY, body_name) + if body_id < 0: + return None + # MuJoCo 3.x no longer exposes body_xpos/body_xquat arrays directly on MjData. + body_state = env.mj_data.body(body_id) + pos = np.array(body_state.xpos, dtype=np.float64) + quat = np.array(body_state.xquat, dtype=np.float64) + return pos, quat + + +def get_available_table_sponge_bodies(env) -> list[str]: + available: list[str] = [] + for name in TABLE_SPONGE_BODIES: + pose = get_named_body_world_pose(env, name) + if pose is not None: + available.append(name) + return available + + +def get_sponge_rack_slot_world(env, slot_index: int = 0) -> np.ndarray | None: + anchors: list[np.ndarray] = [] + for name in RACK_SPONGE_BODIES: + pose = get_named_body_world_pose(env, name) + if pose is not None: + anchors.append(np.array(pose[0], dtype=np.float64)) + if len(anchors) >= 2: + anchors.sort(key=lambda item: float(item[0])) + step = anchors[1] - anchors[0] + step[2] = 0.0 + slots = [ + anchors[-1] + step, + anchors[0] - step, + anchors[-1] + step * 2.0, + anchors[0] - step * 2.0, + ] + chosen = np.array(slots[min(slot_index, len(slots) - 1)], dtype=np.float64) + chosen[2] = float(np.mean([anchor[2] for anchor in anchors]) + 0.008) + return chosen + if len(anchors) == 1: + chosen = anchors[0] + np.array([0.08 * float(slot_index + 1), 0.0, 0.0], dtype=np.float64) + chosen[2] = float(anchors[0][2] + 0.008) + return chosen + rack_pose = get_named_body_world_pose(env, "sponge_rack") + if rack_pose is None: + return None + base = np.array(rack_pose[0], dtype=np.float64) + return base + np.array([0.18 + 0.08 * float(slot_index), 0.58, 0.02], dtype=np.float64) + + +def get_apple_rack_slot_world(env, slot_index: int = 0) -> np.ndarray | None: + anchors: list[np.ndarray] = [] + for name in RACK_APPLE_BODIES: + pose = get_named_body_world_pose(env, name) + if pose is not None: + anchors.append(np.array(pose[0], dtype=np.float64)) + + rack_pose = get_named_body_world_pose(env, "apple_rack") + rack_center = np.array(rack_pose[0], dtype=np.float64) if rack_pose is not None else None + + if len(anchors) >= 2: + center = np.mean(np.asarray(anchors, dtype=np.float64), axis=0) + candidates = [ + center, + center + np.array([-0.045, 0.000, 0.000], dtype=np.float64), + center + np.array([0.045, 0.000, 0.000], dtype=np.float64), + center + np.array([0.000, 0.040, 0.000], dtype=np.float64), + ] + chosen = np.array(candidates[min(slot_index, len(candidates) - 1)], dtype=np.float64) + chosen[2] = float(center[2] + 0.010) + return chosen + + if len(anchors) == 1: + chosen = np.array(anchors[0], dtype=np.float64) + if slot_index > 0: + offsets = [ + np.array([-0.045, 0.000, 0.000], dtype=np.float64), + np.array([0.045, 0.000, 0.000], dtype=np.float64), + np.array([0.000, 0.040, 0.000], dtype=np.float64), + ] + chosen = chosen + offsets[min(slot_index - 1, len(offsets) - 1)] + chosen[2] = float(anchors[0][2] + 0.010) + return chosen + + if rack_center is None: + return None + fallback = rack_center + np.array([0.17, 0.00, 0.28], dtype=np.float64) + fallback[2] = float(rack_center[2] + 0.18) + return fallback + + +def get_named_site_pose(env, site_name: str) -> tuple[np.ndarray, np.ndarray] | None: + site_id = mujoco.mj_name2id(env.mj_model, mujoco.mjtObj.mjOBJ_SITE, site_name) + if site_id < 0: + return None + pos = np.array(env.mj_data.site_xpos[site_id], dtype=np.float64) + size = np.array(env.mj_model.site_size[site_id], dtype=np.float64) + return pos, size + + +def _estimate_body_geometry(env, body_name_or_id) -> dict | None: + body_id = ( + body_name_or_id + if isinstance(body_name_or_id, int) + else mujoco.mj_name2id(env.mj_model, mujoco.mjtObj.mjOBJ_BODY, body_name_or_id) + ) + if body_id < 0: + return None + + geom_adr = int(env.mj_model.body_geomadr[body_id]) + geom_num = int(env.mj_model.body_geomnum[body_id]) + if geom_num <= 0: + return None + + centers = [] + radii = [] + for geom_id in range(geom_adr, geom_adr + geom_num): + center = np.array(env.mj_data.geom_xpos[geom_id], dtype=np.float64) + radius = float(env.mj_model.geom_rbound[geom_id]) + if radius <= 1e-6: + size = np.array(env.mj_model.geom_size[geom_id], dtype=np.float64) + radius = float(np.linalg.norm(size)) + if radius <= 1e-6: + radius = 0.01 + centers.append(center) + radii.append(radius) + + centers_np = np.asarray(centers, dtype=np.float64) + centroid = np.mean(centers_np, axis=0) + planar_radius = max( + float(np.linalg.norm(center[:2] - centroid[:2]) + radius) + for center, radius in zip(centers_np, radii) + ) + z_tops = np.array( + [float(center[2] + radius) for center, radius in zip(centers_np, radii)], + dtype=np.float64, + ) + z_bottoms = np.array( + [float(center[2] - radius) for center, radius in zip(centers_np, radii)], + dtype=np.float64, + ) + z_top = float(np.percentile(z_tops, 85)) + z_bottom = float(np.percentile(z_bottoms, 15)) + return { + "centroid": centroid, + "planar_radius": max(planar_radius, 0.015), + "z_top": z_top, + "z_bottom": z_bottom, + "height": max(z_top - z_bottom, 0.02), + "points": np.zeros((0, 3), dtype=np.float64), + } + + +def _table_workspace_bounds(env) -> tuple[tuple[float, float], tuple[float, float]]: + island_geometry = _estimate_body_geometry(env, ISLAND_BODY_NAME) + if island_geometry is not None: + body_id = mujoco.mj_name2id(env.mj_model, mujoco.mjtObj.mjOBJ_BODY, ISLAND_BODY_NAME) + geom_adr = int(env.mj_model.body_geomadr[body_id]) + geom_num = int(env.mj_model.body_geomnum[body_id]) + x_min = np.inf + x_max = -np.inf + y_min = np.inf + y_max = -np.inf + for geom_id in range(geom_adr, geom_adr + geom_num): + center = np.array(env.mj_data.geom_xpos[geom_id], dtype=np.float64) + radius = float(env.mj_model.geom_rbound[geom_id]) + if radius <= 1e-6: + size = np.array(env.mj_model.geom_size[geom_id], dtype=np.float64) + radius = float(np.linalg.norm(size)) + x_min = min(x_min, center[0] - radius) + x_max = max(x_max, center[0] + radius) + y_min = min(y_min, center[1] - radius) + y_max = max(y_max, center[1] + radius) + + margin = OPENCLAW_TABLE_MARGIN + return ( + (float(x_min + margin), float(x_max - margin)), + (float(y_min + margin), float(y_max - margin)), + ) + + return ((0.45, 1.35), (0.18, 1.02)) + + +def _robot_body_ids(env) -> set[int]: + root_ids = { + mujoco.mj_name2id(env.mj_model, mujoco.mjtObj.mjOBJ_BODY, root_name) + for root_name in ROBOT_ROOT_BODIES + } + root_ids = {root_id for root_id in root_ids if root_id >= 0} + if not root_ids: + return set() + robot_bodies = set() + for body_id in range(env.mj_model.nbody): + current = body_id + while current > 0: + if current in root_ids: + robot_bodies.add(body_id) + break + current = int(env.mj_model.body_parentid[current]) + if body_id in root_ids: + robot_bodies.add(body_id) + return robot_bodies + + +def _collect_scene_obstacles(env, exclude_names: set[str] | None = None): + exclude_names = exclude_names or set() + table_x, table_y = _table_workspace_bounds(env) + robot_body_ids = _robot_body_ids(env) + obstacles = [] + for body_id in range(1, env.mj_model.nbody): + if body_id in robot_body_ids: + continue + body_name = mujoco.mj_id2name(env.mj_model, mujoco.mjtObj.mjOBJ_BODY, body_id) + if not body_name or body_name in exclude_names: + continue + if body_name in {"mocap", ISLAND_BODY_NAME}: + continue + body_jnt_num = int(env.mj_model.body_jntnum[body_id]) + is_free_body = False + if body_jnt_num > 0: + jnt_adr = int(env.mj_model.body_jntadr[body_id]) + is_free_body = env.mj_model.jnt_type[jnt_adr] == mujoco.mjtJoint.mjJNT_FREE + if not is_free_body and body_name not in STATIC_TABLETOP_OBSTACLES: + continue + geometry = _estimate_body_geometry(env, body_id) + if geometry is None: + continue + centroid = geometry["centroid"] + if not ( + table_x[0] - 0.15 <= centroid[0] <= table_x[1] + 0.15 + and table_y[0] - 0.15 <= centroid[1] <= table_y[1] + 0.15 + ): + continue + if geometry["z_top"] < TABLE_SURFACE_Z + 0.01: + continue + if geometry["planar_radius"] > 0.45: + continue + obstacles.append( + { + "name": body_name, + "xy": centroid[:2], + "radius": geometry["planar_radius"], + "z_top": geometry["z_top"], + } + ) + return obstacles + + +def estimate_place_target_world( + env, + depth_img: np.ndarray, + destination_mask: np.ndarray, + source_mask: np.ndarray | None = None, + relation: str = "next_to", + source_name: str | None = None, + destination_name: str | None = None, +) -> np.ndarray: + destination = get_named_scene_geometry(env, destination_name or "") if destination_name else None + if destination is None: + destination = estimate_mask_world_geometry(env, depth_img, destination_mask) + if destination_name == "plate": + body_pose = get_named_body_world_pose(env, destination_name) + if body_pose is not None: + destination["centroid"] = body_pose[0].copy() + + source = get_named_scene_geometry(env, source_name or "") if source_name else None + if source is None and source_mask is not None and np.any(source_mask > 0): + source = estimate_mask_world_geometry(env, depth_img, source_mask) + + destination_xy = destination["centroid"][:2] + source_xy = source["centroid"][:2] if source is not None else None + + source_radius = source["planar_radius"] if source else 0.04 + source_height = source["height"] if source else 0.04 + gap = destination["planar_radius"] + source_radius + 0.025 + gap = float(np.clip(gap, 0.06, 0.11)) + table_x, table_y = _table_workspace_bounds(env) + + T_wc = _camera_pose(env) + camera_right = _normalize(T_wc.R[:, 0][:2]) + camera_front = destination_xy - T_wc.t[:2] + if np.linalg.norm(camera_front) < 1e-8: + camera_front = np.array([0.0, -1.0], dtype=np.float64) + camera_front = _normalize(camera_front) + + relation_vectors = { + "left_of": -camera_right, + "right_of": camera_right, + "in_front_of": camera_front, + "behind": -camera_front, + } + if relation == "in": + xy = destination_xy.copy() + place_z = destination["z_top"] + max(0.012, source_height * 0.30) + return np.array([xy[0], xy[1], place_z], dtype=np.float64) + + if relation == "on_top_of": + xy = destination_xy.copy() + place_z = destination["z_top"] + max(0.012, source_height * 0.30) + return np.array([xy[0], xy[1], place_z], dtype=np.float64) + + if relation in relation_vectors: + xy = destination_xy + gap * relation_vectors[relation] + xy[0] = np.clip(xy[0], table_x[0], table_x[1]) + xy[1] = np.clip(xy[1], table_y[0], table_y[1]) + place_z = TABLE_SURFACE_Z + max(0.018, source_height * 0.45) + return np.array([xy[0], xy[1], place_z], dtype=np.float64) + + if relation == "place": + place_z = TABLE_SURFACE_Z + max(0.018, source_height * 0.45) + return np.array([destination_xy[0], destination_xy[1], place_z], dtype=np.float64) + + directions = [ + np.array([-1.0, 0.0], dtype=np.float64), + np.array([1.0, 0.0], dtype=np.float64), + np.array([0.0, -1.0], dtype=np.float64), + np.array([0.0, 1.0], dtype=np.float64), + _normalize(np.array([-1.0, -1.0], dtype=np.float64)), + _normalize(np.array([-1.0, 1.0], dtype=np.float64)), + _normalize(np.array([1.0, -1.0], dtype=np.float64)), + _normalize(np.array([1.0, 1.0], dtype=np.float64)), + ] + + obstacles = _collect_scene_obstacles( + env, + exclude_names={ + name + for name in [SCENE_BODY_NAMES.get(source_name or ""), SCENE_BODY_NAMES.get(destination_name or "")] + if name + }, + ) + candidates = [] + for direction in directions: + xy = destination_xy + gap * direction + if not (table_x[0] <= xy[0] <= table_x[1] and table_y[0] <= xy[1] <= table_y[1]): + continue + min_clearance = 1e9 + for obstacle in obstacles: + clearance = float(np.linalg.norm(xy - obstacle["xy"]) - (gap + obstacle["radius"])) + min_clearance = min(min_clearance, clearance) + score = 0.0 + if source_xy is not None: + score = float(np.linalg.norm(xy - source_xy)) + edge_margin = min(xy[0] - table_x[0], table_x[1] - xy[0], xy[1] - table_y[0], table_y[1] - xy[1]) + if min_clearance < 0.01: + continue + candidates.append((score - 0.2 * edge_margin - 0.5 * min_clearance, xy)) + + if not candidates: + xy = destination_xy + np.array([-gap, 0.0], dtype=np.float64) + else: + xy = min(candidates, key=lambda item: item[0])[1] + + place_z = TABLE_SURFACE_Z + max(0.018, source_height * 0.45) + return np.array([xy[0], xy[1], place_z], dtype=np.float64) + + +def estimate_direct_grasp_target_world( + env, + depth_img: np.ndarray, + mask: np.ndarray, + source_name: str | None = None, +) -> tuple[np.ndarray, dict]: + geometry = None + if source_name: + geometry = get_named_scene_geometry(env, source_name) + if geometry is None: + geometry = estimate_mask_world_geometry(env, depth_img, mask) + target = geometry["centroid"].copy() + descend_fraction = 0.35 + min_descend = 0.010 + max_descend = 0.022 + if source_name == "duck": + descend_fraction = 0.12 + min_descend = 0.004 + max_descend = 0.010 + elif source_name == "apple": + descend_fraction = 0.18 + min_descend = 0.006 + max_descend = 0.014 + descend_offset = float( + np.clip(geometry["height"] * descend_fraction, min_descend, max_descend) + ) + target[2] = float( + np.clip( + geometry["z_top"] - descend_offset, + TABLE_SURFACE_Z + 0.020, + geometry["z_top"] - 0.004, + ) + ) + return target, geometry + + +def _move_joint_waypoint( + env, + robot, + action: np.ndarray, + q_target: np.ndarray, + duration: float, + frame_callback=None, + stage_name: str | None = None, +): + q_start = np.array(robot.get_joint(), dtype=np.float64) + q_target = np.array(q_target, dtype=np.float64) + parameter = JointParameter(q_start, q_target) + velocity_parameter = QuinticVelocityParameter(duration) + trajectory_parameter = TrajectoryParameter(parameter, velocity_parameter) + planner = TrajectoryPlanner(trajectory_parameter) + + total_time = duration + time_step_num = round(total_time / 0.002) + 1 + times = np.linspace(0.0, total_time, time_step_num) + frame_every = max(1, len(times) // 12) + for index, timei in enumerate(times): + if timei == 0.0: + continue + joint = planner.interpolate(timei) + robot.move_joint(joint) + action[:6] = joint + env.step(action) + if frame_callback is not None and (index % frame_every == 0 or index == len(times) - 1): + try: + frame_callback(stage_name or "motion", env) + except Exception: + pass + + +def _solve_ik_waypoint(robot, target_pose: sm.SE3, seed_q, label: str) -> np.ndarray: + previous_q = np.array(robot.get_joint(), dtype=np.float64) + try: + robot.set_joint(list(np.array(seed_q, dtype=np.float64))) + q = robot.ikine(target_pose) + finally: + robot.set_joint(list(previous_q)) + + if len(q) == 0: + raise RuntimeError(f"IK failed for {label}") + + return np.array(q, dtype=np.float64) + + +def _scratch_data_with_robot_configuration(env, q: np.ndarray) -> mujoco.MjData: + q = np.array(q, dtype=np.float64) + scratch = mujoco.MjData(env.mj_model) + scratch.qpos[:] = env.mj_data.qpos[:] + scratch.qvel[:] = env.mj_data.qvel[:] + if env.mj_model.na > 0: + scratch.act[:] = env.mj_data.act[:] + for i, joint_name in enumerate(env.joint_names): + mj_utils.set_joint_q(env.mj_model, scratch, joint_name, q[i]) + mujoco.mj_forward(env.mj_model, scratch) + return scratch + + +def _describe_robot_scene_collision( + env, + robot, + q: np.ndarray, + allowed_body_names: set[str] | None = None, +) -> str | None: + allowed_body_names = allowed_body_names or set() + robot_body_ids = _robot_body_ids(env) + scratch = _scratch_data_with_robot_configuration(env, q) + for contact_idx in range(scratch.ncon): + contact = scratch.contact[contact_idx] + body1 = int(env.mj_model.geom_bodyid[contact.geom1]) + body2 = int(env.mj_model.geom_bodyid[contact.geom2]) + if body1 not in robot_body_ids and body2 not in robot_body_ids: + continue + + if body1 in robot_body_ids and body2 in robot_body_ids: + continue + + other_body = body2 if body1 in robot_body_ids else body1 + other_name = mujoco.mj_id2name(env.mj_model, mujoco.mjtObj.mjOBJ_BODY, other_body) + if other_name in allowed_body_names: + continue + if contact.dist < OPENCLAW_CONTACT_TOL: + robot_body = body1 if body1 in robot_body_ids else body2 + robot_name = mujoco.mj_id2name( + env.mj_model, mujoco.mjtObj.mjOBJ_BODY, robot_body + ) + return f"{robot_name} vs {other_name}: dist={contact.dist:.4f}" + return None + + +def _configuration_has_robot_scene_collision( + env, + robot, + q: np.ndarray, + allowed_body_names: set[str] | None = None, +) -> bool: + return ( + _describe_robot_scene_collision( + env, + robot, + q, + allowed_body_names=allowed_body_names, + ) + is not None + ) + + +def _solve_pose_candidates( + robot, + candidates, + seed_q, + label: str, + env=None, + allowed_body_names: set[str] | None = None, +): + last_error = None + for idx, (target_pose, note) in enumerate(candidates): + try: + q = _solve_ik_waypoint(robot, target_pose, seed_q, f"{label} [{note}]") + if env is not None and OPENCLAW_ENABLE_SCENE_COLLISION: + collision_detail = _describe_robot_scene_collision( + env, + robot, + q, + allowed_body_names=allowed_body_names, + ) + if collision_detail is not None: + raise RuntimeError( + f"scene collision for {label} [{note}] -> {collision_detail}" + ) + print(f"[ik] {label}: using candidate '{note}'") + return target_pose, q + except Exception as exc: + last_error = exc + continue + + if last_error is None: + raise RuntimeError(f"No candidate poses generated for {label}") + raise last_error + + +def _build_topdown_pose_from_world( + world_point: np.ndarray, + finger_axis_hint: np.ndarray | None = None, +) -> sm.SE3: + finger_axis = np.array( + finger_axis_hint if finger_axis_hint is not None else [1.0, 0.0, 0.0], + dtype=np.float64, + ) + finger_axis[2] = 0.0 + if np.linalg.norm(finger_axis) < 1e-8: + finger_axis = np.array([1.0, 0.0, 0.0], dtype=np.float64) + finger_axis = _normalize(finger_axis) + + approach_axis = np.array([0.0, 0.0, -1.0], dtype=np.float64) + lateral_axis = np.cross(approach_axis, finger_axis) + if np.linalg.norm(lateral_axis) < 1e-8: + finger_axis = np.array([0.0, 1.0, 0.0], dtype=np.float64) + lateral_axis = np.cross(approach_axis, finger_axis) + lateral_axis = _normalize(lateral_axis) + finger_axis = _normalize(np.cross(lateral_axis, approach_axis)) + + rotation_world = np.column_stack((approach_axis, finger_axis, lateral_axis)) + return sm.SE3.Rt(sm.SO3(rotation_world), np.array(world_point, dtype=np.float64)) + + +def _build_topdown_grasp_pose(T_wc: sm.SE3, gg: GraspGroup) -> sm.SE3: + grasp_translation_camera = np.array(gg.translations[0], dtype=np.float64) + # GraspNet uses the standard CV camera frame (x right, y down, z forward), + # while MuJoCo camera poses follow an OpenGL-style frame (x right, y up, z backward). + camera_to_mujoco = np.diag([1.0, -1.0, -1.0]) + grasp_translation_world = ( + T_wc * sm.SE3.Trans(camera_to_mujoco @ grasp_translation_camera) + ).t + + raw_rotation_world = T_wc.R @ camera_to_mujoco @ gg.rotation_matrices[0] + finger_axis = raw_rotation_world[:, 1].copy() + return _build_topdown_pose_from_world(grasp_translation_world, finger_axis) + + +def _make_local_x_rotation_candidates(base_pose: sm.SE3, offsets, yaw_values): + candidates = [] + for offset in offsets: + for yaw in yaw_values: + pose = base_pose * sm.SE3(offset, 0.0, 0.0) * sm.SE3.Rx(yaw) + candidates.append((pose, f"x={offset:.3f}, rx={yaw:.3f}")) + return candidates + + +def _make_world_translation_candidates(base_pose: sm.SE3, xyz_offsets, yaw_values): + candidates = [] + base_translation = np.array(base_pose.t, dtype=np.float64) + base_rotation = sm.SO3(base_pose.R) + for offset in xyz_offsets: + offset = np.array(offset, dtype=np.float64) + for yaw in yaw_values: + pose = sm.SE3.Trans(*(base_translation + offset)) * sm.SE3(base_rotation) * sm.SE3.Rx(yaw) + candidates.append( + ( + pose, + f"world=({offset[0]:.3f},{offset[1]:.3f},{offset[2]:.3f}), rx={yaw:.3f}", + ) + ) + return candidates + + +def _compute_safe_travel_z(env, xy_points: list[np.ndarray]) -> float: + travel_z = max(OPENCLAW_TRAVEL_Z, TABLE_SURFACE_Z + 0.30) + obstacles = _collect_scene_obstacles(env) + for xy in xy_points: + for obstacle in obstacles: + clearance = np.linalg.norm(np.array(xy, dtype=np.float64) - obstacle["xy"]) + if clearance <= obstacle["radius"] + 0.20: + travel_z = max(travel_z, obstacle["z_top"] + 0.08) + return float(np.clip(travel_z, TABLE_SURFACE_Z + 0.25, 1.38)) + + +def _transit_hub_xy(env, fallback_xy: np.ndarray) -> np.ndarray: + base_id = mujoco.mj_name2id(env.mj_model, mujoco.mjtObj.mjOBJ_BODY, "ur5e_base") + if base_id < 0: + return np.array(fallback_xy, dtype=np.float64) + base_xy = np.array(env.mj_data.xpos[base_id][:2], dtype=np.float64) + table_x, table_y = _table_workspace_bounds(env) + hub_xy = base_xy + np.array([0.22, 0.34], dtype=np.float64) + hub_xy[0] = np.clip(hub_xy[0], table_x[0], table_x[1]) + hub_xy[1] = np.clip(hub_xy[1], table_y[0], table_y[1]) + return hub_xy + + +def execute_grasp( + env, + gg, + place_target_world: np.ndarray | None = None, + grasp_target_world: np.ndarray | None = None, + source_name: str | None = None, + place_mode: str | None = None, + frame_callback=None, +): + robot = env.robot + + T_wc = _camera_pose(env) + if grasp_target_world is None: + T_wo = _build_topdown_grasp_pose(T_wc, gg) + else: + T_wo = _build_topdown_pose_from_world(np.array(grasp_target_world, dtype=np.float64)) + + source_body_name = SCENE_BODY_NAMES.get(source_name or "") + finger_axis_hint = np.array(T_wo.R[:, 1], dtype=np.float64) + + action = np.zeros(7) + durations = { + "home": 0.8, + "hub": 0.9, + "hover_pick": 0.9, + "pregrasp": 0.8, + "grasp": 0.7, + "lift": 0.9, + "hover_place": 0.9, + "place": 0.8, + "retreat": 0.8, + "reset": 1.0, + } + + q0 = np.array(robot.get_joint(), dtype=np.float64) + q_home = np.array([0.0, 0.0, np.pi / 2, 0.0, -np.pi / 2, 0.0], dtype=np.float64) + _move_joint_waypoint(env, robot, action, q_home, durations["home"], frame_callback=frame_callback, stage_name="home") + + yaw_values = [0.0, np.pi / 2, -np.pi / 2, np.pi] + pick_xy = np.array(T_wo.t[:2], dtype=np.float64) + place_xy = ( + np.array(place_target_world[:2], dtype=np.float64) + if place_target_world is not None + else pick_xy.copy() + ) + travel_z = _compute_safe_travel_z(env, [pick_xy, place_xy]) + hub_xy = _transit_hub_xy(env, pick_xy) + + T_hub = _build_topdown_pose_from_world( + np.array([hub_xy[0], hub_xy[1], travel_z], dtype=np.float64), + finger_axis_hint, + ) + hub_candidates = _make_world_translation_candidates( + T_hub, + xyz_offsets=[ + (0.0, 0.0, 0.0), + (0.03, 0.0, 0.0), + (-0.03, 0.0, 0.0), + (0.0, 0.03, 0.0), + (0.0, -0.03, 0.0), + ], + yaw_values=yaw_values, + ) + T_hub, q_hub = _solve_pose_candidates( + robot, hub_candidates, q_home, "hub", env=env + ) + _move_joint_waypoint(env, robot, action, q_hub, durations["hub"], frame_callback=frame_callback, stage_name="hub") + + T_hover_pick = _build_topdown_pose_from_world( + np.array([pick_xy[0], pick_xy[1], travel_z], dtype=np.float64), + finger_axis_hint, + ) + hover_pick_candidates = _make_world_translation_candidates( + T_hover_pick, + xyz_offsets=[ + (0.0, 0.0, 0.0), + (0.02, 0.0, 0.0), + (-0.02, 0.0, 0.0), + (0.0, 0.02, 0.0), + (0.0, -0.02, 0.0), + ], + yaw_values=yaw_values, + ) + T_hover_pick, q_hover_pick = _solve_pose_candidates( + robot, hover_pick_candidates, q_hub, "hover_pick", env=env + ) + _move_joint_waypoint(env, robot, action, q_hover_pick, durations["hover_pick"], frame_callback=frame_callback, stage_name="hover_pick") + + pregrasp_z = max(T_wo.t[2] + OPENCLAW_PREGRASP_CLEARANCE, TABLE_SURFACE_Z + 0.10) + T_pregrasp = _build_topdown_pose_from_world( + np.array([pick_xy[0], pick_xy[1], pregrasp_z], dtype=np.float64), + finger_axis_hint, + ) + pregrasp_candidates = _make_world_translation_candidates( + T_pregrasp, + xyz_offsets=[ + (0.0, 0.0, 0.0), + (0.01, 0.0, 0.0), + (-0.01, 0.0, 0.0), + (0.0, 0.01, 0.0), + (0.0, -0.01, 0.0), + (0.0, 0.0, 0.02), + ], + yaw_values=yaw_values, + ) + T_pregrasp, q_pregrasp = _solve_pose_candidates( + robot, + pregrasp_candidates, + q_hover_pick, + "pregrasp", + env=env, + allowed_body_names={source_body_name} if source_body_name else None, + ) + _move_joint_waypoint(env, robot, action, q_pregrasp, durations["pregrasp"], frame_callback=frame_callback, stage_name="pregrasp") + + grasp_candidates = _make_world_translation_candidates( + T_wo, + xyz_offsets=[ + (0.0, 0.0, 0.0), + (0.006, 0.0, 0.0), + (-0.006, 0.0, 0.0), + (0.0, 0.006, 0.0), + (0.0, -0.006, 0.0), + (0.0, 0.0, 0.008), + ], + yaw_values=yaw_values, + ) + T_grasp, q_grasp = _solve_pose_candidates( + robot, + grasp_candidates, + q_pregrasp, + "grasp", + env=env, + allowed_body_names={source_body_name} if source_body_name else None, + ) + _move_joint_waypoint(env, robot, action, q_grasp, durations["grasp"], frame_callback=frame_callback, stage_name="grasp") + + for _ in range(1000): + action[-1] = min(action[-1] + 0.2, 255) + env.step(action) + if frame_callback is not None: + try: + frame_callback("grasp_close", env) + except Exception: + pass + + T_lift = _build_topdown_pose_from_world( + np.array([pick_xy[0], pick_xy[1], travel_z], dtype=np.float64), + finger_axis_hint, + ) + lift_candidates = _make_world_translation_candidates( + T_lift, + xyz_offsets=[(0.0, 0.0, 0.0), (0.0, 0.0, 0.04)], + yaw_values=yaw_values, + ) + T_lift, q_lift = _solve_pose_candidates( + robot, + lift_candidates, + q_grasp, + "lift", + env=env, + allowed_body_names={source_body_name} if source_body_name else None, + ) + _move_joint_waypoint(env, robot, action, q_lift, durations["lift"], frame_callback=frame_callback, stage_name="lift") + + if place_target_world is None: + place_xyz = np.array( + [T_grasp.t[0], T_grasp.t[1], max(T_grasp.t[2] + 0.02, TABLE_SURFACE_Z + 0.02)], + dtype=np.float64, + ) + else: + place_target_world = np.array(place_target_world, dtype=np.float64) + place_xyz = place_target_world + + T_hover_place = _build_topdown_pose_from_world( + np.array([place_xyz[0], place_xyz[1], travel_z], dtype=np.float64), + finger_axis_hint, + ) + if place_mode and place_mode.startswith("drop_above"): + hover_place_candidates = _make_world_translation_candidates( + T_hover_place, + xyz_offsets=[ + (0.0, 0.0, 0.0), + (0.0, 0.0, 0.05), + ], + yaw_values=yaw_values, + ) + else: + hover_place_candidates = _make_world_translation_candidates( + T_hover_place, + xyz_offsets=[ + (0.0, 0.0, 0.0), + (0.0, 0.0, 0.05), + (0.03, 0.0, 0.0), + (-0.03, 0.0, 0.0), + (0.0, 0.03, 0.0), + (0.0, -0.03, 0.0), + ], + yaw_values=yaw_values, + ) + T_hover_place, q_hover_place = _solve_pose_candidates( + robot, + hover_place_candidates, + q_lift, + "hover_place", + env=env, + allowed_body_names={source_body_name} if source_body_name else None, + ) + _move_joint_waypoint(env, robot, action, q_hover_place, durations["hover_place"], frame_callback=frame_callback, stage_name="hover_place") + + if place_mode == "drop_above": + preplace_z = float(place_xyz[2]) + elif place_mode == "drop_above_plate": + preplace_z = float(place_xyz[2]) + else: + preplace_z = max(place_xyz[2] + OPENCLAW_PLACE_CLEARANCE, TABLE_SURFACE_Z + 0.09) + T_preplace = _build_topdown_pose_from_world( + np.array([place_xyz[0], place_xyz[1], preplace_z], dtype=np.float64), + finger_axis_hint, + ) + if place_mode and place_mode.startswith("drop_above"): + preplace_candidates = _make_world_translation_candidates( + T_preplace, + xyz_offsets=[ + (0.0, 0.0, 0.0), + (0.0, 0.0, 0.03), + ], + yaw_values=yaw_values, + ) + else: + preplace_candidates = _make_world_translation_candidates( + T_preplace, + xyz_offsets=[ + (0.0, 0.0, 0.0), + (0.0, 0.0, 0.03), + (0.02, 0.0, 0.0), + (-0.02, 0.0, 0.0), + (0.0, 0.02, 0.0), + (0.0, -0.02, 0.0), + ], + yaw_values=yaw_values, + ) + T_preplace, q_preplace = _solve_pose_candidates( + robot, + preplace_candidates, + q_hover_place, + "preplace", + env=env, + allowed_body_names={source_body_name} if source_body_name else None, + ) + _move_joint_waypoint(env, robot, action, q_preplace, durations["place"], frame_callback=frame_callback, stage_name="preplace") + + if place_mode and place_mode.startswith("drop_above"): + place_exec_xyz = np.array([place_xyz[0], place_xyz[1], preplace_z], dtype=np.float64) + T_place = _build_topdown_pose_from_world(place_exec_xyz, finger_axis_hint) + q_place = q_preplace + else: + place_exec_xyz = np.array([place_xyz[0], place_xyz[1], place_xyz[2]], dtype=np.float64) + T_place = _build_topdown_pose_from_world(place_exec_xyz, finger_axis_hint) + place_candidates = _make_world_translation_candidates( + T_place, + xyz_offsets=[ + (0.0, 0.0, 0.0), + (0.0, 0.0, 0.03), + (0.02, 0.0, 0.0), + (-0.02, 0.0, 0.0), + (0.0, 0.02, 0.0), + (0.0, -0.02, 0.0), + ], + yaw_values=yaw_values, + ) + T_place, q_place = _solve_pose_candidates( + robot, + place_candidates, + q_preplace, + "place", + env=env, + allowed_body_names={source_body_name} if source_body_name else None, + ) + _move_joint_waypoint(env, robot, action, q_place, durations["place"], frame_callback=frame_callback, stage_name="place") + + for _ in range(1000): + action[-1] = max(action[-1] - 0.2, 0) + env.step(action) + if frame_callback is not None: + try: + frame_callback("release", env) + except Exception: + pass + + T_retreat = _build_topdown_pose_from_world( + np.array([place_xyz[0], place_xyz[1], travel_z], dtype=np.float64), + finger_axis_hint, + ) + retreat_candidates = _make_world_translation_candidates( + T_retreat, + xyz_offsets=[(0.0, 0.0, 0.0), (0.0, 0.0, 0.05)], + yaw_values=yaw_values, + ) + T_retreat, q_retreat = _solve_pose_candidates( + robot, retreat_candidates, q_place, "retreat", env=env + ) + _move_joint_waypoint(env, robot, action, q_retreat, durations["retreat"], frame_callback=frame_callback, stage_name="retreat") + + hub_return_candidates = _make_world_translation_candidates( + T_hub, + xyz_offsets=[ + (0.0, 0.0, 0.0), + (0.03, 0.0, 0.0), + (-0.03, 0.0, 0.0), + (0.0, 0.03, 0.0), + (0.0, -0.03, 0.0), + ], + yaw_values=yaw_values, + ) + _, q_hub_return = _solve_pose_candidates( + robot, hub_return_candidates, q_retreat, "hub_return", env=env + ) + _move_joint_waypoint(env, robot, action, q_hub_return, durations["hub"], frame_callback=frame_callback, stage_name="hub_return") + + _move_joint_waypoint(env, robot, action, q0, durations["reset"], frame_callback=frame_callback, stage_name="reset") + diff --git a/third_party/tuntunclaw/graspnet-baseline/.gitignore b/third_party/tuntunclaw/graspnet-baseline/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..89be87d95fab737fced160f0364059ba3eef9114 --- /dev/null +++ b/third_party/tuntunclaw/graspnet-baseline/.gitignore @@ -0,0 +1,16 @@ +**/__pycache__/** +*.ipynb +**/.ipynb_checkpoints/** +*.npy +*.npz +**/.vscode/** +**/grasp_label*/** +**/log*/** +**/dump*/** +**/build/** +*.o +*.so +*.egg +**/*.egg-info/** +logs +dataset/tolerance \ No newline at end of file diff --git a/third_party/tuntunclaw/graspnet-baseline/LICENSE b/third_party/tuntunclaw/graspnet-baseline/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..df2f94aab3779dab4beef0d9f7377934cb45b77d --- /dev/null +++ b/third_party/tuntunclaw/graspnet-baseline/LICENSE @@ -0,0 +1,160 @@ +GRASPNET-BASELINE +SOFTWARE LICENSE AGREEMENT +ACADEMIC OR NON-PROFIT ORGANIZATION NONCOMMERCIAL RESEARCH USE ONLY + +BY USING OR DOWNLOADING THE SOFTWARE, YOU ARE AGREEING TO THE TERMS OF THIS LICENSE AGREEMENT. IF YOU DO NOT AGREE WITH THESE TERMS, YOU MAY NOT USE OR DOWNLOAD THE SOFTWARE. + +This is a license agreement ("Agreement") between your academic institution or non-profit organization or self (called "Licensee" or "You" in this Agreement) and Shanghai Jiao Tong University (called "Licensor" in this Agreement). All rights not specifically granted to you in this Agreement are reserved for Licensor. + +RESERVATION OF OWNERSHIP AND GRANT OF LICENSE: +Licensor retains exclusive ownership of any copy of the Software (as defined below) licensed under this Agreement and hereby grants to Licensee a personal, non-exclusive, +non-transferable license to use the Software for noncommercial research purposes, without the right to sublicense, pursuant to the terms and conditions of this Agreement. As used in this Agreement, the term "Software" means (i) the actual copy of all or any portion of code for program routines made accessible to Licensee by Licensor pursuant to this Agreement, inclusive of backups, updates, and/or merged copies permitted hereunder or subsequently supplied by Licensor, including all or any file structures, programming instructions, user interfaces and screen formats and sequences as well as any and all documentation and instructions related to it, and (ii) all or any derivatives and/or modifications created or made by You to any of the items specified in (i). + +CONFIDENTIALITY: Licensee acknowledges that the Software is proprietary to Licensor, and as such, Licensee agrees to receive all such materials in confidence and use the Software only in accordance with the terms of this Agreement. Licensee agrees to use reasonable effort to protect the Software from unauthorized use, reproduction, distribution, or publication. + +PERMITTED USES: The Software may be used for your own noncommercial internal research purposes. You understand and agree that Licensor is not obligated to implement any suggestions and/or feedback you might provide regarding the Software, but to the extent Licensor does so, you are not entitled to any compensation related thereto. + +DERIVATIVES: You may create derivatives of or make modifications to the Software, however, You agree that all and any such derivatives and modifications will be owned by Licensor and become a part of the Software licensed to You under this Agreement. You may only use such derivatives and modifications for your own noncommercial internal research purposes, and you may not otherwise use, distribute or copy such derivatives and modifications in violation of this Agreement. + +BACKUPS: If Licensee is an organization, it may make that number of copies of the Software necessary for internal noncommercial use at a single site within its organization provided that all information appearing in or on the original labels, including the copyright and trademark notices are copied onto the labels of the copies. + +USES NOT PERMITTED: You may not distribute, copy or use the Software except as explicitly permitted herein. Licensee has not been granted any trademark license as part of this Agreement and may not use the name or mark “AlphaPose", "Shanghai Jiao Tong" or any renditions thereof without the prior written permission of Licensor. + +You may not sell, rent, lease, sublicense, lend, time-share or transfer, in whole or in part, or provide third parties access to prior or present versions (or any parts thereof) of the Software. + +ASSIGNMENT: You may not assign this Agreement or your rights hereunder without the prior written consent of Licensor. Any attempted assignment without such consent shall be null and void. + +TERM: The term of the license granted by this Agreement is from Licensee's acceptance of this Agreement by downloading the Software or by using the Software until terminated as provided below. + +The Agreement automatically terminates without notice if you fail to comply with any provision of this Agreement. Licensee may terminate this Agreement by ceasing using the Software. Upon any termination of this Agreement, Licensee will delete any and all copies of the Software. You agree that all provisions which operate to protect the proprietary rights of Licensor shall remain in force should breach occur and that the obligation of confidentiality described in this Agreement is binding in perpetuity and, as such, survives the term of the Agreement. + +FEE: Provided Licensee abides completely by the terms and conditions of this Agreement, there is no fee due to Licensor for Licensee's use of the Software in accordance with this Agreement. + +DISCLAIMER OF WARRANTIES: THE SOFTWARE IS PROVIDED "AS-IS" WITHOUT WARRANTY OF ANY KIND INCLUDING ANY WARRANTIES OF PERFORMANCE OR MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE OR PURPOSE OR OF NON-INFRINGEMENT. LICENSEE BEARS ALL RISK RELATING TO QUALITY AND PERFORMANCE OF THE SOFTWARE AND RELATED MATERIALS. + +SUPPORT AND MAINTENANCE: No Software support or training by the Licensor is provided as part of this Agreement. + +EXCLUSIVE REMEDY AND LIMITATION OF LIABILITY: To the maximum extent permitted under applicable law, Licensor shall not be liable for direct, indirect, special, incidental, or consequential damages or lost profits related to Licensee's use of and/or inability to use the Software, even if Licensor is advised of the possibility of such damage. + +EXPORT REGULATION: Licensee agrees to comply with any and all applicable +U.S. export control laws, regulations, and/or other laws related to embargoes and sanction programs administered by the Office of Foreign Assets Control. + +SEVERABILITY: If any provision(s) of this Agreement shall be held to be invalid, illegal, or unenforceable by a court or other tribunal of competent jurisdiction, the validity, legality and enforceability of the remaining provisions shall not in any way be affected or impaired thereby. + +NO IMPLIED WAIVERS: No failure or delay by Licensor in enforcing any right or remedy under this Agreement shall be construed as a waiver of any future or other exercise of such right or remedy by Licensor. + +ENTIRE AGREEMENT AND AMENDMENTS: This Agreement constitutes the sole and entire agreement between Licensee and Licensor as to the matter set forth herein and supersedes any previous agreements, understandings, and arrangements between the parties relating hereto. + + + +************************************************************************ + +THIRD-PARTY SOFTWARE NOTICES AND INFORMATION + +This project incorporates material from the project(s) listed below (collectively, "Third Party Code"). This Third Party Code is licensed to you under their original license terms set forth below. We reserves all other rights not expressly granted, whether by implication, estoppel or otherwise. + +1. PyTorch (https://github.com/pytorch/pytorch) + +THIRD-PARTY SOFTWARE NOTICES AND INFORMATION + +This project incorporates material from the project(s) listed below (collectively, "Third Party Code"). This Third Party Code is licensed to you under their original license terms set forth below. We reserves all other rights not expressly granted, whether by implication, estoppel or otherwise. + +From PyTorch: + +Copyright (c) 2016- Facebook, Inc (Adam Paszke) +Copyright (c) 2014- Facebook, Inc (Soumith Chintala) +Copyright (c) 2011-2014 Idiap Research Institute (Ronan Collobert) +Copyright (c) 2012-2014 Deepmind Technologies (Koray Kavukcuoglu) +Copyright (c) 2011-2012 NEC Laboratories America (Koray Kavukcuoglu) +Copyright (c) 2011-2013 NYU (Clement Farabet) +Copyright (c) 2006-2010 NEC Laboratories America (Ronan Collobert, Leon Bottou, Iain Melvin, Jason Weston) +Copyright (c) 2006 Idiap Research Institute (Samy Bengio) +Copyright (c) 2001-2004 Idiap Research Institute (Ronan Collobert, Samy Bengio, Johnny Mariethoz) + +From Caffe2: + +Copyright (c) 2016-present, Facebook Inc. All rights reserved. + +All contributions by Facebook: +Copyright (c) 2016 Facebook Inc. + +All contributions by Google: +Copyright (c) 2015 Google Inc. +All rights reserved. + +All contributions by Yangqing Jia: +Copyright (c) 2015 Yangqing Jia +All rights reserved. + +All contributions by Kakao Brain: +Copyright 2019-2020 Kakao Brain + +All contributions from Caffe: +Copyright(c) 2013, 2014, 2015, the respective contributors +All rights reserved. + +All other contributions: +Copyright(c) 2015, 2016 the respective contributors +All rights reserved. + +Caffe2 uses a copyright model similar to Caffe: each contributor holds +copyright over their contributions to Caffe2. The project versioning records +all such contribution and copyright details. If a contributor wants to further +mark their specific copyright on a particular contribution, they should +indicate their copyright solely in the commit message of the change when it is +committed. + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + +3. Neither the names of Facebook, Deepmind Technologies, NYU, NEC Laboratories America + and IDIAP Research Institute nor the names of its contributors may be + used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. + +2. VoteNet (https://github.com/facebookresearch/votenet) + +MIT License + +Copyright (c) Facebook, Inc. and its affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +************END OF THIRD-PARTY SOFTWARE NOTICES AND INFORMATION********** diff --git a/third_party/tuntunclaw/graspnet-baseline/README.md b/third_party/tuntunclaw/graspnet-baseline/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f379c7ae41f9880f44180883a295a5920a46b692 --- /dev/null +++ b/third_party/tuntunclaw/graspnet-baseline/README.md @@ -0,0 +1,132 @@ +# GraspNet Baseline +Baseline model for "GraspNet-1Billion: A Large-Scale Benchmark for General Object Grasping" (CVPR 2020). + +[[paper](https://openaccess.thecvf.com/content_CVPR_2020/papers/Fang_GraspNet-1Billion_A_Large-Scale_Benchmark_for_General_Object_Grasping_CVPR_2020_paper.pdf)] +[[dataset](https://graspnet.net/)] +[[API](https://github.com/graspnet/graspnetAPI)] +[[doc](https://graspnetapi.readthedocs.io/en/latest/index.html)] + +
    + scene_0114 + scene_0116 + scene_0117 +
    Top 50 grasps detected by our baseline model. +
    + +![teaser](doc/teaser.png) + +## Requirements +- Python 3 +- PyTorch 1.6 +- Open3d >=0.8 +- TensorBoard 2.3 +- NumPy +- SciPy +- Pillow +- tqdm + +## Installation +Get the code. +```bash +git clone https://github.com/graspnet/graspnet-baseline.git +cd graspnet-baseline +``` +Install packages via Pip. +```bash +pip install -r requirements.txt +``` +Compile and install pointnet2 operators (code adapted from [votenet](https://github.com/facebookresearch/votenet)). +```bash +cd pointnet2 +python setup.py install +``` +Compile and install knn operator (code adapted from [pytorch_knn_cuda](https://github.com/chrischoy/pytorch_knn_cuda)). +```bash +cd knn +python setup.py install +``` +Install graspnetAPI for evaluation. +```bash +git clone https://github.com/graspnet/graspnetAPI.git +cd graspnetAPI +pip install . +``` + +## Tolerance Label Generation +Tolerance labels are not included in the original dataset, and need additional generation. Make sure you have downloaded the orginal dataset from [GraspNet](https://graspnet.net/). The generation code is in [dataset/generate_tolerance_label.py](dataset/generate_tolerance_label.py). You can simply generate tolerance label by running the script: (`--dataset_root` and `--num_workers` should be specified according to your settings) +```bash +cd dataset +sh command_generate_tolerance_label.sh +``` + +Or you can download the tolerance labels from [Google Drive](https://drive.google.com/file/d/1DcjGGhZIJsxd61719N0iWA7L6vNEK0ci/view?usp=sharing)/[Baidu Pan](https://pan.baidu.com/s/1HN29P-csHavJF-R_wec6SQ) and run: +```bash +mv tolerance.tar dataset/ +cd dataset +tar -xvf tolerance.tar +``` + +## Training and Testing +Training examples are shown in [command_train.sh](command_train.sh). `--dataset_root`, `--camera` and `--log_dir` should be specified according to your settings. You can use TensorBoard to visualize training process. + +Testing examples are shown in [command_test.sh](command_test.sh), which contains inference and result evaluation. `--dataset_root`, `--camera`, `--checkpoint_path` and `--dump_dir` should be specified according to your settings. Set `--collision_thresh` to -1 for fast inference. + +The pretrained weights can be downloaded from: + +- `checkpoint-rs.tar` +[[Google Drive](https://drive.google.com/file/d/1hd0G8LN6tRpi4742XOTEisbTXNZ-1jmk/view?usp=sharing)] +[[Baidu Pan](https://pan.baidu.com/s/1Eme60l39tTZrilF0I86R5A)] +- `checkpoint-kn.tar` +[[Google Drive](https://drive.google.com/file/d/1vK-d0yxwyJwXHYWOtH1bDMoe--uZ2oLX/view?usp=sharing)] +[[Baidu Pan](https://pan.baidu.com/s/1QpYzzyID-aG5CgHjPFNB9g)] + +`checkpoint-rs.tar` and `checkpoint-kn.tar` are trained using RealSense data and Kinect data respectively. + +## Demo +A demo program is provided for grasp detection and visualization using RGB-D images. You can refer to [command_demo.sh](command_demo.sh) to run the program. `--checkpoint_path` should be specified according to your settings (make sure you have downloaded the pretrained weights, we recommend the realsense model since it might transfer better). The output should be similar to the following example: + +
    + demo_result +
    + +__Try your own data__ by modifying `get_and_process_data()` in [demo.py](demo.py). Refer to [doc/example_data/](doc/example_data/) for data preparation. RGB-D images and camera intrinsics are required for inference. `factor_depth` stands for the scale for depth value to be transformed into meters. You can also add a workspace mask for denser output. + +## Results +Results "In repo" report the model performance with single-view collision detection as post-processing. In evaluation we set `--collision_thresh` to 0.01. + +Evaluation results on RealSense camera: +| | | Seen | | | Similar | | | Novel | | +|:--------:|:------:|:----------------:|:----------------:|:------:|:----------------:|:----------------:|:------:|:----------------:|:----------------:| +| | __AP__ | AP0.8 | AP0.4 | __AP__ | AP0.8 | AP0.4 | __AP__ | AP0.8 | AP0.4 | +| In paper | 27.56 | 33.43 | 16.95 | 26.11 | 34.18 | 14.23 | 10.55 | 11.25 | 3.98 | +| In repo | 47.47 | 55.90 | 41.33 | 42.27 | 51.01 | 35.40 | 16.61 | 20.84 | 8.30 | + +Evaluation results on Kinect camera: +| | | Seen | | | Similar | | | Novel | | +|:--------:|:------:|:----------------:|:----------------:|:------:|:----------------:|:----------------:|:------:|:----------------:|:----------------:| +| | __AP__ | AP0.8 | AP0.4 | __AP__ | AP0.8 | AP0.4 | __AP__ | AP0.8 | AP0.4 | +| In paper | 29.88 | 36.19 | 19.31 | 27.84 | 33.19 | 16.62 | 11.51 | 12.92 | 3.56 | +| In repo | 42.02 | 49.91 | 35.34 | 37.35 | 44.82 | 30.40 | 12.17 | 15.17 | 5.51 | + +## Citation +Please cite our paper in your publications if it helps your research: +``` +@article{fang2023robust, + title={Robust grasping across diverse sensor qualities: The GraspNet-1Billion dataset}, + author={Fang, Hao-Shu and Gou, Minghao and Wang, Chenxi and Lu, Cewu}, + journal={The International Journal of Robotics Research}, + year={2023}, + publisher={SAGE Publications Sage UK: London, England} +} + +@inproceedings{fang2020graspnet, + title={GraspNet-1Billion: A Large-Scale Benchmark for General Object Grasping}, + author={Fang, Hao-Shu and Wang, Chenxi and Gou, Minghao and Lu, Cewu}, + booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition(CVPR)}, + pages={11444--11453}, + year={2020} +} +``` + +## License +All data, labels, code and models belong to the graspnet team, MVIG, SJTU and are freely available for free non-commercial use, and may be redistributed under these conditions. For commercial queries, please drop an email at fhaoshu at gmail_dot_com and cc lucewu at sjtu.edu.cn . diff --git a/third_party/tuntunclaw/graspnet-baseline/command_demo.sh b/third_party/tuntunclaw/graspnet-baseline/command_demo.sh new file mode 100644 index 0000000000000000000000000000000000000000..f889fc3cf2857405359e4a7e480d3c6993fa65fa --- /dev/null +++ b/third_party/tuntunclaw/graspnet-baseline/command_demo.sh @@ -0,0 +1 @@ +CUDA_VISIBLE_DEVICES=0 python demo.py --checkpoint_path logs/log_kn/checkpoint.tar diff --git a/third_party/tuntunclaw/graspnet-baseline/command_test.sh b/third_party/tuntunclaw/graspnet-baseline/command_test.sh new file mode 100644 index 0000000000000000000000000000000000000000..9a7235ef5e003edb66dc0a8f89c29f6fe8ecdc21 --- /dev/null +++ b/third_party/tuntunclaw/graspnet-baseline/command_test.sh @@ -0,0 +1,2 @@ +CUDA_VISIBLE_DEVICES=0 python test.py --dump_dir logs/dump_rs --checkpoint_path logs/log_rs/checkpoint.tar --camera realsense --dataset_root /data/Benchmark/graspnet +# CUDA_VISIBLE_DEVICES=0 python test.py --dump_dir logs/dump_kn --checkpoint_path logs/log_kn/checkpoint.tar --camera kinect --dataset_root /data/Benchmark/graspnet diff --git a/third_party/tuntunclaw/graspnet-baseline/command_train.sh b/third_party/tuntunclaw/graspnet-baseline/command_train.sh new file mode 100644 index 0000000000000000000000000000000000000000..b2a1f9bdf84e9d011fbaa4d91f349bc0bcbf3595 --- /dev/null +++ b/third_party/tuntunclaw/graspnet-baseline/command_train.sh @@ -0,0 +1,2 @@ +CUDA_VISIBLE_DEVICES=0 python train.py --camera realsense --log_dir logs/log_rs --batch_size 2 --dataset_root /data/Benchmark/graspnet +# CUDA_VISIBLE_DEVICES=0 python train.py --camera kinect --log_dir logs/log_kn --batch_size 2 --dataset_root /data/Benchmark/graspnet diff --git a/third_party/tuntunclaw/graspnet-baseline/demo.py b/third_party/tuntunclaw/graspnet-baseline/demo.py new file mode 100644 index 0000000000000000000000000000000000000000..f257bcba894b393148990bca62279d35a5b4d530 --- /dev/null +++ b/third_party/tuntunclaw/graspnet-baseline/demo.py @@ -0,0 +1,124 @@ +""" Demo to show prediction results. + Author: chenxi-wang +""" + +import os +import sys +import numpy as np +import open3d as o3d +import argparse +import importlib +import scipy.io as scio +from PIL import Image + +import torch +from graspnetAPI import GraspGroup + +ROOT_DIR = os.path.dirname(os.path.abspath(__file__)) +sys.path.append(os.path.join(ROOT_DIR, 'models')) +sys.path.append(os.path.join(ROOT_DIR, 'dataset')) +sys.path.append(os.path.join(ROOT_DIR, 'utils')) + +from graspnet import GraspNet, pred_decode +from graspnet_dataset import GraspNetDataset +from collision_detector import ModelFreeCollisionDetector +from data_utils import CameraInfo, create_point_cloud_from_depth_image + +parser = argparse.ArgumentParser() +parser.add_argument('--checkpoint_path', required=True, help='Model checkpoint path') +parser.add_argument('--num_point', type=int, default=20000, help='Point Number [default: 20000]') +parser.add_argument('--num_view', type=int, default=300, help='View Number [default: 300]') +parser.add_argument('--collision_thresh', type=float, default=0.01, help='Collision Threshold in collision detection [default: 0.01]') +parser.add_argument('--voxel_size', type=float, default=0.01, help='Voxel Size to process point clouds before collision detection [default: 0.01]') +cfgs = parser.parse_args() + + +def get_net(): + # Init the model + net = GraspNet(input_feature_dim=0, num_view=cfgs.num_view, num_angle=12, num_depth=4, + cylinder_radius=0.05, hmin=-0.02, hmax_list=[0.01,0.02,0.03,0.04], is_training=False) + device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") + net.to(device) + # Load checkpoint + checkpoint = torch.load(cfgs.checkpoint_path) + net.load_state_dict(checkpoint['model_state_dict']) + start_epoch = checkpoint['epoch'] + print("-> loaded checkpoint %s (epoch: %d)"%(cfgs.checkpoint_path, start_epoch)) + # set model to eval mode + net.eval() + return net + +def get_and_process_data(data_dir): + # load data + color = np.array(Image.open(os.path.join(data_dir, 'color.png')), dtype=np.float32) / 255.0 + depth = np.array(Image.open(os.path.join(data_dir, 'depth.png'))) + workspace_mask = np.array(Image.open(os.path.join(data_dir, 'workspace_mask.png'))) + meta = scio.loadmat(os.path.join(data_dir, 'meta.mat')) + intrinsic = meta['intrinsic_matrix'] + factor_depth = meta['factor_depth'] + + # generate cloud + camera = CameraInfo(1280.0, 720.0, intrinsic[0][0], intrinsic[1][1], intrinsic[0][2], intrinsic[1][2], factor_depth) + cloud = create_point_cloud_from_depth_image(depth, camera, organized=True) + + # get valid points + mask = (workspace_mask & (depth > 0)) + cloud_masked = cloud[mask] + color_masked = color[mask] + + # sample points + if len(cloud_masked) >= cfgs.num_point: + idxs = np.random.choice(len(cloud_masked), cfgs.num_point, replace=False) + else: + idxs1 = np.arange(len(cloud_masked)) + idxs2 = np.random.choice(len(cloud_masked), cfgs.num_point-len(cloud_masked), replace=True) + idxs = np.concatenate([idxs1, idxs2], axis=0) + cloud_sampled = cloud_masked[idxs] + color_sampled = color_masked[idxs] + + # convert data + cloud = o3d.geometry.PointCloud() + cloud.points = o3d.utility.Vector3dVector(cloud_masked.astype(np.float32)) + cloud.colors = o3d.utility.Vector3dVector(color_masked.astype(np.float32)) + end_points = dict() + cloud_sampled = torch.from_numpy(cloud_sampled[np.newaxis].astype(np.float32)) + device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") + cloud_sampled = cloud_sampled.to(device) + end_points['point_clouds'] = cloud_sampled + end_points['cloud_colors'] = color_sampled + + return end_points, cloud + +def get_grasps(net, end_points): + # Forward pass + with torch.no_grad(): + end_points = net(end_points) + grasp_preds = pred_decode(end_points) + gg_array = grasp_preds[0].detach().cpu().numpy() + gg = GraspGroup(gg_array) + return gg + +def collision_detection(gg, cloud): + mfcdetector = ModelFreeCollisionDetector(cloud, voxel_size=cfgs.voxel_size) + collision_mask = mfcdetector.detect(gg, approach_dist=0.05, collision_thresh=cfgs.collision_thresh) + gg = gg[~collision_mask] + return gg + +def vis_grasps(gg, cloud): + gg.nms() + gg.sort_by_score() + gg = gg[:50] + grippers = gg.to_open3d_geometry_list() + o3d.visualization.draw_geometries([cloud, *grippers]) + +def demo(data_dir): + net = get_net() + end_points, cloud = get_and_process_data(data_dir) + gg = get_grasps(net, end_points) + if cfgs.collision_thresh > 0: + gg = collision_detection(gg, np.array(cloud.points)) + vis_grasps(gg, cloud) + +if __name__=='__main__': + data_dir = 'doc/example_data' + demo(data_dir) diff --git a/third_party/tuntunclaw/graspnet-baseline/graspnetAPI/.gitignore b/third_party/tuntunclaw/graspnet-baseline/graspnetAPI/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..56da945a292e394e06ac016254ca1b3457899a6c --- /dev/null +++ b/third_party/tuntunclaw/graspnet-baseline/graspnetAPI/.gitignore @@ -0,0 +1,13 @@ +*.pyc +*.so +*.o +*.egg-info/ +/graspnetAPI/dump_full/ +/graspnetAPI/eval/acc_novel +/dump_full/ +/dist/ +/build/ +/.vscode/ +/graspnms/build/ +*.npy +/graspnms/grasp_nms.cpp \ No newline at end of file diff --git a/third_party/tuntunclaw/graspnet-baseline/graspnetAPI/.readthedocs.yml b/third_party/tuntunclaw/graspnet-baseline/graspnetAPI/.readthedocs.yml new file mode 100644 index 0000000000000000000000000000000000000000..9ab6142cc38e431e66a68d63a0c68a396854cb48 --- /dev/null +++ b/third_party/tuntunclaw/graspnet-baseline/graspnetAPI/.readthedocs.yml @@ -0,0 +1,30 @@ +# .readthedocs.yml +# Read the Docs configuration file +# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details + +# Required +version: 2 + +# Build documentation in the docs/ directory with Sphinx +sphinx: + configuration: docs/source/conf.py + +# Build documentation with MkDocs +#mkdocs: +# configuration: mkdocs.yml +build: + image: stable +# Optionally build your docs in additional formats such as PDF +formats: + - pdf + - epub + + # Optionally set the version of Python and requirements required to build your docs + +python: + version: 3.6 + install: + - requirements: docs/requirements.txt + - method: pip + path: . + system_packages: true diff --git a/third_party/tuntunclaw/graspnet-baseline/graspnetAPI/=4.6.0 b/third_party/tuntunclaw/graspnet-baseline/graspnetAPI/=4.6.0 new file mode 100644 index 0000000000000000000000000000000000000000..6a2ea10898be8883917c8fe45799cc5b1a688937 --- /dev/null +++ b/third_party/tuntunclaw/graspnet-baseline/graspnetAPI/=4.6.0 @@ -0,0 +1,10 @@ +Looking in indexes: https://pypi.tuna.tsinghua.edu.cn/simple +Requirement already satisfied: opencv-python in /home/hting/anaconda3/envs/vlm_graspnet/lib/python3.10/site-packages (4.12.0.88) +Collecting numpy<2.3.0,>=2 (from opencv-python) + Using cached https://pypi.tuna.tsinghua.edu.cn/packages/b4/63/3de6a34ad7ad6646ac7d2f55ebc6ad439dbbf9c4370017c50cf403fb19b5/numpy-2.2.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (16.8 MB) +Installing collected packages: numpy + Attempting uninstall: numpy + Found existing installation: numpy 1.23.4 + Uninstalling numpy-1.23.4: + Successfully uninstalled numpy-1.23.4 +Successfully installed numpy-2.2.6 diff --git a/third_party/tuntunclaw/graspnet-baseline/graspnetAPI/README.md b/third_party/tuntunclaw/graspnet-baseline/graspnetAPI/README.md new file mode 100644 index 0000000000000000000000000000000000000000..17139921d2ded6eb0d681ed52dc155da7fc637ae --- /dev/null +++ b/third_party/tuntunclaw/graspnet-baseline/graspnetAPI/README.md @@ -0,0 +1,95 @@ +# graspnetAPI +[![PyPI version](https://badge.fury.io/py/graspnetAPI.svg)](https://badge.fury.io/py/graspnetAPI) + +## Dataset + +Visit the [GraspNet Website](http://graspnet.net) to get the dataset. + +## Install +You can install using pip. (Note: The pip version might be old, install from the source is recommended.) +```bash +pip install graspnetAPI +``` + +You can also install from source. + +```bash +git clone https://github.com/graspnet/graspnetAPI.git +cd graspnetAPI +pip install . +``` + +## Document + +Refer to [online document](https://graspnetapi.readthedocs.io/en/latest/index.html) for more details. +[PDF Document](https://graspnetapi.readthedocs.io/_/downloads/en/latest/pdf/) is available, too. + +You can also build the doc manually. +```bash +cd docs +pip install -r requirements.txt +bash build_doc.sh +``` + +LaTeX is required to build the pdf, but html can be built anyway. + +## Grasp Definition +The frame of our gripper is defined as +
    + +
    + + +## Examples +```bash +cd examples + +# change the path of graspnet root + +# How to load labels from graspnet. +python3 exam_loadGrasp.py + +# How to convert between 6d and rectangle grasps. +python3 exam_convert.py + +# Check the completeness of the data. +python3 exam_check_data.py + +# you can also run other examples +``` + +Please refer to our document for more examples. + +## Citation +Please cite these papers in your publications if it helps your research: +``` +@article{fang2023robust, + title={Robust grasping across diverse sensor qualities: The GraspNet-1Billion dataset}, + author={Fang, Hao-Shu and Gou, Minghao and Wang, Chenxi and Lu, Cewu}, + journal={The International Journal of Robotics Research}, + year={2023}, + publisher={SAGE Publications Sage UK: London, England} +} + +@inproceedings{fang2020graspnet, + title={GraspNet-1Billion: A Large-Scale Benchmark for General Object Grasping}, + author={Fang, Hao-Shu and Wang, Chenxi and Gou, Minghao and Lu, Cewu}, + booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition(CVPR)}, + pages={11444--11453}, + year={2020} +} +``` + +## Change Log + +#### 1.2.6 + +- Add transformation for Grasp and GraspGroup. + +#### 1.2.7 + +- Add inpainting for depth image. + +#### 1.2.8 + +- Minor fix bug on loadScenePointCloud. diff --git a/third_party/tuntunclaw/graspnet-baseline/graspnetAPI/copy_rect_labels.py b/third_party/tuntunclaw/graspnet-baseline/graspnetAPI/copy_rect_labels.py new file mode 100644 index 0000000000000000000000000000000000000000..779d1a1c5fcdc4c4bfc81ed1e94b5a728b163694 --- /dev/null +++ b/third_party/tuntunclaw/graspnet-baseline/graspnetAPI/copy_rect_labels.py @@ -0,0 +1,19 @@ +import os +from tqdm import tqdm + +### change the root to you path #### +graspnet_root = '/home/gmh/graspnet' + +### change the root to the folder contains rectangle grasp labels ### +rect_labels_root = 'rect_labels' + +for sceneId in tqdm(range(190), 'Copying Rectangle Grasp Labels'): + for camera in ['kinect', 'realsense']: + dest_dir = os.path.join(graspnet_root, 'scenes', 'scene_%04d' % sceneId, camera, 'rect') + src_dir = os.path.join(rect_labels_root, 'scene_%04d' % sceneId, camera) + if not os.path.exists(dest_dir): + os.mkdir(dest_dir) + for annId in range(256): + src_path = os.path.join(src_dir,'%04d.npy' % annId) + assert os.path.exists(src_path) + os.system('cp {} {}'.format(src_path, dest_dir)) diff --git a/third_party/tuntunclaw/graspnet-baseline/graspnetAPI/gen_pickle_dexmodel.py b/third_party/tuntunclaw/graspnet-baseline/graspnetAPI/gen_pickle_dexmodel.py new file mode 100644 index 0000000000000000000000000000000000000000..f9c8c66983f6e527041fba75ebe3815079be0d71 --- /dev/null +++ b/third_party/tuntunclaw/graspnet-baseline/graspnetAPI/gen_pickle_dexmodel.py @@ -0,0 +1,21 @@ +__author__ = 'mhgou' + +from graspnetAPI.utils.eval_utils import load_dexnet_model +from tqdm import tqdm +import pickle +import os + +##### Change the root to your path ##### +graspnet_root = '/home/gmh/graspnet' + +##### Do NOT change this folder name ##### +dex_folder = 'dex_models' +if not os.path.exists(dex_folder): + os.makedirs(dex_folder) + +model_dir = os.path.join(graspnet_root, 'models') +for obj_id in tqdm(range(88), 'dump models'): + dex_model = load_dexnet_model(os.path.join(model_dir, '%03d' % obj_id, 'textured')) + with open(os.path.join(dex_folder, '%03d.pkl' % obj_id), 'wb') as f: + pickle.dump(dex_model, f) + diff --git a/third_party/tuntunclaw/graspnet-baseline/graspnetAPI/grasp_definition.vsdx b/third_party/tuntunclaw/graspnet-baseline/graspnetAPI/grasp_definition.vsdx new file mode 100644 index 0000000000000000000000000000000000000000..b4ee835965f5104399fdde40ff55a5775d81e1ab Binary files /dev/null and b/third_party/tuntunclaw/graspnet-baseline/graspnetAPI/grasp_definition.vsdx differ diff --git a/third_party/tuntunclaw/graspnet-baseline/graspnetAPI/setup.py b/third_party/tuntunclaw/graspnet-baseline/graspnetAPI/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..8e7bef2635e8ec5220f54b904b08d4dbf34d2a96 --- /dev/null +++ b/third_party/tuntunclaw/graspnet-baseline/graspnetAPI/setup.py @@ -0,0 +1,37 @@ +from distutils.core import setup +from setuptools import find_packages +from setuptools.command.install import install +import os + +setup( + name='graspnetAPI', + version='1.2.11', + description='graspnet API', + author='Hao-Shu Fang, Chenxi Wang, Minghao Gou', + author_email='gouminghao@gmail.com', + url='https://graspnet.net', + packages=find_packages(), + install_requires=[ + 'numpy==1.23.4', + 'scipy', + 'transforms3d==0.3.1', + 'open3d>=0.8.0.0', + 'trimesh', + 'tqdm', + 'Pillow', + 'opencv-python', + 'pillow', + 'matplotlib', + 'pywavefront', + 'trimesh', + 'scikit-image', + 'autolab_core', + 'autolab-perception', + 'cvxopt', + 'dill', + 'h5py', +# 'sklearn', + 'scikit_learn', + 'grasp_nms' + ] +) diff --git a/third_party/tuntunclaw/graspnet-baseline/knn/knn_modules.py b/third_party/tuntunclaw/graspnet-baseline/knn/knn_modules.py new file mode 100644 index 0000000000000000000000000000000000000000..ea43dc68f69649b5c246325ed6738901247f51ba --- /dev/null +++ b/third_party/tuntunclaw/graspnet-baseline/knn/knn_modules.py @@ -0,0 +1,17 @@ +import unittest +import gc +import operator as op +import functools +import torch +from torch.autograd import Variable, Function +from knn_pytorch import knn_pytorch +# import knn_pytorch +def knn(ref, query, k=1): + """ Compute k nearest neighbors for each query point. + """ + device = ref.device + ref = ref.float().to(device) + query = query.float().to(device) + inds = torch.empty(query.shape[0], k, query.shape[2]).long().to(device) + knn_pytorch.knn(ref, query, inds) + return inds diff --git a/third_party/tuntunclaw/graspnet-baseline/knn/setup.py b/third_party/tuntunclaw/graspnet-baseline/knn/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..9aa9803ce986b0014fd1dce9ab02772111340455 --- /dev/null +++ b/third_party/tuntunclaw/graspnet-baseline/knn/setup.py @@ -0,0 +1,66 @@ +#!/usr/bin/env python + +import glob +import os + +import torch +from setuptools import find_packages +from setuptools import setup +from torch.utils.cpp_extension import CUDA_HOME +from torch.utils.cpp_extension import CppExtension +from torch.utils.cpp_extension import CUDAExtension + +requirements = ["torch", "torchvision"] + + +def get_extensions(): + this_dir = os.path.dirname(os.path.abspath(__file__)) + extensions_dir = os.path.join(this_dir, "src") + + main_file = glob.glob(os.path.join(extensions_dir, "*.cpp")) + source_cpu = glob.glob(os.path.join(extensions_dir, "cpu", "*.cpp")) + source_cuda = glob.glob(os.path.join(extensions_dir, "cuda", "*.cu")) + + sources = main_file + source_cpu + extension = CppExtension + + extra_compile_args = {"cxx": []} + define_macros = [] + + if torch.cuda.is_available() and CUDA_HOME is not None: + extension = CUDAExtension + sources += source_cuda + define_macros += [("WITH_CUDA", None)] + extra_compile_args["nvcc"] = [ + "-DCUDA_HAS_FP16=1", + "-D__CUDA_NO_HALF_OPERATORS__", + "-D__CUDA_NO_HALF_CONVERSIONS__", + "-D__CUDA_NO_HALF2_OPERATORS__", + ] + + sources = [os.path.join(extensions_dir, s) for s in sources] + + include_dirs = [extensions_dir] + + ext_modules = [ + extension( + "knn_pytorch.knn_pytorch", + sources, + include_dirs=include_dirs, + define_macros=define_macros, + extra_compile_args=extra_compile_args, + ) + ] + + return ext_modules + + +setup( + name="knn_pytorch", + version="0.1", + author="foolyc", + url="https://github.com/foolyc/torchKNN", + description="KNN implement in Pytorch 1.0 including both cpu version and gpu version", + ext_modules=get_extensions(), + cmdclass={"build_ext": torch.utils.cpp_extension.BuildExtension}, +) diff --git a/third_party/tuntunclaw/graspnet-baseline/models/backbone.py b/third_party/tuntunclaw/graspnet-baseline/models/backbone.py new file mode 100644 index 0000000000000000000000000000000000000000..a3da44474082a3e862cd6c63c0b3c76a1fc50e0a --- /dev/null +++ b/third_party/tuntunclaw/graspnet-baseline/models/backbone.py @@ -0,0 +1,131 @@ +""" PointNet2 backbone for feature learning. + Author: Charles R. Qi +""" +import os +import sys +import torch +import torch.nn as nn + +BASE_DIR = os.path.dirname(os.path.abspath(__file__)) +ROOT_DIR = os.path.dirname(BASE_DIR) +sys.path.append(ROOT_DIR) +sys.path.append(os.path.join(ROOT_DIR, 'pointnet2')) + +from pointnet2_modules import PointnetSAModuleVotes, PointnetFPModule + +class Pointnet2Backbone(nn.Module): + r""" + Backbone network for point cloud feature learning. + Based on Pointnet++ single-scale grouping network. + + Parameters + ---------- + input_feature_dim: int + Number of input channels in the feature descriptor for each point. + e.g. 3 for RGB. + """ + def __init__(self, input_feature_dim=0): + super().__init__() + + self.sa1 = PointnetSAModuleVotes( + npoint=2048, + radius=0.04, + nsample=64, + mlp=[input_feature_dim, 64, 64, 128], + use_xyz=True, + normalize_xyz=True + ) + + self.sa2 = PointnetSAModuleVotes( + npoint=1024, + radius=0.1, + nsample=32, + mlp=[128, 128, 128, 256], + use_xyz=True, + normalize_xyz=True + ) + + self.sa3 = PointnetSAModuleVotes( + npoint=512, + radius=0.2, + nsample=16, + mlp=[256, 128, 128, 256], + use_xyz=True, + normalize_xyz=True + ) + + self.sa4 = PointnetSAModuleVotes( + npoint=256, + radius=0.3, + nsample=16, + mlp=[256, 128, 128, 256], + use_xyz=True, + normalize_xyz=True + ) + + self.fp1 = PointnetFPModule(mlp=[256+256,256,256]) + self.fp2 = PointnetFPModule(mlp=[256+256,256,256]) + + def _break_up_pc(self, pc): + xyz = pc[..., 0:3].contiguous() + features = ( + pc[..., 3:].transpose(1, 2).contiguous() + if pc.size(-1) > 3 else None + ) + + return xyz, features + + def forward(self, pointcloud: torch.cuda.FloatTensor, end_points=None): + r""" + Forward pass of the network + + Parameters + ---------- + pointcloud: Variable(torch.cuda.FloatTensor) + (B, N, 3 + input_feature_dim) tensor + Point cloud to run predicts on + Each point in the point-cloud MUST + be formated as (x, y, z, features...) + + Returns + ---------- + end_points: {XXX_xyz, XXX_features, XXX_inds} + XXX_xyz: float32 Tensor of shape (B,K,3) + XXX_features: float32 Tensor of shape (B,D,K) + XXX_inds: int64 Tensor of shape (B,K) values in [0,N-1] + """ + if not end_points: end_points = {} + batch_size = pointcloud.shape[0] + + xyz, features = self._break_up_pc(pointcloud) + end_points['input_xyz'] = xyz + end_points['input_features'] = features + + # --------- 4 SET ABSTRACTION LAYERS --------- + xyz, features, fps_inds = self.sa1(xyz, features) + end_points['sa1_inds'] = fps_inds + end_points['sa1_xyz'] = xyz + end_points['sa1_features'] = features + + xyz, features, fps_inds = self.sa2(xyz, features) # this fps_inds is just 0,1,...,1023 + end_points['sa2_inds'] = fps_inds + end_points['sa2_xyz'] = xyz + end_points['sa2_features'] = features + + xyz, features, fps_inds = self.sa3(xyz, features) # this fps_inds is just 0,1,...,511 + end_points['sa3_xyz'] = xyz + end_points['sa3_features'] = features + + xyz, features, fps_inds = self.sa4(xyz, features) # this fps_inds is just 0,1,...,255 + end_points['sa4_xyz'] = xyz + end_points['sa4_features'] = features + + # --------- 2 FEATURE UPSAMPLING LAYERS -------- + features = self.fp1(end_points['sa3_xyz'], end_points['sa4_xyz'], end_points['sa3_features'], end_points['sa4_features']) + features = self.fp2(end_points['sa2_xyz'], end_points['sa3_xyz'], end_points['sa2_features'], features) + end_points['fp2_features'] = features + end_points['fp2_xyz'] = end_points['sa2_xyz'] + num_seed = end_points['fp2_xyz'].shape[1] + end_points['fp2_inds'] = end_points['sa1_inds'][:,0:num_seed] # indices among the entire input point clouds + + return features, end_points['fp2_xyz'], end_points \ No newline at end of file diff --git a/third_party/tuntunclaw/graspnet-baseline/models/graspnet.py b/third_party/tuntunclaw/graspnet-baseline/models/graspnet.py new file mode 100644 index 0000000000000000000000000000000000000000..4df490d22b62046f1f1ed663d376bf62be56231d --- /dev/null +++ b/third_party/tuntunclaw/graspnet-baseline/models/graspnet.py @@ -0,0 +1,137 @@ +""" GraspNet baseline model definition. + Author: chenxi-wang +""" + +import os +import sys +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F + +BASE_DIR = os.path.dirname(os.path.abspath(__file__)) +ROOT_DIR = os.path.dirname(BASE_DIR) +sys.path.append(ROOT_DIR) +sys.path.append(os.path.join(ROOT_DIR, 'pointnet2')) +sys.path.append(os.path.join(ROOT_DIR, 'utils')) + +from backbone import Pointnet2Backbone +from modules import ApproachNet, CloudCrop, OperationNet, ToleranceNet +from loss import get_loss +from loss_utils import GRASP_MAX_WIDTH, GRASP_MAX_TOLERANCE, batch_viewpoint_params_to_matrix + + +class GraspNetStage1(nn.Module): + def __init__(self, input_feature_dim=0, num_view=300): + super().__init__() + self.backbone = Pointnet2Backbone(input_feature_dim) + self.vpmodule = ApproachNet(num_view, 256) + + def forward(self, end_points): + pointcloud = end_points['point_clouds'] + seed_features, seed_xyz, end_points = self.backbone(pointcloud, end_points) + end_points = self.vpmodule(seed_xyz, seed_features, end_points) + return end_points + + +class GraspNetStage2(nn.Module): + def __init__(self, num_angle=12, num_depth=4, cylinder_radius=0.05, hmin=-0.02, hmax_list=[0.01,0.02,0.03,0.04], is_training=True): + super().__init__() + self.num_angle = num_angle + self.num_depth = num_depth + self.is_training = is_training + self.crop = CloudCrop(64, 3, cylinder_radius, hmin, hmax_list) + self.operation = OperationNet(num_angle, num_depth) + self.tolerance = ToleranceNet(num_angle, num_depth) + + def forward(self, end_points): + pointcloud = end_points['input_xyz'] + if self.is_training: + # Defer heavy training-only dependency to avoid importing KNN extension for inference. + from label_generation import match_grasp_view_and_label + grasp_top_views_rot, _, _, _, end_points = match_grasp_view_and_label(end_points) + seed_xyz = end_points['batch_grasp_point'] + else: + grasp_top_views_rot = end_points['grasp_top_view_rot'] + seed_xyz = end_points['fp2_xyz'] + + vp_features = self.crop(seed_xyz, pointcloud, grasp_top_views_rot) + end_points = self.operation(vp_features, end_points) + end_points = self.tolerance(vp_features, end_points) + + return end_points + +class GraspNet(nn.Module): + def __init__(self, input_feature_dim=0, num_view=300, num_angle=12, num_depth=4, cylinder_radius=0.05, hmin=-0.02, hmax_list=[0.01,0.02,0.03,0.04], is_training=True): + super().__init__() + self.is_training = is_training + self.view_estimator = GraspNetStage1(input_feature_dim, num_view) + self.grasp_generator = GraspNetStage2(num_angle, num_depth, cylinder_radius, hmin, hmax_list, is_training) + + def forward(self, end_points): + end_points = self.view_estimator(end_points) + if self.is_training: + # Defer heavy training-only dependency to avoid importing KNN extension for inference. + from label_generation import process_grasp_labels + end_points = process_grasp_labels(end_points) + end_points = self.grasp_generator(end_points) + return end_points + +def pred_decode(end_points): + batch_size = len(end_points['point_clouds']) + grasp_preds = [] + for i in range(batch_size): + ## load predictions + objectness_score = end_points['objectness_score'][i].float() + grasp_score = end_points['grasp_score_pred'][i].float() + grasp_center = end_points['fp2_xyz'][i].float() + approaching = -end_points['grasp_top_view_xyz'][i].float() + grasp_angle_class_score = end_points['grasp_angle_cls_pred'][i] + grasp_width = 1.2 * end_points['grasp_width_pred'][i] + grasp_width = torch.clamp(grasp_width, min=0, max=GRASP_MAX_WIDTH) + grasp_tolerance = end_points['grasp_tolerance_pred'][i] + + ## slice preds by angle + # grasp angle + grasp_angle_class = torch.argmax(grasp_angle_class_score, 0) + grasp_angle = grasp_angle_class.float() / 12 * np.pi + # grasp score & width & tolerance + grasp_angle_class_ = grasp_angle_class.unsqueeze(0) + grasp_score = torch.gather(grasp_score, 0, grasp_angle_class_).squeeze(0) + grasp_width = torch.gather(grasp_width, 0, grasp_angle_class_).squeeze(0) + grasp_tolerance = torch.gather(grasp_tolerance, 0, grasp_angle_class_).squeeze(0) + + ## slice preds by score/depth + # grasp depth + grasp_depth_class = torch.argmax(grasp_score, 1, keepdims=True) + grasp_depth = (grasp_depth_class.float()+1) * 0.01 + # grasp score & angle & width & tolerance + grasp_score = torch.gather(grasp_score, 1, grasp_depth_class) + grasp_angle = torch.gather(grasp_angle, 1, grasp_depth_class) + grasp_width = torch.gather(grasp_width, 1, grasp_depth_class) + grasp_tolerance = torch.gather(grasp_tolerance, 1, grasp_depth_class) + + ## slice preds by objectness + objectness_pred = torch.argmax(objectness_score, 0) + objectness_mask = (objectness_pred==1) + grasp_score = grasp_score[objectness_mask] + grasp_width = grasp_width[objectness_mask] + grasp_depth = grasp_depth[objectness_mask] + approaching = approaching[objectness_mask] + grasp_angle = grasp_angle[objectness_mask] + grasp_center = grasp_center[objectness_mask] + grasp_tolerance = grasp_tolerance[objectness_mask] + grasp_score = grasp_score * grasp_tolerance / GRASP_MAX_TOLERANCE + + ## convert to rotation matrix + Ns = grasp_angle.size(0) + approaching_ = approaching.view(Ns, 3) + grasp_angle_ = grasp_angle.view(Ns) + rotation_matrix = batch_viewpoint_params_to_matrix(approaching_, grasp_angle_) + rotation_matrix = rotation_matrix.view(Ns, 9) + + # merge preds + grasp_height = 0.02 * torch.ones_like(grasp_score) + obj_ids = -1 * torch.ones_like(grasp_score) + grasp_preds.append(torch.cat([grasp_score, grasp_width, grasp_height, grasp_depth, rotation_matrix, grasp_center, obj_ids], axis=-1)) + return grasp_preds diff --git a/third_party/tuntunclaw/graspnet-baseline/models/loss.py b/third_party/tuntunclaw/graspnet-baseline/models/loss.py new file mode 100644 index 0000000000000000000000000000000000000000..3d1e8ad7290b4b33d73dc6770fb00faf0b031f0f --- /dev/null +++ b/third_party/tuntunclaw/graspnet-baseline/models/loss.py @@ -0,0 +1,132 @@ +""" Loss functions for training. + Author: chenxi-wang +""" + +import torch +import torch.nn as nn +import torch.nn.functional as F +import numpy as np +import sys +import os +import time + +BASE_DIR = os.path.dirname(os.path.abspath(__file__)) +ROOT_DIR = os.path.dirname(BASE_DIR) +sys.path.append(ROOT_DIR) +sys.path.append(os.path.join(ROOT_DIR, 'utils')) + +from loss_utils import GRASP_MAX_WIDTH, GRASP_MAX_TOLERANCE, THRESH_GOOD, THRESH_BAD,\ + transform_point_cloud, generate_grasp_views,\ + batch_viewpoint_params_to_matrix, huber_loss + +def get_loss(end_points): + objectness_loss, end_points = compute_objectness_loss(end_points) + view_loss, end_points = compute_view_loss(end_points) + grasp_loss, end_points = compute_grasp_loss(end_points) + loss = objectness_loss + view_loss + 0.2 * grasp_loss + end_points['loss/overall_loss'] = loss + return loss, end_points + +def compute_objectness_loss(end_points): + criterion = nn.CrossEntropyLoss(reduction='mean') + objectness_score = end_points['objectness_score'] + objectness_label = end_points['objectness_label'] + fp2_inds = end_points['fp2_inds'].long() + objectness_label = torch.gather(objectness_label, 1, fp2_inds) + loss = criterion(objectness_score, objectness_label) + + end_points['loss/stage1_objectness_loss'] = loss + objectness_pred = torch.argmax(objectness_score, 1) + end_points['stage1_objectness_acc'] = (objectness_pred == objectness_label.long()).float().mean() + + end_points['stage1_objectness_prec'] = (objectness_pred == objectness_label.long())[objectness_pred == 1].float().mean() + end_points['stage1_objectness_recall'] = (objectness_pred == objectness_label.long())[objectness_label == 1].float().mean() + + return loss, end_points + +def compute_view_loss(end_points): + criterion = nn.MSELoss(reduction='none') + view_score = end_points['view_score'] + view_label = end_points['batch_grasp_view_label'] + objectness_label = end_points['objectness_label'] + fp2_inds = end_points['fp2_inds'].long() + V = view_label.size(2) + objectness_label = torch.gather(objectness_label, 1, fp2_inds) + + objectness_mask = (objectness_label > 0) + objectness_mask = objectness_mask.unsqueeze(-1).repeat(1, 1, V) + pos_view_pred_mask = ((view_score >= THRESH_GOOD) & objectness_mask) + + loss = criterion(view_score, view_label) + loss = loss[objectness_mask].mean() + + end_points['loss/stage1_view_loss'] = loss + end_points['stage1_pos_view_pred_count'] = pos_view_pred_mask.long().sum() + + return loss, end_points + + +def compute_grasp_loss(end_points, use_template_in_training=True): + top_view_inds = end_points['grasp_top_view_inds'] # (B, Ns) + vp_rot = end_points['grasp_top_view_rot'] # (B, Ns, view_factor, 3, 3) + objectness_label = end_points['objectness_label'] + fp2_inds = end_points['fp2_inds'].long() + objectness_mask = torch.gather(objectness_label, 1, fp2_inds).bool() # (B, Ns) + + # process labels + batch_grasp_label = end_points['batch_grasp_label'] # (B, Ns, A, D) + batch_grasp_offset = end_points['batch_grasp_offset'] # (B, Ns, A, D, 3) + batch_grasp_tolerance = end_points['batch_grasp_tolerance'] # (B, Ns, A, D) + B, Ns, A, D = batch_grasp_label.size() + + # pick the one with the highest angle score + top_view_grasp_angles = batch_grasp_offset[:, :, :, :, 0] #(B, Ns, A, D) + top_view_grasp_depths = batch_grasp_offset[:, :, :, :, 1] #(B, Ns, A, D) + top_view_grasp_widths = batch_grasp_offset[:, :, :, :, 2] #(B, Ns, A, D) + target_labels_inds = torch.argmax(batch_grasp_label, dim=2, keepdim=True) # (B, Ns, 1, D) + target_labels = torch.gather(batch_grasp_label, 2, target_labels_inds).squeeze(2) # (B, Ns, D) + target_angles = torch.gather(top_view_grasp_angles, 2, target_labels_inds).squeeze(2) # (B, Ns, D) + target_depths = torch.gather(top_view_grasp_depths, 2, target_labels_inds).squeeze(2) # (B, Ns, D) + target_widths = torch.gather(top_view_grasp_widths, 2, target_labels_inds).squeeze(2) # (B, Ns, D) + target_tolerance = torch.gather(batch_grasp_tolerance, 2, target_labels_inds).squeeze(2) # (B, Ns, D) + + graspable_mask = (target_labels > THRESH_BAD) + objectness_mask = objectness_mask.unsqueeze(-1).expand_as(graspable_mask) + loss_mask = (objectness_mask & graspable_mask).float() + + # 1. grasp score loss + target_labels_inds_ = target_labels_inds.transpose(1, 2) # (B, 1, Ns, D) + grasp_score = torch.gather(end_points['grasp_score_pred'], 1, target_labels_inds_).squeeze(1) + grasp_score_loss = huber_loss(grasp_score-target_labels, delta=1.0) + grasp_score_loss = torch.sum(grasp_score_loss * loss_mask) / (loss_mask.sum() + 1e-6) + end_points['loss/stage2_grasp_score_loss'] = grasp_score_loss + + # 2. inplane rotation cls loss + target_angles_cls = target_labels_inds.squeeze(2) # (B, Ns, D) + criterion_grasp_angle_class = nn.CrossEntropyLoss(reduction='none') + grasp_angle_class_score = end_points['grasp_angle_cls_pred'] + grasp_angle_class_loss = criterion_grasp_angle_class(grasp_angle_class_score, target_angles_cls) + grasp_angle_class_loss = torch.sum(grasp_angle_class_loss * loss_mask) / (loss_mask.sum() + 1e-6) + end_points['loss/stage2_grasp_angle_class_loss'] = grasp_angle_class_loss + grasp_angle_class_pred = torch.argmax(grasp_angle_class_score, 1) + end_points['stage2_grasp_angle_class_acc/0_degree'] = (grasp_angle_class_pred==target_angles_cls)[loss_mask.bool()].float().mean() + acc_mask_15 = ((torch.abs(grasp_angle_class_pred-target_angles_cls)<=1) | (torch.abs(grasp_angle_class_pred-target_angles_cls)>=A-1)) + end_points['stage2_grasp_angle_class_acc/15_degree'] = acc_mask_15[loss_mask.bool()].float().mean() + acc_mask_30 = ((torch.abs(grasp_angle_class_pred-target_angles_cls)<=2) | (torch.abs(grasp_angle_class_pred-target_angles_cls)>=A-2)) + end_points['stage2_grasp_angle_class_acc/30_degree'] = acc_mask_30[loss_mask.bool()].float().mean() + + # 3. width reg loss + grasp_width_pred = torch.gather(end_points['grasp_width_pred'], 1, target_labels_inds_).squeeze(1) + grasp_width_loss = huber_loss((grasp_width_pred-target_widths)/GRASP_MAX_WIDTH, delta=1) + grasp_width_loss = torch.sum(grasp_width_loss * loss_mask) / (loss_mask.sum() + 1e-6) + end_points['loss/stage2_grasp_width_loss'] = grasp_width_loss + + # 4. tolerance reg loss + grasp_tolerance_pred = torch.gather(end_points['grasp_tolerance_pred'], 1, target_labels_inds_).squeeze(1) + grasp_tolerance_loss = huber_loss((grasp_tolerance_pred-target_tolerance)/GRASP_MAX_TOLERANCE, delta=1) + grasp_tolerance_loss = torch.sum(grasp_tolerance_loss * loss_mask) / (loss_mask.sum() + 1e-6) + end_points['loss/stage2_grasp_tolerance_loss'] = grasp_tolerance_loss + + grasp_loss = grasp_score_loss + grasp_angle_class_loss\ + + grasp_width_loss + grasp_tolerance_loss + return grasp_loss, end_points \ No newline at end of file diff --git a/third_party/tuntunclaw/graspnet-baseline/pointnet2/pointnet2_modules.py b/third_party/tuntunclaw/graspnet-baseline/pointnet2/pointnet2_modules.py new file mode 100644 index 0000000000000000000000000000000000000000..bfb4c3e6aa6a21ccff2f0c6891d29133171ffb86 --- /dev/null +++ b/third_party/tuntunclaw/graspnet-baseline/pointnet2/pointnet2_modules.py @@ -0,0 +1,518 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +''' Pointnet2 layers. +Modified based on: https://github.com/erikwijmans/Pointnet2_PyTorch +Extended with the following: +1. Uniform sampling in each local region (sample_uniformly) +2. Return sampled points indices to support votenet. +''' +import torch +import torch.nn as nn +import torch.nn.functional as F + +import os +import sys +BASE_DIR = os.path.dirname(os.path.abspath(__file__)) +sys.path.append(BASE_DIR) + +import pointnet2_utils +import pytorch_utils as pt_utils +from typing import List + + +class _PointnetSAModuleBase(nn.Module): + + def __init__(self): + super().__init__() + self.npoint = None + self.groupers = None + self.mlps = None + + def forward(self, xyz: torch.Tensor, + features: torch.Tensor = None) -> (torch.Tensor, torch.Tensor): + r""" + Parameters + ---------- + xyz : torch.Tensor + (B, N, 3) tensor of the xyz coordinates of the features + features : torch.Tensor + (B, N, C) tensor of the descriptors of the the features + + Returns + ------- + new_xyz : torch.Tensor + (B, npoint, 3) tensor of the new features' xyz + new_features : torch.Tensor + (B, npoint, \sum_k(mlps[k][-1])) tensor of the new_features descriptors + """ + + new_features_list = [] + + xyz_flipped = xyz.transpose(1, 2).contiguous() + new_xyz = pointnet2_utils.gather_operation( + xyz_flipped, + pointnet2_utils.furthest_point_sample(xyz, self.npoint) + ).transpose(1, 2).contiguous() if self.npoint is not None else None + + for i in range(len(self.groupers)): + new_features = self.groupers[i]( + xyz, new_xyz, features + ) # (B, C, npoint, nsample) + + new_features = self.mlps[i]( + new_features + ) # (B, mlp[-1], npoint, nsample) + new_features = F.max_pool2d( + new_features, kernel_size=[1, new_features.size(3)] + ) # (B, mlp[-1], npoint, 1) + new_features = new_features.squeeze(-1) # (B, mlp[-1], npoint) + + new_features_list.append(new_features) + + return new_xyz, torch.cat(new_features_list, dim=1) + + +class PointnetSAModuleMSG(_PointnetSAModuleBase): + r"""Pointnet set abstrction layer with multiscale grouping + + Parameters + ---------- + npoint : int + Number of features + radii : list of float32 + list of radii to group with + nsamples : list of int32 + Number of samples in each ball query + mlps : list of list of int32 + Spec of the pointnet before the global max_pool for each scale + bn : bool + Use batchnorm + """ + + def __init__( + self, + *, + npoint: int, + radii: List[float], + nsamples: List[int], + mlps: List[List[int]], + bn: bool = True, + use_xyz: bool = True, + sample_uniformly: bool = False + ): + super().__init__() + + assert len(radii) == len(nsamples) == len(mlps) + + self.npoint = npoint + self.groupers = nn.ModuleList() + self.mlps = nn.ModuleList() + for i in range(len(radii)): + radius = radii[i] + nsample = nsamples[i] + self.groupers.append( + pointnet2_utils.QueryAndGroup(radius, nsample, use_xyz=use_xyz, sample_uniformly=sample_uniformly) + if npoint is not None else pointnet2_utils.GroupAll(use_xyz) + ) + mlp_spec = mlps[i] + if use_xyz: + mlp_spec[0] += 3 + + self.mlps.append(pt_utils.SharedMLP(mlp_spec, bn=bn)) + + +class PointnetSAModule(PointnetSAModuleMSG): + r"""Pointnet set abstrction layer + + Parameters + ---------- + npoint : int + Number of features + radius : float + Radius of ball + nsample : int + Number of samples in the ball query + mlp : list + Spec of the pointnet before the global max_pool + bn : bool + Use batchnorm + """ + + def __init__( + self, + *, + mlp: List[int], + npoint: int = None, + radius: float = None, + nsample: int = None, + bn: bool = True, + use_xyz: bool = True + ): + super().__init__( + mlps=[mlp], + npoint=npoint, + radii=[radius], + nsamples=[nsample], + bn=bn, + use_xyz=use_xyz + ) + + +class PointnetSAModuleVotes(nn.Module): + ''' Modified based on _PointnetSAModuleBase and PointnetSAModuleMSG + with extra support for returning point indices for getting their GT votes ''' + + def __init__( + self, + *, + mlp: List[int], + npoint: int = None, + radius: float = None, + nsample: int = None, + bn: bool = True, + use_xyz: bool = True, + pooling: str = 'max', + sigma: float = None, # for RBF pooling + normalize_xyz: bool = False, # noramlize local XYZ with radius + sample_uniformly: bool = False, + ret_unique_cnt: bool = False + ): + super().__init__() + + self.npoint = npoint + self.radius = radius + self.nsample = nsample + self.pooling = pooling + self.mlp_module = None + self.use_xyz = use_xyz + self.sigma = sigma + if self.sigma is None: + self.sigma = self.radius/2 + self.normalize_xyz = normalize_xyz + self.ret_unique_cnt = ret_unique_cnt + + if npoint is not None: + self.grouper = pointnet2_utils.QueryAndGroup(radius, nsample, + use_xyz=use_xyz, ret_grouped_xyz=True, normalize_xyz=normalize_xyz, + sample_uniformly=sample_uniformly, ret_unique_cnt=ret_unique_cnt) + else: + self.grouper = pointnet2_utils.GroupAll(use_xyz, ret_grouped_xyz=True) + + mlp_spec = mlp + if use_xyz and len(mlp_spec)>0: + mlp_spec[0] += 3 + self.mlp_module = pt_utils.SharedMLP(mlp_spec, bn=bn) + + + def forward(self, xyz: torch.Tensor, + features: torch.Tensor = None, + inds: torch.Tensor = None) -> (torch.Tensor, torch.Tensor): + r""" + Parameters + ---------- + xyz : torch.Tensor + (B, N, 3) tensor of the xyz coordinates of the features + features : torch.Tensor + (B, C, N) tensor of the descriptors of the the features + inds : torch.Tensor + (B, npoint) tensor that stores index to the xyz points (values in 0-N-1) + + Returns + ------- + new_xyz : torch.Tensor + (B, npoint, 3) tensor of the new features' xyz + new_features : torch.Tensor + (B, \sum_k(mlps[k][-1]), npoint) tensor of the new_features descriptors + inds: torch.Tensor + (B, npoint) tensor of the inds + """ + + xyz_flipped = xyz.transpose(1, 2).contiguous() + if inds is None: + inds = pointnet2_utils.furthest_point_sample(xyz, self.npoint) + else: + assert(inds.shape[1] == self.npoint) + new_xyz = pointnet2_utils.gather_operation( + xyz_flipped, inds + ).transpose(1, 2).contiguous() if self.npoint is not None else None + + if not self.ret_unique_cnt: + grouped_features, grouped_xyz = self.grouper( + xyz, new_xyz, features + ) # (B, C, npoint, nsample) + else: + grouped_features, grouped_xyz, unique_cnt = self.grouper( + xyz, new_xyz, features + ) # (B, C, npoint, nsample), (B,3,npoint,nsample), (B,npoint) + + new_features = self.mlp_module( + grouped_features + ) # (B, mlp[-1], npoint, nsample) + if self.pooling == 'max': + new_features = F.max_pool2d( + new_features, kernel_size=[1, new_features.size(3)] + ) # (B, mlp[-1], npoint, 1) + elif self.pooling == 'avg': + new_features = F.avg_pool2d( + new_features, kernel_size=[1, new_features.size(3)] + ) # (B, mlp[-1], npoint, 1) + elif self.pooling == 'rbf': + # Use radial basis function kernel for weighted sum of features (normalized by nsample and sigma) + # Ref: https://en.wikipedia.org/wiki/Radial_basis_function_kernel + rbf = torch.exp(-1 * grouped_xyz.pow(2).sum(1,keepdim=False) / (self.sigma**2) / 2) # (B, npoint, nsample) + new_features = torch.sum(new_features * rbf.unsqueeze(1), -1, keepdim=True) / float(self.nsample) # (B, mlp[-1], npoint, 1) + new_features = new_features.squeeze(-1) # (B, mlp[-1], npoint) + + if not self.ret_unique_cnt: + return new_xyz, new_features, inds + else: + return new_xyz, new_features, inds, unique_cnt + +class PointnetSAModuleMSGVotes(nn.Module): + ''' Modified based on _PointnetSAModuleBase and PointnetSAModuleMSG + with extra support for returning point indices for getting their GT votes ''' + + def __init__( + self, + *, + mlps: List[List[int]], + npoint: int, + radii: List[float], + nsamples: List[int], + bn: bool = True, + use_xyz: bool = True, + sample_uniformly: bool = False + ): + super().__init__() + + assert(len(mlps) == len(nsamples) == len(radii)) + + self.npoint = npoint + self.groupers = nn.ModuleList() + self.mlps = nn.ModuleList() + for i in range(len(radii)): + radius = radii[i] + nsample = nsamples[i] + self.groupers.append( + pointnet2_utils.QueryAndGroup(radius, nsample, use_xyz=use_xyz, sample_uniformly=sample_uniformly) + if npoint is not None else pointnet2_utils.GroupAll(use_xyz) + ) + mlp_spec = mlps[i] + if use_xyz: + mlp_spec[0] += 3 + + self.mlps.append(pt_utils.SharedMLP(mlp_spec, bn=bn)) + + def forward(self, xyz: torch.Tensor, + features: torch.Tensor = None, inds: torch.Tensor = None) -> (torch.Tensor, torch.Tensor): + r""" + Parameters + ---------- + xyz : torch.Tensor + (B, N, 3) tensor of the xyz coordinates of the features + features : torch.Tensor + (B, C, C) tensor of the descriptors of the the features + inds : torch.Tensor + (B, npoint) tensor that stores index to the xyz points (values in 0-N-1) + + Returns + ------- + new_xyz : torch.Tensor + (B, npoint, 3) tensor of the new features' xyz + new_features : torch.Tensor + (B, \sum_k(mlps[k][-1]), npoint) tensor of the new_features descriptors + inds: torch.Tensor + (B, npoint) tensor of the inds + """ + new_features_list = [] + + xyz_flipped = xyz.transpose(1, 2).contiguous() + if inds is None: + inds = pointnet2_utils.furthest_point_sample(xyz, self.npoint) + new_xyz = pointnet2_utils.gather_operation( + xyz_flipped, inds + ).transpose(1, 2).contiguous() if self.npoint is not None else None + + for i in range(len(self.groupers)): + new_features = self.groupers[i]( + xyz, new_xyz, features + ) # (B, C, npoint, nsample) + new_features = self.mlps[i]( + new_features + ) # (B, mlp[-1], npoint, nsample) + new_features = F.max_pool2d( + new_features, kernel_size=[1, new_features.size(3)] + ) # (B, mlp[-1], npoint, 1) + new_features = new_features.squeeze(-1) # (B, mlp[-1], npoint) + + new_features_list.append(new_features) + + return new_xyz, torch.cat(new_features_list, dim=1), inds + + +class PointnetFPModule(nn.Module): + r"""Propigates the features of one set to another + + Parameters + ---------- + mlp : list + Pointnet module parameters + bn : bool + Use batchnorm + """ + + def __init__(self, *, mlp: List[int], bn: bool = True): + super().__init__() + self.mlp = pt_utils.SharedMLP(mlp, bn=bn) + + def forward( + self, unknown: torch.Tensor, known: torch.Tensor, + unknow_feats: torch.Tensor, known_feats: torch.Tensor + ) -> torch.Tensor: + r""" + Parameters + ---------- + unknown : torch.Tensor + (B, n, 3) tensor of the xyz positions of the unknown features + known : torch.Tensor + (B, m, 3) tensor of the xyz positions of the known features + unknow_feats : torch.Tensor + (B, C1, n) tensor of the features to be propigated to + known_feats : torch.Tensor + (B, C2, m) tensor of features to be propigated + + Returns + ------- + new_features : torch.Tensor + (B, mlp[-1], n) tensor of the features of the unknown features + """ + + if known is not None: + dist, idx = pointnet2_utils.three_nn(unknown, known) + dist_recip = 1.0 / (dist + 1e-8) + norm = torch.sum(dist_recip, dim=2, keepdim=True) + weight = dist_recip / norm + + interpolated_feats = pointnet2_utils.three_interpolate( + known_feats, idx, weight + ) + else: + interpolated_feats = known_feats.expand( + *known_feats.size()[0:2], unknown.size(1) + ) + + if unknow_feats is not None: + new_features = torch.cat([interpolated_feats, unknow_feats], + dim=1) #(B, C2 + C1, n) + else: + new_features = interpolated_feats + + new_features = new_features.unsqueeze(-1) + new_features = self.mlp(new_features) + + return new_features.squeeze(-1) + +class PointnetLFPModuleMSG(nn.Module): + ''' Modified based on _PointnetSAModuleBase and PointnetSAModuleMSG + learnable feature propagation layer.''' + + def __init__( + self, + *, + mlps: List[List[int]], + radii: List[float], + nsamples: List[int], + post_mlp: List[int], + bn: bool = True, + use_xyz: bool = True, + sample_uniformly: bool = False + ): + super().__init__() + + assert(len(mlps) == len(nsamples) == len(radii)) + + self.post_mlp = pt_utils.SharedMLP(post_mlp, bn=bn) + + self.groupers = nn.ModuleList() + self.mlps = nn.ModuleList() + for i in range(len(radii)): + radius = radii[i] + nsample = nsamples[i] + self.groupers.append( + pointnet2_utils.QueryAndGroup(radius, nsample, use_xyz=use_xyz, + sample_uniformly=sample_uniformly) + ) + mlp_spec = mlps[i] + if use_xyz: + mlp_spec[0] += 3 + + self.mlps.append(pt_utils.SharedMLP(mlp_spec, bn=bn)) + + def forward(self, xyz2: torch.Tensor, xyz1: torch.Tensor, + features2: torch.Tensor, features1: torch.Tensor) -> torch.Tensor: + r""" Propagate features from xyz1 to xyz2. + Parameters + ---------- + xyz2 : torch.Tensor + (B, N2, 3) tensor of the xyz coordinates of the features + xyz1 : torch.Tensor + (B, N1, 3) tensor of the xyz coordinates of the features + features2 : torch.Tensor + (B, C2, N2) tensor of the descriptors of the the features + features1 : torch.Tensor + (B, C1, N1) tensor of the descriptors of the the features + + Returns + ------- + new_features1 : torch.Tensor + (B, \sum_k(mlps[k][-1]), N1) tensor of the new_features descriptors + """ + new_features_list = [] + + for i in range(len(self.groupers)): + new_features = self.groupers[i]( + xyz1, xyz2, features1 + ) # (B, C1, N2, nsample) + new_features = self.mlps[i]( + new_features + ) # (B, mlp[-1], N2, nsample) + new_features = F.max_pool2d( + new_features, kernel_size=[1, new_features.size(3)] + ) # (B, mlp[-1], N2, 1) + new_features = new_features.squeeze(-1) # (B, mlp[-1], N2) + + if features2 is not None: + new_features = torch.cat([new_features, features2], + dim=1) #(B, mlp[-1] + C2, N2) + + new_features = new_features.unsqueeze(-1) + new_features = self.post_mlp(new_features) + + new_features_list.append(new_features) + + return torch.cat(new_features_list, dim=1).squeeze(-1) + + +if __name__ == "__main__": + from torch.autograd import Variable + torch.manual_seed(1) + torch.cuda.manual_seed_all(1) + xyz = Variable(torch.randn(2, 9, 3).cuda(), requires_grad=True) + xyz_feats = Variable(torch.randn(2, 9, 6).cuda(), requires_grad=True) + + test_module = PointnetSAModuleMSG( + npoint=2, radii=[5.0, 10.0], nsamples=[6, 3], mlps=[[9, 3], [9, 6]] + ) + test_module.cuda() + print(test_module(xyz, xyz_feats)) + + for _ in range(1): + _, new_features = test_module(xyz, xyz_feats) + new_features.backward( + torch.cuda.FloatTensor(*new_features.size()).fill_(1) + ) + print(new_features) + print(xyz.grad) diff --git a/third_party/tuntunclaw/graspnet-baseline/pointnet2/pointnet2_utils.py b/third_party/tuntunclaw/graspnet-baseline/pointnet2/pointnet2_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..45c4c860e7229db9537d7939ac6d0fa4ff40aa12 --- /dev/null +++ b/third_party/tuntunclaw/graspnet-baseline/pointnet2/pointnet2_utils.py @@ -0,0 +1,555 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +''' Modified based on: https://github.com/erikwijmans/Pointnet2_PyTorch ''' +from __future__ import ( + division, + absolute_import, + with_statement, + print_function, + unicode_literals, +) +import torch +from torch.autograd import Function +import torch.nn as nn +import pytorch_utils as pt_utils +import sys + +try: + import builtins +except: + import __builtin__ as builtins + +try: + import pointnet2._ext as _ext +except ImportError: + if not getattr(builtins, "__POINTNET2_SETUP__", False): + raise ImportError( + "Could not import _ext module.\n" + "Please see the setup instructions in the README: " + "https://github.com/erikwijmans/Pointnet2_PyTorch/blob/master/README.rst" + ) + +if False: + # Workaround for type hints without depending on the `typing` module + from typing import * + + +class RandomDropout(nn.Module): + def __init__(self, p=0.5, inplace=False): + super(RandomDropout, self).__init__() + self.p = p + self.inplace = inplace + + def forward(self, X): + theta = torch.Tensor(1).uniform_(0, self.p)[0] + return pt_utils.feature_dropout_no_scaling(X, theta, self.train, self.inplace) + + +class FurthestPointSampling(Function): + @staticmethod + def forward(ctx, xyz, npoint): + # type: (Any, torch.Tensor, int) -> torch.Tensor + r""" + Uses iterative furthest point sampling to select a set of npoint features that have the largest + minimum distance + + Parameters + ---------- + xyz : torch.Tensor + (B, N, 3) tensor where N > npoint + npoint : int32 + number of features in the sampled set + + Returns + ------- + torch.Tensor + (B, npoint) tensor containing the set + """ + return _ext.furthest_point_sampling(xyz, npoint) + + @staticmethod + def backward(xyz, a=None): + return None, None + + +furthest_point_sample = FurthestPointSampling.apply + + +class GatherOperation(Function): + @staticmethod + def forward(ctx, features, idx): + # type: (Any, torch.Tensor, torch.Tensor) -> torch.Tensor + r""" + + Parameters + ---------- + features : torch.Tensor + (B, C, N) tensor + + idx : torch.Tensor + (B, npoint) tensor of the features to gather + + Returns + ------- + torch.Tensor + (B, C, npoint) tensor + """ + + _, C, N = features.size() + + ctx.for_backwards = (idx, C, N) + + return _ext.gather_points(features, idx) + + @staticmethod + def backward(ctx, grad_out): + idx, C, N = ctx.for_backwards + + grad_features = _ext.gather_points_grad(grad_out.contiguous(), idx, N) + return grad_features, None + + +gather_operation = GatherOperation.apply + + +class ThreeNN(Function): + @staticmethod + def forward(ctx, unknown, known): + # type: (Any, torch.Tensor, torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor] + r""" + Find the three nearest neighbors of unknown in known + Parameters + ---------- + unknown : torch.Tensor + (B, n, 3) tensor of known features + known : torch.Tensor + (B, m, 3) tensor of unknown features + + Returns + ------- + dist : torch.Tensor + (B, n, 3) l2 distance to the three nearest neighbors + idx : torch.Tensor + (B, n, 3) index of 3 nearest neighbors + """ + dist2, idx = _ext.three_nn(unknown, known) + + return torch.sqrt(dist2), idx + + @staticmethod + def backward(ctx, a=None, b=None): + return None, None + + +three_nn = ThreeNN.apply + + +class ThreeInterpolate(Function): + @staticmethod + def forward(ctx, features, idx, weight): + # type(Any, torch.Tensor, torch.Tensor, torch.Tensor) -> Torch.Tensor + r""" + Performs weight linear interpolation on 3 features + Parameters + ---------- + features : torch.Tensor + (B, c, m) Features descriptors to be interpolated from + idx : torch.Tensor + (B, n, 3) three nearest neighbors of the target features in features + weight : torch.Tensor + (B, n, 3) weights + + Returns + ------- + torch.Tensor + (B, c, n) tensor of the interpolated features + """ + B, c, m = features.size() + n = idx.size(1) + + ctx.three_interpolate_for_backward = (idx, weight, m) + + return _ext.three_interpolate(features, idx, weight) + + @staticmethod + def backward(ctx, grad_out): + # type: (Any, torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor] + r""" + Parameters + ---------- + grad_out : torch.Tensor + (B, c, n) tensor with gradients of ouputs + + Returns + ------- + grad_features : torch.Tensor + (B, c, m) tensor with gradients of features + + None + + None + """ + idx, weight, m = ctx.three_interpolate_for_backward + + grad_features = _ext.three_interpolate_grad( + grad_out.contiguous(), idx, weight, m + ) + + return grad_features, None, None + + +three_interpolate = ThreeInterpolate.apply + + +class GroupingOperation(Function): + @staticmethod + def forward(ctx, features, idx): + # type: (Any, torch.Tensor, torch.Tensor) -> torch.Tensor + r""" + + Parameters + ---------- + features : torch.Tensor + (B, C, N) tensor of features to group + idx : torch.Tensor + (B, npoint, nsample) tensor containing the indicies of features to group with + + Returns + ------- + torch.Tensor + (B, C, npoint, nsample) tensor + """ + B, nfeatures, nsample = idx.size() + _, C, N = features.size() + + ctx.for_backwards = (idx, N) + + return _ext.group_points(features, idx) + + @staticmethod + def backward(ctx, grad_out): + # type: (Any, torch.tensor) -> Tuple[torch.Tensor, torch.Tensor] + r""" + + Parameters + ---------- + grad_out : torch.Tensor + (B, C, npoint, nsample) tensor of the gradients of the output from forward + + Returns + ------- + torch.Tensor + (B, C, N) gradient of the features + None + """ + idx, N = ctx.for_backwards + + grad_features = _ext.group_points_grad(grad_out.contiguous(), idx, N) + + return grad_features, None + + +grouping_operation = GroupingOperation.apply + + +class BallQuery(Function): + @staticmethod + def forward(ctx, radius, nsample, xyz, new_xyz): + # type: (Any, float, int, torch.Tensor, torch.Tensor) -> torch.Tensor + r""" + + Parameters + ---------- + radius : float + radius of the balls + nsample : int + maximum number of features in the balls + xyz : torch.Tensor + (B, N, 3) xyz coordinates of the features + new_xyz : torch.Tensor + (B, npoint, 3) centers of the ball query + + Returns + ------- + torch.Tensor + (B, npoint, nsample) tensor with the indicies of the features that form the query balls + """ + return _ext.ball_query(new_xyz, xyz, radius, nsample) + + @staticmethod + def backward(ctx, a=None): + return None, None, None, None + + +ball_query = BallQuery.apply + + +class QueryAndGroup(nn.Module): + r""" + Groups with a ball query of radius + + Parameters + --------- + radius : float32 + Radius of ball + nsample : int32 + Maximum number of features to gather in the ball + """ + + def __init__(self, radius, nsample, use_xyz=True, ret_grouped_xyz=False, normalize_xyz=False, sample_uniformly=False, ret_unique_cnt=False): + # type: (QueryAndGroup, float, int, bool) -> None + super(QueryAndGroup, self).__init__() + self.radius, self.nsample, self.use_xyz = radius, nsample, use_xyz + self.ret_grouped_xyz = ret_grouped_xyz + self.normalize_xyz = normalize_xyz + self.sample_uniformly = sample_uniformly + self.ret_unique_cnt = ret_unique_cnt + if self.ret_unique_cnt: + assert(self.sample_uniformly) + + def forward(self, xyz, new_xyz, features=None): + # type: (QueryAndGroup, torch.Tensor. torch.Tensor, torch.Tensor) -> Tuple[Torch.Tensor] + r""" + Parameters + ---------- + xyz : torch.Tensor + xyz coordinates of the features (B, N, 3) + new_xyz : torch.Tensor + centriods (B, npoint, 3) + features : torch.Tensor + Descriptors of the features (B, C, N) + + Returns + ------- + new_features : torch.Tensor + (B, 3 + C, npoint, nsample) tensor + """ + idx = ball_query(self.radius, self.nsample, xyz, new_xyz) + + if self.sample_uniformly: + unique_cnt = torch.zeros((idx.shape[0], idx.shape[1])) + for i_batch in range(idx.shape[0]): + for i_region in range(idx.shape[1]): + unique_ind = torch.unique(idx[i_batch, i_region, :]) + num_unique = unique_ind.shape[0] + unique_cnt[i_batch, i_region] = num_unique + sample_ind = torch.randint(0, num_unique, (self.nsample - num_unique,), dtype=torch.long) + all_ind = torch.cat((unique_ind, unique_ind[sample_ind])) + idx[i_batch, i_region, :] = all_ind + + + xyz_trans = xyz.transpose(1, 2).contiguous() + grouped_xyz = grouping_operation(xyz_trans, idx) # (B, 3, npoint, nsample) + grouped_xyz -= new_xyz.transpose(1, 2).unsqueeze(-1) + if self.normalize_xyz: + grouped_xyz /= self.radius + + if features is not None: + grouped_features = grouping_operation(features, idx) + if self.use_xyz: + new_features = torch.cat( + [grouped_xyz, grouped_features], dim=1 + ) # (B, C + 3, npoint, nsample) + else: + new_features = grouped_features + else: + assert ( + self.use_xyz + ), "Cannot have not features and not use xyz as a feature!" + new_features = grouped_xyz + + ret = [new_features] + if self.ret_grouped_xyz: + ret.append(grouped_xyz) + if self.ret_unique_cnt: + ret.append(unique_cnt) + if len(ret) == 1: + return ret[0] + else: + return tuple(ret) + + +class GroupAll(nn.Module): + r""" + Groups all features + + Parameters + --------- + """ + + def __init__(self, use_xyz=True, ret_grouped_xyz=False): + # type: (GroupAll, bool) -> None + super(GroupAll, self).__init__() + self.use_xyz = use_xyz + + def forward(self, xyz, new_xyz, features=None): + # type: (GroupAll, torch.Tensor, torch.Tensor, torch.Tensor) -> Tuple[torch.Tensor] + r""" + Parameters + ---------- + xyz : torch.Tensor + xyz coordinates of the features (B, N, 3) + new_xyz : torch.Tensor + Ignored + features : torch.Tensor + Descriptors of the features (B, C, N) + + Returns + ------- + new_features : torch.Tensor + (B, C + 3, 1, N) tensor + """ + + grouped_xyz = xyz.transpose(1, 2).unsqueeze(2) + if features is not None: + grouped_features = features.unsqueeze(2) + if self.use_xyz: + new_features = torch.cat( + [grouped_xyz, grouped_features], dim=1 + ) # (B, 3 + C, 1, N) + else: + new_features = grouped_features + else: + new_features = grouped_xyz + + if self.ret_grouped_xyz: + return new_features, grouped_xyz + else: + return new_features + + +class CylinderQuery(Function): + @staticmethod + def forward(ctx, radius, hmin, hmax, nsample, xyz, new_xyz, rot): + # type: (Any, float, float, float, int, torch.Tensor, torch.Tensor, torch.Tensor) -> torch.Tensor + r""" + + Parameters + ---------- + radius : float + radius of the cylinders + hmin, hmax : float + endpoints of cylinder height in x-rotation axis + nsample : int + maximum number of features in the cylinders + xyz : torch.Tensor + (B, N, 3) xyz coordinates of the features + new_xyz : torch.Tensor + (B, npoint, 3) centers of the cylinder query + rot: torch.Tensor + (B, npoint, 9) flatten rotation matrices from + cylinder frame to world frame + + Returns + ------- + torch.Tensor + (B, npoint, nsample) tensor with the indicies of the features that form the query balls + """ + return _ext.cylinder_query(new_xyz, xyz, rot, radius, hmin, hmax, nsample) + + @staticmethod + def backward(ctx, a=None): + return None, None, None, None, None, None, None + + +cylinder_query = CylinderQuery.apply + + +class CylinderQueryAndGroup(nn.Module): + r""" + Groups with a cylinder query of radius and height + + Parameters + --------- + radius : float32 + Radius of cylinder + hmin, hmax: float32 + endpoints of cylinder height in x-rotation axis + nsample : int32 + Maximum number of features to gather in the ball + """ + + def __init__(self, radius, hmin, hmax, nsample, use_xyz=True, ret_grouped_xyz=False, normalize_xyz=False, rotate_xyz=True, sample_uniformly=False, ret_unique_cnt=False): + # type: (CylinderQueryAndGroup, float, float, float, int, bool) -> None + super(CylinderQueryAndGroup, self).__init__() + self.radius, self.nsample, self.hmin, self.hmax, = radius, nsample, hmin, hmax + self.use_xyz = use_xyz + self.ret_grouped_xyz = ret_grouped_xyz + self.normalize_xyz = normalize_xyz + self.rotate_xyz = rotate_xyz + self.sample_uniformly = sample_uniformly + self.ret_unique_cnt = ret_unique_cnt + if self.ret_unique_cnt: + assert(self.sample_uniformly) + + def forward(self, xyz, new_xyz, rot, features=None): + # type: (QueryAndGroup, torch.Tensor. torch.Tensor, torch.Tensor) -> Tuple[Torch.Tensor] + r""" + Parameters + ---------- + xyz : torch.Tensor + xyz coordinates of the features (B, N, 3) + new_xyz : torch.Tensor + centriods (B, npoint, 3) + rot : torch.Tensor + rotation matrices (B, npoint, 3, 3) + features : torch.Tensor + Descriptors of the features (B, C, N) + + Returns + ------- + new_features : torch.Tensor + (B, 3 + C, npoint, nsample) tensor + """ + B, npoint, _ = new_xyz.size() + idx = cylinder_query(self.radius, self.hmin, self.hmax, self.nsample, xyz, new_xyz, rot.view(B, npoint, 9)) + + if self.sample_uniformly: + unique_cnt = torch.zeros((idx.shape[0], idx.shape[1])) + for i_batch in range(idx.shape[0]): + for i_region in range(idx.shape[1]): + unique_ind = torch.unique(idx[i_batch, i_region, :]) + num_unique = unique_ind.shape[0] + unique_cnt[i_batch, i_region] = num_unique + sample_ind = torch.randint(0, num_unique, (self.nsample - num_unique,), dtype=torch.long) + all_ind = torch.cat((unique_ind, unique_ind[sample_ind])) + idx[i_batch, i_region, :] = all_ind + + + xyz_trans = xyz.transpose(1, 2).contiguous() + grouped_xyz = grouping_operation(xyz_trans, idx) # (B, 3, npoint, nsample) + grouped_xyz -= new_xyz.transpose(1, 2).unsqueeze(-1) + if self.normalize_xyz: + grouped_xyz /= self.radius + if self.rotate_xyz: + grouped_xyz_ = grouped_xyz.permute(0, 2, 3, 1).contiguous() # (B, npoint, nsample, 3) + grouped_xyz_ = torch.matmul(grouped_xyz_, rot) + grouped_xyz = grouped_xyz_.permute(0, 3, 1, 2).contiguous() + + + if features is not None: + grouped_features = grouping_operation(features, idx) + if self.use_xyz: + new_features = torch.cat( + [grouped_xyz, grouped_features], dim=1 + ) # (B, C + 3, npoint, nsample) + else: + new_features = grouped_features + else: + assert ( + self.use_xyz + ), "Cannot have not features and not use xyz as a feature!" + new_features = grouped_xyz + + ret = [new_features] + if self.ret_grouped_xyz: + ret.append(grouped_xyz) + if self.ret_unique_cnt: + ret.append(unique_cnt) + if len(ret) == 1: + return ret[0] + else: + return tuple(ret) \ No newline at end of file diff --git a/third_party/tuntunclaw/graspnet-baseline/pointnet2/pytorch_utils.py b/third_party/tuntunclaw/graspnet-baseline/pointnet2/pytorch_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..b9c9263709d1f3075f22025f7e64b4f1b186c721 --- /dev/null +++ b/third_party/tuntunclaw/graspnet-baseline/pointnet2/pytorch_utils.py @@ -0,0 +1,298 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +''' Modified based on Ref: https://github.com/erikwijmans/Pointnet2_PyTorch ''' +import torch +import torch.nn as nn +from typing import List, Tuple + +class SharedMLP(nn.Sequential): + + def __init__( + self, + args: List[int], + *, + bn: bool = False, + activation=nn.ReLU(inplace=True), + preact: bool = False, + first: bool = False, + name: str = "" + ): + super().__init__() + + for i in range(len(args) - 1): + self.add_module( + name + 'layer{}'.format(i), + Conv2d( + args[i], + args[i + 1], + bn=(not first or not preact or (i != 0)) and bn, + activation=activation + if (not first or not preact or (i != 0)) else None, + preact=preact + ) + ) + + +class _BNBase(nn.Sequential): + + def __init__(self, in_size, batch_norm=None, name=""): + super().__init__() + self.add_module(name + "bn", batch_norm(in_size)) + + nn.init.constant_(self[0].weight, 1.0) + nn.init.constant_(self[0].bias, 0) + + +class BatchNorm1d(_BNBase): + + def __init__(self, in_size: int, *, name: str = ""): + super().__init__(in_size, batch_norm=nn.BatchNorm1d, name=name) + + +class BatchNorm2d(_BNBase): + + def __init__(self, in_size: int, name: str = ""): + super().__init__(in_size, batch_norm=nn.BatchNorm2d, name=name) + + +class BatchNorm3d(_BNBase): + + def __init__(self, in_size: int, name: str = ""): + super().__init__(in_size, batch_norm=nn.BatchNorm3d, name=name) + + +class _ConvBase(nn.Sequential): + + def __init__( + self, + in_size, + out_size, + kernel_size, + stride, + padding, + activation, + bn, + init, + conv=None, + batch_norm=None, + bias=True, + preact=False, + name="" + ): + super().__init__() + + bias = bias and (not bn) + conv_unit = conv( + in_size, + out_size, + kernel_size=kernel_size, + stride=stride, + padding=padding, + bias=bias + ) + init(conv_unit.weight) + if bias: + nn.init.constant_(conv_unit.bias, 0) + + if bn: + if not preact: + bn_unit = batch_norm(out_size) + else: + bn_unit = batch_norm(in_size) + + if preact: + if bn: + self.add_module(name + 'bn', bn_unit) + + if activation is not None: + self.add_module(name + 'activation', activation) + + self.add_module(name + 'conv', conv_unit) + + if not preact: + if bn: + self.add_module(name + 'bn', bn_unit) + + if activation is not None: + self.add_module(name + 'activation', activation) + + +class Conv1d(_ConvBase): + + def __init__( + self, + in_size: int, + out_size: int, + *, + kernel_size: int = 1, + stride: int = 1, + padding: int = 0, + activation=nn.ReLU(inplace=True), + bn: bool = False, + init=nn.init.kaiming_normal_, + bias: bool = True, + preact: bool = False, + name: str = "" + ): + super().__init__( + in_size, + out_size, + kernel_size, + stride, + padding, + activation, + bn, + init, + conv=nn.Conv1d, + batch_norm=BatchNorm1d, + bias=bias, + preact=preact, + name=name + ) + + +class Conv2d(_ConvBase): + + def __init__( + self, + in_size: int, + out_size: int, + *, + kernel_size: Tuple[int, int] = (1, 1), + stride: Tuple[int, int] = (1, 1), + padding: Tuple[int, int] = (0, 0), + activation=nn.ReLU(inplace=True), + bn: bool = False, + init=nn.init.kaiming_normal_, + bias: bool = True, + preact: bool = False, + name: str = "" + ): + super().__init__( + in_size, + out_size, + kernel_size, + stride, + padding, + activation, + bn, + init, + conv=nn.Conv2d, + batch_norm=BatchNorm2d, + bias=bias, + preact=preact, + name=name + ) + + +class Conv3d(_ConvBase): + + def __init__( + self, + in_size: int, + out_size: int, + *, + kernel_size: Tuple[int, int, int] = (1, 1, 1), + stride: Tuple[int, int, int] = (1, 1, 1), + padding: Tuple[int, int, int] = (0, 0, 0), + activation=nn.ReLU(inplace=True), + bn: bool = False, + init=nn.init.kaiming_normal_, + bias: bool = True, + preact: bool = False, + name: str = "" + ): + super().__init__( + in_size, + out_size, + kernel_size, + stride, + padding, + activation, + bn, + init, + conv=nn.Conv3d, + batch_norm=BatchNorm3d, + bias=bias, + preact=preact, + name=name + ) + + +class FC(nn.Sequential): + + def __init__( + self, + in_size: int, + out_size: int, + *, + activation=nn.ReLU(inplace=True), + bn: bool = False, + init=None, + preact: bool = False, + name: str = "" + ): + super().__init__() + + fc = nn.Linear(in_size, out_size, bias=not bn) + if init is not None: + init(fc.weight) + if not bn: + nn.init.constant_(fc.bias, 0) + + if preact: + if bn: + self.add_module(name + 'bn', BatchNorm1d(in_size)) + + if activation is not None: + self.add_module(name + 'activation', activation) + + self.add_module(name + 'fc', fc) + + if not preact: + if bn: + self.add_module(name + 'bn', BatchNorm1d(out_size)) + + if activation is not None: + self.add_module(name + 'activation', activation) + +def set_bn_momentum_default(bn_momentum): + + def fn(m): + if isinstance(m, (nn.BatchNorm1d, nn.BatchNorm2d, nn.BatchNorm3d)): + m.momentum = bn_momentum + + return fn + + +class BNMomentumScheduler(object): + + def __init__( + self, model, bn_lambda, last_epoch=-1, + setter=set_bn_momentum_default + ): + if not isinstance(model, nn.Module): + raise RuntimeError( + "Class '{}' is not a PyTorch nn Module".format( + type(model).__name__ + ) + ) + + self.model = model + self.setter = setter + self.lmbd = bn_lambda + + self.step(last_epoch + 1) + self.last_epoch = last_epoch + + def step(self, epoch=None): + if epoch is None: + epoch = self.last_epoch + 1 + + self.last_epoch = epoch + self.model.apply(self.setter(self.lmbd(epoch))) + + diff --git a/third_party/tuntunclaw/graspnet-baseline/pointnet2/setup.py b/third_party/tuntunclaw/graspnet-baseline/pointnet2/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..12deacb35155709ffb214302a739c6dc87a2a6de --- /dev/null +++ b/third_party/tuntunclaw/graspnet-baseline/pointnet2/setup.py @@ -0,0 +1,33 @@ +# Copyright (c) Facebook, Inc. and its affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +from setuptools import setup +from torch.utils.cpp_extension import BuildExtension, CUDAExtension +import glob +import os +ROOT = os.path.dirname(os.path.abspath(__file__)) + +_ext_src_root = "_ext_src" +_ext_sources = glob.glob("{}/src/*.cpp".format(_ext_src_root)) + glob.glob( + "{}/src/*.cu".format(_ext_src_root) +) +_ext_headers = glob.glob("{}/include/*".format(_ext_src_root)) + +setup( + name='pointnet2', + ext_modules=[ + CUDAExtension( + name='pointnet2._ext', + sources=_ext_sources, + extra_compile_args={ + "cxx": ["-O2", "-I{}".format("{}/{}/include".format(ROOT, _ext_src_root))], + "nvcc": ["-O2", "-I{}".format("{}/{}/include".format(ROOT, _ext_src_root))], + }, + ) + ], + cmdclass={ + 'build_ext': BuildExtension + } +) diff --git a/third_party/tuntunclaw/graspnet-baseline/requirements.txt b/third_party/tuntunclaw/graspnet-baseline/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..426f8c97f84bc1623a669c33ac290329a76aaf9a --- /dev/null +++ b/third_party/tuntunclaw/graspnet-baseline/requirements.txt @@ -0,0 +1,6 @@ +tensorboard +numpy==1.23.4 +scipy +open3d>=0.8 +Pillow +tqdm diff --git a/third_party/tuntunclaw/graspnet-baseline/test.py b/third_party/tuntunclaw/graspnet-baseline/test.py new file mode 100644 index 0000000000000000000000000000000000000000..6177d7d70a9e1d1462ea5995c8da7aef77084172 --- /dev/null +++ b/third_party/tuntunclaw/graspnet-baseline/test.py @@ -0,0 +1,118 @@ +""" Testing for GraspNet baseline model. """ + +import os +import sys +import numpy as np +import argparse +import time + +import torch +from torch.utils.data import DataLoader +from graspnetAPI import GraspGroup, GraspNetEval + +ROOT_DIR = os.path.dirname(os.path.abspath(__file__)) +sys.path.append(os.path.join(ROOT_DIR, 'models')) +sys.path.append(os.path.join(ROOT_DIR, 'dataset')) +sys.path.append(os.path.join(ROOT_DIR, 'utils')) + +from graspnet import GraspNet, pred_decode +from graspnet_dataset import GraspNetDataset, collate_fn +from collision_detector import ModelFreeCollisionDetector + +parser = argparse.ArgumentParser() +parser.add_argument('--dataset_root', required=True, help='Dataset root') +parser.add_argument('--checkpoint_path', required=True, help='Model checkpoint path') +parser.add_argument('--dump_dir', required=True, help='Dump dir to save outputs') +parser.add_argument('--camera', required=True, help='Camera split [realsense/kinect]') +parser.add_argument('--num_point', type=int, default=20000, help='Point Number [default: 20000]') +parser.add_argument('--num_view', type=int, default=300, help='View Number [default: 300]') +parser.add_argument('--batch_size', type=int, default=1, help='Batch Size during inference [default: 1]') +parser.add_argument('--collision_thresh', type=float, default=0.01, help='Collision Threshold in collision detection [default: 0.01]') +parser.add_argument('--voxel_size', type=float, default=0.01, help='Voxel Size to process point clouds before collision detection [default: 0.01]') +parser.add_argument('--num_workers', type=int, default=30, help='Number of workers used in evaluation [default: 30]') +cfgs = parser.parse_args() + +# ------------------------------------------------------------------------- GLOBAL CONFIG BEG +if not os.path.exists(cfgs.dump_dir): os.mkdir(cfgs.dump_dir) + +# Init datasets and dataloaders +def my_worker_init_fn(worker_id): + np.random.seed(np.random.get_state()[1][0] + worker_id) + pass + +# Create Dataset and Dataloader +TEST_DATASET = GraspNetDataset(cfgs.dataset_root, valid_obj_idxs=None, grasp_labels=None, split='test', camera=cfgs.camera, num_points=cfgs.num_point, remove_outlier=True, augment=False, load_label=False) + +print(len(TEST_DATASET)) +SCENE_LIST = TEST_DATASET.scene_list() +TEST_DATALOADER = DataLoader(TEST_DATASET, batch_size=cfgs.batch_size, shuffle=False, + num_workers=4, worker_init_fn=my_worker_init_fn, collate_fn=collate_fn) +print(len(TEST_DATALOADER)) +# Init the model +net = GraspNet(input_feature_dim=0, num_view=cfgs.num_view, num_angle=12, num_depth=4, + cylinder_radius=0.05, hmin=-0.02, hmax_list=[0.01,0.02,0.03,0.04], is_training=False) +device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") +net.to(device) +# Load checkpoint +checkpoint = torch.load(cfgs.checkpoint_path) +net.load_state_dict(checkpoint['model_state_dict']) +start_epoch = checkpoint['epoch'] +print("-> loaded checkpoint %s (epoch: %d)"%(cfgs.checkpoint_path, start_epoch)) + + +# ------------------------------------------------------------------------- GLOBAL CONFIG END + +def inference(): + batch_interval = 100 + stat_dict = {} # collect statistics + # set model to eval mode (for bn and dp) + net.eval() + tic = time.time() + for batch_idx, batch_data in enumerate(TEST_DATALOADER): + for key in batch_data: + if 'list' in key: + for i in range(len(batch_data[key])): + for j in range(len(batch_data[key][i])): + batch_data[key][i][j] = batch_data[key][i][j].to(device) + else: + batch_data[key] = batch_data[key].to(device) + + # Forward pass + with torch.no_grad(): + end_points = net(batch_data) + grasp_preds = pred_decode(end_points) + + # Dump results for evaluation + for i in range(cfgs.batch_size): + data_idx = batch_idx * cfgs.batch_size + i + preds = grasp_preds[i].detach().cpu().numpy() + gg = GraspGroup(preds) + + # collision detection + if cfgs.collision_thresh > 0: + cloud, _ = TEST_DATASET.get_data(data_idx, return_raw_cloud=True) + mfcdetector = ModelFreeCollisionDetector(cloud, voxel_size=cfgs.voxel_size) + collision_mask = mfcdetector.detect(gg, approach_dist=0.05, collision_thresh=cfgs.collision_thresh) + gg = gg[~collision_mask] + + # save grasps + save_dir = os.path.join(cfgs.dump_dir, SCENE_LIST[data_idx], cfgs.camera) + save_path = os.path.join(save_dir, str(data_idx%256).zfill(4)+'.npy') + if not os.path.exists(save_dir): + os.makedirs(save_dir) + gg.save_npy(save_path) + + if batch_idx % batch_interval == 0: + toc = time.time() + print('Eval batch: %d, time: %fs'%(batch_idx, (toc-tic)/batch_interval)) + tic = time.time() + +def evaluate(): + ge = GraspNetEval(root=cfgs.dataset_root, camera=cfgs.camera, split='test') + res, ap = ge.eval_all(cfgs.dump_dir, proc=cfgs.num_workers) + save_dir = os.path.join(cfgs.dump_dir, 'ap_{}.npy'.format(cfgs.camera)) + np.save(save_dir, res) + +if __name__=='__main__': + inference() + evaluate() diff --git a/third_party/tuntunclaw/graspnet-baseline/train.py b/third_party/tuntunclaw/graspnet-baseline/train.py new file mode 100644 index 0000000000000000000000000000000000000000..2d33fba770ec7528e2b4a1291e9058d600b8b4dd --- /dev/null +++ b/third_party/tuntunclaw/graspnet-baseline/train.py @@ -0,0 +1,222 @@ +""" Training routine for GraspNet baseline model. """ + +import os +import sys +import numpy as np +from datetime import datetime +import argparse + +import torch +import torch.nn as nn +import torch.optim as optim +from torch.optim import lr_scheduler +from torch.utils.data import DataLoader +from torch.utils.tensorboard import SummaryWriter + +ROOT_DIR = os.path.dirname(os.path.abspath(__file__)) +sys.path.append(os.path.join(ROOT_DIR, 'utils')) +sys.path.append(os.path.join(ROOT_DIR, 'pointnet2')) +sys.path.append(os.path.join(ROOT_DIR, 'models')) +sys.path.append(os.path.join(ROOT_DIR, 'dataset')) +from graspnet import GraspNet, get_loss +from pytorch_utils import BNMomentumScheduler +from graspnet_dataset import GraspNetDataset, collate_fn, load_grasp_labels +from label_generation import process_grasp_labels + +parser = argparse.ArgumentParser() +parser.add_argument('--dataset_root', required=True, help='Dataset root') +parser.add_argument('--camera', required=True, help='Camera split [realsense/kinect]') +parser.add_argument('--checkpoint_path', default=None, help='Model checkpoint path [default: None]') +parser.add_argument('--log_dir', default='log', help='Dump dir to save model checkpoint [default: log]') +parser.add_argument('--num_point', type=int, default=20000, help='Point Number [default: 20000]') +parser.add_argument('--num_view', type=int, default=300, help='View Number [default: 300]') +parser.add_argument('--max_epoch', type=int, default=18, help='Epoch to run [default: 18]') +parser.add_argument('--batch_size', type=int, default=2, help='Batch Size during training [default: 2]') +parser.add_argument('--learning_rate', type=float, default=0.001, help='Initial learning rate [default: 0.001]') +parser.add_argument('--weight_decay', type=float, default=0, help='Optimization L2 weight decay [default: 0]') +parser.add_argument('--bn_decay_step', type=int, default=2, help='Period of BN decay (in epochs) [default: 2]') +parser.add_argument('--bn_decay_rate', type=float, default=0.5, help='Decay rate for BN decay [default: 0.5]') +parser.add_argument('--lr_decay_steps', default='8,12,16', help='When to decay the learning rate (in epochs) [default: 8,12,16]') +parser.add_argument('--lr_decay_rates', default='0.1,0.1,0.1', help='Decay rates for lr decay [default: 0.1,0.1,0.1]') +cfgs = parser.parse_args() + +# ------------------------------------------------------------------------- GLOBAL CONFIG BEG +EPOCH_CNT = 0 +LR_DECAY_STEPS = [int(x) for x in cfgs.lr_decay_steps.split(',')] +LR_DECAY_RATES = [float(x) for x in cfgs.lr_decay_rates.split(',')] +assert(len(LR_DECAY_STEPS)==len(LR_DECAY_RATES)) +DEFAULT_CHECKPOINT_PATH = os.path.join(cfgs.log_dir, 'checkpoint.tar') +CHECKPOINT_PATH = cfgs.checkpoint_path if cfgs.checkpoint_path is not None \ + else DEFAULT_CHECKPOINT_PATH + +if not os.path.exists(cfgs.log_dir): + os.makedirs(cfgs.log_dir) + +LOG_FOUT = open(os.path.join(cfgs.log_dir, 'log_train.txt'), 'a') +LOG_FOUT.write(str(cfgs)+'\n') +def log_string(out_str): + LOG_FOUT.write(out_str+'\n') + LOG_FOUT.flush() + print(out_str) + +# Init datasets and dataloaders +def my_worker_init_fn(worker_id): + np.random.seed(np.random.get_state()[1][0] + worker_id) + pass + +# Create Dataset and Dataloader +valid_obj_idxs, grasp_labels = load_grasp_labels(cfgs.dataset_root) +TRAIN_DATASET = GraspNetDataset(cfgs.dataset_root, valid_obj_idxs, grasp_labels, camera=cfgs.camera, split='train', num_points=cfgs.num_point, remove_outlier=True, augment=True) +TEST_DATASET = GraspNetDataset(cfgs.dataset_root, valid_obj_idxs, grasp_labels, camera=cfgs.camera, split='test_seen', num_points=cfgs.num_point, remove_outlier=True, augment=False) + +print(len(TRAIN_DATASET), len(TEST_DATASET)) +TRAIN_DATALOADER = DataLoader(TRAIN_DATASET, batch_size=cfgs.batch_size, shuffle=True, + num_workers=4, worker_init_fn=my_worker_init_fn, collate_fn=collate_fn) +TEST_DATALOADER = DataLoader(TEST_DATASET, batch_size=cfgs.batch_size, shuffle=False, + num_workers=4, worker_init_fn=my_worker_init_fn, collate_fn=collate_fn) +print(len(TRAIN_DATALOADER), len(TEST_DATALOADER)) +# Init the model and optimzier +net = GraspNet(input_feature_dim=0, num_view=cfgs.num_view, num_angle=12, num_depth=4, + cylinder_radius=0.05, hmin=-0.02, hmax_list=[0.01,0.02,0.03,0.04]) +device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") +net.to(device) +# Load the Adam optimizer +optimizer = optim.Adam(net.parameters(), lr=cfgs.learning_rate, weight_decay=cfgs.weight_decay) +# Load checkpoint if there is any +it = -1 # for the initialize value of `LambdaLR` and `BNMomentumScheduler` +start_epoch = 0 +if CHECKPOINT_PATH is not None and os.path.isfile(CHECKPOINT_PATH): + checkpoint = torch.load(CHECKPOINT_PATH) + net.load_state_dict(checkpoint['model_state_dict']) + optimizer.load_state_dict(checkpoint['optimizer_state_dict']) + start_epoch = checkpoint['epoch'] + log_string("-> loaded checkpoint %s (epoch: %d)"%(CHECKPOINT_PATH, start_epoch)) +# Decay Batchnorm momentum from 0.5 to 0.999 +# note: pytorch's BN momentum (default 0.1)= 1 - tensorflow's BN momentum +BN_MOMENTUM_INIT = 0.5 +BN_MOMENTUM_MAX = 0.001 +bn_lbmd = lambda it: max(BN_MOMENTUM_INIT * cfgs.bn_decay_rate**(int(it / cfgs.bn_decay_step)), BN_MOMENTUM_MAX) +bnm_scheduler = BNMomentumScheduler(net, bn_lambda=bn_lbmd, last_epoch=start_epoch-1) + + +def get_current_lr(epoch): + lr = cfgs.learning_rate + for i,lr_decay_epoch in enumerate(LR_DECAY_STEPS): + if epoch >= lr_decay_epoch: + lr *= LR_DECAY_RATES[i] + return lr + +def adjust_learning_rate(optimizer, epoch): + lr = get_current_lr(epoch) + for param_group in optimizer.param_groups: + param_group['lr'] = lr + +# TensorBoard Visualizers +TRAIN_WRITER = SummaryWriter(os.path.join(cfgs.log_dir, 'train')) +TEST_WRITER = SummaryWriter(os.path.join(cfgs.log_dir, 'test')) + +# ------------------------------------------------------------------------- GLOBAL CONFIG END + +def train_one_epoch(): + stat_dict = {} # collect statistics + adjust_learning_rate(optimizer, EPOCH_CNT) + bnm_scheduler.step() # decay BN momentum + # set model to training mode + net.train() + for batch_idx, batch_data_label in enumerate(TRAIN_DATALOADER): + for key in batch_data_label: + if 'list' in key: + for i in range(len(batch_data_label[key])): + for j in range(len(batch_data_label[key][i])): + batch_data_label[key][i][j] = batch_data_label[key][i][j].to(device) + else: + batch_data_label[key] = batch_data_label[key].to(device) + + # Forward pass + end_points = net(batch_data_label) + + # Compute loss and gradients, update parameters. + loss, end_points = get_loss(end_points) + loss.backward() + if (batch_idx+1) % 1 == 0: + optimizer.step() + optimizer.zero_grad() + + # Accumulate statistics and print out + for key in end_points: + if 'loss' in key or 'acc' in key or 'prec' in key or 'recall' in key or 'count' in key: + if key not in stat_dict: stat_dict[key] = 0 + stat_dict[key] += end_points[key].item() + + batch_interval = 10 + if (batch_idx+1) % batch_interval == 0: + log_string(' ---- batch: %03d ----' % (batch_idx+1)) + for key in sorted(stat_dict.keys()): + TRAIN_WRITER.add_scalar(key, stat_dict[key]/batch_interval, (EPOCH_CNT*len(TRAIN_DATALOADER)+batch_idx)*cfgs.batch_size) + log_string('mean %s: %f'%(key, stat_dict[key]/batch_interval)) + stat_dict[key] = 0 + +def evaluate_one_epoch(): + stat_dict = {} # collect statistics + # set model to eval mode (for bn and dp) + net.eval() + for batch_idx, batch_data_label in enumerate(TEST_DATALOADER): + if batch_idx % 10 == 0: + print('Eval batch: %d'%(batch_idx)) + for key in batch_data_label: + if 'list' in key: + for i in range(len(batch_data_label[key])): + for j in range(len(batch_data_label[key][i])): + batch_data_label[key][i][j] = batch_data_label[key][i][j].to(device) + else: + batch_data_label[key] = batch_data_label[key].to(device) + + # Forward pass + with torch.no_grad(): + end_points = net(batch_data_label) + + # Compute loss + loss, end_points = get_loss(end_points) + + # Accumulate statistics and print out + for key in end_points: + if 'loss' in key or 'acc' in key or 'prec' in key or 'recall' in key or 'count' in key: + if key not in stat_dict: stat_dict[key] = 0 + stat_dict[key] += end_points[key].item() + + for key in sorted(stat_dict.keys()): + TEST_WRITER.add_scalar(key, stat_dict[key]/float(batch_idx+1), (EPOCH_CNT+1)*len(TRAIN_DATALOADER)*cfgs.batch_size) + log_string('eval mean %s: %f'%(key, stat_dict[key]/(float(batch_idx+1)))) + + mean_loss = stat_dict['loss/overall_loss']/float(batch_idx+1) + return mean_loss + + +def train(start_epoch): + global EPOCH_CNT + min_loss = 1e10 + loss = 0 + for epoch in range(start_epoch, cfgs.max_epoch): + EPOCH_CNT = epoch + log_string('**** EPOCH %03d ****' % (epoch)) + log_string('Current learning rate: %f'%(get_current_lr(epoch))) + log_string('Current BN decay momentum: %f'%(bnm_scheduler.lmbd(bnm_scheduler.last_epoch))) + log_string(str(datetime.now())) + # Reset numpy seed. + # REF: https://github.com/pytorch/pytorch/issues/5059 + np.random.seed() + train_one_epoch() + loss = evaluate_one_epoch() + # Save checkpoint + save_dict = {'epoch': epoch+1, # after training one epoch, the start_epoch should be epoch+1 + 'optimizer_state_dict': optimizer.state_dict(), + 'loss': loss, + } + try: # with nn.DataParallel() the net is added as a submodule of DataParallel + save_dict['model_state_dict'] = net.module.state_dict() + except: + save_dict['model_state_dict'] = net.state_dict() + torch.save(save_dict, os.path.join(cfgs.log_dir, 'checkpoint.tar')) + +if __name__=='__main__': + train(start_epoch) diff --git a/third_party/tuntunclaw/integrations.py b/third_party/tuntunclaw/integrations.py new file mode 100644 index 0000000000000000000000000000000000000000..d802e5a9563f38e2f3c4b92eaf1b2cc3e8cad188 --- /dev/null +++ b/third_party/tuntunclaw/integrations.py @@ -0,0 +1,214 @@ +"""External integrations used by the OpenClaw demo.""" + +from __future__ import annotations + +import json +import os +import time +from dataclasses import dataclass +from functools import lru_cache +from pathlib import Path +from typing import Any +from urllib.error import HTTPError, URLError +from urllib.request import Request, urlopen + + +def _now_iso() -> str: + return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()) + + +def _env(name: str, default: str = "") -> str: + return os.getenv(name, default).strip() + + +def _load_openclaw_config() -> dict[str, Any]: + candidates = [ + Path(_env("OPENCLAW_CONFIG_PATH")) if _env("OPENCLAW_CONFIG_PATH") else None, + Path.home() / ".openclaw" / "openclaw.json", + ] + for candidate in candidates: + if candidate is None or not candidate.exists(): + continue + try: + return json.loads(candidate.read_text(encoding="utf-8")) + except Exception: + continue + return {} + + +def _openclaw_feishu_block() -> dict[str, Any]: + cfg = _load_openclaw_config() + return dict(((cfg.get("channels") or {}).get("feishu") or {})) + + +def _request_json( + url: str, + *, + payload: dict[str, Any] | None = None, + headers: dict[str, str] | None = None, + timeout: float = 10.0, +) -> dict[str, Any]: + data = None + if payload is not None: + data = json.dumps(payload, ensure_ascii=False).encode("utf-8") + req = Request(url, data=data, headers=headers or {}, method="POST" if payload is not None else "GET") + with urlopen(req, timeout=timeout) as resp: + raw = resp.read().decode("utf-8") + if not raw: + return {} + return json.loads(raw) + +@dataclass +class FeishuNotifier: + app_id: str = "" + app_secret: str = "" + target: str = "" + receive_id_type: str = "chat_id" + enabled: bool = True + token_ttl_seconds: int = 6600 + + _tenant_token: str = "" + _tenant_token_expiry: float = 0.0 + + @classmethod + def from_env(cls) -> "FeishuNotifier": + feishu_cfg = _openclaw_feishu_block() + app_id = _env("OPENCLAW_FEISHU_APP_ID") or str(feishu_cfg.get("appId") or "") + app_secret = _env("OPENCLAW_FEISHU_APP_SECRET") or str(feishu_cfg.get("appSecret") or "") + target = ( + _env("OPENCLAW_FEISHU_NOTIFY_TARGET") + or _env("OPENCLAW_FEISHU_TARGET") + or str(feishu_cfg.get("notifyTarget") or feishu_cfg.get("notify_target") or "") + ) + receive_id_type = ( + _env("OPENCLAW_FEISHU_NOTIFY_RECEIVE_ID_TYPE") + or _env("OPENCLAW_FEISHU_RECEIVE_ID_TYPE") + or str(feishu_cfg.get("notifyReceiveIdType") or feishu_cfg.get("receiveIdType") or "chat_id") + ) + enabled = _env("OPENCLAW_FEISHU_NOTIFY_ENABLED", "1").lower() not in {"0", "false", "no"} + return cls( + app_id=app_id, + app_secret=app_secret, + target=target, + receive_id_type=receive_id_type or "chat_id", + enabled=enabled, + ) + + def is_configured(self) -> bool: + return bool(self.enabled and self.app_id and self.app_secret and self.target) + + def _tenant_access_token(self) -> str: + if self._tenant_token and time.time() < self._tenant_token_expiry: + return self._tenant_token + + if not self.app_id or not self.app_secret: + raise RuntimeError("Feishu app credentials are missing") + + payload = {"app_id": self.app_id, "app_secret": self.app_secret} + response = _request_json( + "https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal", + payload=payload, + headers={"Content-Type": "application/json; charset=utf-8"}, + ) + if int(response.get("code", 1)) != 0: + raise RuntimeError(response.get("msg") or "failed to acquire tenant access token") + + token = str(response.get("tenant_access_token") or "") + if not token: + raise RuntimeError("tenant access token missing in Feishu response") + + expires = int(response.get("expire") or self.token_ttl_seconds) + self._tenant_token = token + self._tenant_token_expiry = time.time() + max(60, expires - 60) + return token + + def send_markdown( + self, + text: str, + *, + target: str | None = None, + receive_id_type: str | None = None, + ) -> dict[str, Any]: + if not self.is_configured(): + return {"ok": False, "reason": "feishu notifier not configured"} + + target_value = (target or self.target).strip() + receive_type = (receive_id_type or self.receive_id_type).strip() or "chat_id" + content = { + "zh_cn": { + "content": [[{"tag": "md", "text": text}]], + } + } + token = self._tenant_access_token() + response = _request_json( + f"https://open.feishu.cn/open-apis/im/v1/messages?receive_id_type={receive_type}", + payload={ + "receive_id": target_value, + "msg_type": "post", + "content": json.dumps(content, ensure_ascii=False), + }, + headers={ + "Authorization": f"Bearer {token}", + "Content-Type": "application/json; charset=utf-8", + }, + ) + if int(response.get("code", 1)) != 0: + raise RuntimeError(response.get("msg") or "failed to send feishu message") + data = response.get("data") or {} + return { + "ok": True, + "message_id": str(data.get("message_id") or ""), + "chat_id": str(data.get("chat_id") or ""), + "raw": response, + } + + def send_low_stock_alert(self, event: dict[str, Any]) -> dict[str, Any]: + if not self.is_configured(): + return {"ok": False, "reason": "feishu notifier not configured"} + + order_url = str(event.get("order_url") or "") + quantity = int(event.get("reorder_qty") or 1) + remaining = int(event.get("remaining") or 0) + threshold = int(event.get("threshold") or 0) + label = str(event.get("label") or event.get("sku") or "物资") + command = str(event.get("command") or "") + session_id = str(event.get("session_id") or "") + body = "\n".join( + [ + f"## 库存预警：{label} 低于阈值", + "", + f"- 当前剩余：{remaining}", + f"- 预设阈值：{threshold}", + f"- 建议补货：{quantity}", + ] + + ([f"- 来源命令：{command}"] if command else []) + + ([f"- 会话 ID：{session_id}"] if session_id else []) + + ([f"[一键下单]({order_url})"] if order_url else []) + ) + return self.send_markdown(body) + + +def post_json(url: str, payload: dict[str, Any], *, timeout: float = 8.0) -> dict[str, Any]: + response = _request_json( + url, + payload=payload, + headers={"Content-Type": "application/json; charset=utf-8"}, + timeout=timeout, + ) + return response + + +def notify_robot_backend(payload: dict[str, Any]) -> dict[str, Any]: + url = _env("OPENCLAW_ROBOT_WEBHOOK_URL") + if not url: + return {"ok": False, "reason": "robot webhook not configured"} + try: + response = post_json(url, payload) + return {"ok": True, "response": response} + except (HTTPError, URLError, TimeoutError, OSError, ValueError) as exc: + return {"ok": False, "reason": str(exc)} + + +@lru_cache(maxsize=1) +def get_feishu_notifier() -> FeishuNotifier: + return FeishuNotifier.from_env() diff --git a/third_party/tuntunclaw/inventory.py b/third_party/tuntunclaw/inventory.py new file mode 100644 index 0000000000000000000000000000000000000000..0ea62734b733c5578cfb42c8570dcdb0ae55dd84 --- /dev/null +++ b/third_party/tuntunclaw/inventory.py @@ -0,0 +1,417 @@ +"""Persistent inventory tracking for the OpenClaw demo workflow.""" + +from __future__ import annotations + +import json +import os +import threading +import time +import uuid +from copy import deepcopy +from dataclasses import dataclass +from pathlib import Path +from typing import Any +from urllib.parse import quote + + +def _now_iso() -> str: + return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()) + + +def _normalize_text(value: str | None) -> str: + return (value or "").strip().lower() + + +def _default_public_base() -> str: + host = os.getenv("OPENCLAW_WEB_HOST", "127.0.0.1").strip() + port = os.getenv("OPENCLAW_WEB_PORT", "8000").strip() + return ( + os.getenv("OPENCLAW_PUBLIC_BASE_URL", "").strip() + or os.getenv("OPENCLAW_WEB_PUBLIC_BASE_URL", "").strip() + or f"http://{host}:{port}" + ) + + +@dataclass +class InventoryItem: + key: str + label: str + count: int + threshold: int + reorder_qty: int + unit: str = "块" + alert_sent: bool = False + order_pending: bool = False + last_updated_at: str = "" + last_alert_at: str = "" + last_alert_token: str = "" + last_order_at: str = "" + + def to_dict(self) -> dict[str, Any]: + return { + "key": self.key, + "label": self.label, + "count": self.count, + "threshold": self.threshold, + "reorder_qty": self.reorder_qty, + "unit": self.unit, + "alert_sent": self.alert_sent, + "order_pending": self.order_pending, + "last_updated_at": self.last_updated_at, + "last_alert_at": self.last_alert_at, + "last_alert_token": self.last_alert_token, + "last_order_at": self.last_order_at, + } + + @classmethod + def from_dict(cls, payload: dict[str, Any]) -> "InventoryItem": + return cls( + key=str(payload.get("key") or payload.get("sku") or "chocolate"), + label=str(payload.get("label") or payload.get("label_zh") or "巧克力"), + count=int(payload.get("count", 0)), + threshold=int(payload.get("threshold", 3)), + reorder_qty=int(payload.get("reorder_qty", 10)), + unit=str(payload.get("unit") or "块"), + alert_sent=bool(payload.get("alert_sent", False)), + order_pending=bool(payload.get("order_pending", False)), + last_updated_at=str(payload.get("last_updated_at") or ""), + last_alert_at=str(payload.get("last_alert_at") or ""), + last_alert_token=str(payload.get("last_alert_token") or ""), + last_order_at=str(payload.get("last_order_at") or ""), + ) + + +class InventoryStore: + """File-backed, thread-safe inventory and order tracker.""" + + ALIASES = { + "chocolate": [ + "chocolate", + "choco", + "chocolate bar", + "巧克力", + "巧克力棒", + "巧克力块", + ], + } + + DEFAULT_ITEMS = { + "chocolate": InventoryItem( + key="chocolate", + label="巧克力", + count=12, + threshold=3, + reorder_qty=10, + unit="块", + ), + } + + def __init__( + self, + root: str | Path | None = None, + *, + public_base_url: str | None = None, + ) -> None: + self.root = Path(root) if root is not None else Path(__file__).resolve().parent / "temp" / "inventory" + self.root.mkdir(parents=True, exist_ok=True) + self.state_path = self.root / "inventory.json" + self.orders_path = self.root / "orders.jsonl" + self.public_base_url = (public_base_url or _default_public_base()).rstrip("/") + self._lock = threading.RLock() + self._state = self._load_state() + self._processed_sessions: set[str] = set(self._state.get("processed_sessions", [])) + self._processed_order_tokens: set[str] = set(self._state.get("processed_order_tokens", [])) + + # ------------------------------------------------------------------ + # Persistence + # ------------------------------------------------------------------ + def _load_state(self) -> dict[str, Any]: + if self.state_path.exists(): + try: + raw = json.loads(self.state_path.read_text(encoding="utf-8")) + items = { + key: InventoryItem.from_dict(value).to_dict() + for key, value in (raw.get("items") or {}).items() + } + if not items: + items = {key: item.to_dict() for key, item in self.DEFAULT_ITEMS.items()} + return { + "items": items, + "history": list(raw.get("history") or []), + "alerts": list(raw.get("alerts") or []), + "orders": list(raw.get("orders") or []), + "processed_sessions": list(raw.get("processed_sessions") or []), + "processed_order_tokens": list(raw.get("processed_order_tokens") or []), + "updated_at": str(raw.get("updated_at") or _now_iso()), + } + except Exception: + pass + return { + "items": {key: item.to_dict() for key, item in self.DEFAULT_ITEMS.items()}, + "history": [], + "alerts": [], + "orders": [], + "processed_sessions": [], + "processed_order_tokens": [], + "updated_at": _now_iso(), + } + + def _save_state(self) -> None: + self._state["updated_at"] = _now_iso() + self._state["processed_sessions"] = sorted(self._processed_sessions) + self._state["processed_order_tokens"] = sorted(self._processed_order_tokens) + self.state_path.write_text( + json.dumps(self._state, ensure_ascii=False, indent=2), + encoding="utf-8", + ) + + # ------------------------------------------------------------------ + # Lookup helpers + # ------------------------------------------------------------------ + def _resolve_key(self, text: str | None) -> str | None: + normalized = _normalize_text(text) + if not normalized: + return None + for key, aliases in self.ALIASES.items(): + if any(alias in normalized for alias in aliases): + return key + if normalized in self._state.get("items", {}): + return normalized + return None + + def _ensure_item(self, key: str) -> InventoryItem: + items = self._state.setdefault("items", {}) + if key not in items: + items[key] = InventoryItem( + key=key, + label=key, + count=0, + threshold=3, + reorder_qty=10, + unit="块", + ).to_dict() + return InventoryItem.from_dict(items[key]) + + def _write_item(self, item: InventoryItem) -> None: + self._state.setdefault("items", {})[item.key] = item.to_dict() + + def _trim(self, key: str, limit: int = 50) -> None: + entries = self._state.setdefault(key, []) + if len(entries) > limit: + del entries[:-limit] + + def _materialize_item(self, item: InventoryItem) -> dict[str, Any]: + low_stock = item.count <= item.threshold + order_url = self.build_order_url( + item.key, + item.reorder_qty, + token=item.last_alert_token or None, + ) + payload = item.to_dict() + payload.update( + { + "status": "low_stock" if low_stock else "ok", + "low_stock": low_stock, + "order_url": order_url, + } + ) + return payload + + # ------------------------------------------------------------------ + # Public API + # ------------------------------------------------------------------ + def snapshot(self) -> dict[str, Any]: + with self._lock: + items = [ + self._materialize_item(InventoryItem.from_dict(value)) + for key, value in sorted(self._state.get("items", {}).items(), key=lambda item: item[0]) + ] + return deepcopy( + { + "items": items, + "history": list(self._state.get("history", [])), + "alerts": list(self._state.get("alerts", [])), + "orders": list(self._state.get("orders", [])), + "updated_at": self._state.get("updated_at", _now_iso()), + "public_base_url": self.public_base_url, + } + ) + + def build_order_url(self, sku: str, quantity: int | None = None, *, token: str | None = None) -> str: + qty = int(quantity or self._ensure_item(sku).reorder_qty or 1) + base = ( + f"{self.public_base_url}/api/inventory/order" + f"?sku={quote(sku)}&quantity={qty}&source=feishu" + ) + if token: + base += f"&token={quote(token)}" + return base + + def record_task_success( + self, + *, + task: dict[str, Any], + command: str | None = None, + session_id: str | None = None, + ) -> dict[str, Any] | None: + """Consume inventory for a successful grasp-like task.""" + + with self._lock: + if session_id and session_id in self._processed_sessions: + return None + + source = task.get("source") or command + sku = self._resolve_key(str(source) if source is not None else None) + if not sku: + if session_id: + self._processed_sessions.add(session_id) + self._save_state() + return None + + item = self._ensure_item(sku) + previous = item.count + item.count = max(0, item.count - 1) + item.last_updated_at = _now_iso() + + low_stock = item.count <= item.threshold + alert_sent = False + if low_stock and not item.alert_sent: + item.alert_sent = True + item.last_alert_at = _now_iso() + item.last_alert_token = uuid.uuid4().hex + alert_sent = True + + self._write_item(item) + event = { + "kind": "low_stock_alert" if alert_sent else "consume", + "sku": item.key, + "label": item.label, + "unit": item.unit, + "previous": previous, + "remaining": item.count, + "threshold": item.threshold, + "reorder_qty": item.reorder_qty, + "alert_sent": alert_sent, + "order_pending": item.order_pending, + "order_url": self.build_order_url(item.key, item.reorder_qty, token=item.last_alert_token or None), + "order_token": item.last_alert_token, + "source": source, + "session_id": session_id, + "command": command, + "timestamp": _now_iso(), + } + self._state.setdefault("history", []).append(event) + if alert_sent: + self._state.setdefault("alerts", []).append(event) + if session_id: + self._processed_sessions.add(session_id) + self._trim("history") + self._trim("alerts") + self._save_state() + return event + + def record_order( + self, + *, + sku: str, + quantity: int, + source: str = "feishu", + session_id: str | None = None, + token: str | None = None, + ) -> dict[str, Any]: + with self._lock: + if token and token in self._processed_order_tokens: + item = self._ensure_item(sku) + return { + "status": "duplicate", + "duplicate": True, + "sku": item.key, + "label": item.label, + "quantity": int(quantity), + "source": source, + "session_id": session_id, + "token": token, + "timestamp": _now_iso(), + } + + item = self._ensure_item(sku) + item.order_pending = True + item.last_order_at = _now_iso() + self._write_item(item) + if token: + self._processed_order_tokens.add(token) + order = { + "sku": item.key, + "label": item.label, + "quantity": int(quantity), + "source": source, + "session_id": session_id, + "token": token, + "timestamp": _now_iso(), + } + self._state.setdefault("orders", []).append(order) + self._trim("orders") + self._save_state() + with self.orders_path.open("a", encoding="utf-8") as f: + f.write(json.dumps(order, ensure_ascii=False) + "\n") + return order + + def replenish(self, *, sku: str, quantity: int) -> dict[str, Any]: + with self._lock: + item = self._ensure_item(sku) + previous = item.count + item.count += int(quantity) + item.last_updated_at = _now_iso() + if item.count > item.threshold: + item.alert_sent = False + item.order_pending = False + item.last_alert_token = "" + self._write_item(item) + event = { + "kind": "replenish", + "sku": item.key, + "label": item.label, + "previous": previous, + "remaining": item.count, + "threshold": item.threshold, + "timestamp": _now_iso(), + } + self._state.setdefault("history", []).append(event) + self._trim("history") + self._save_state() + return event + + def set_item_count(self, *, sku: str, count: int) -> dict[str, Any]: + with self._lock: + item = self._ensure_item(sku) + previous = item.count + item.count = max(0, int(count)) + item.last_updated_at = _now_iso() + if item.count > item.threshold: + item.alert_sent = False + item.order_pending = False + item.last_alert_token = "" + self._write_item(item) + event = { + "kind": "set", + "sku": item.key, + "label": item.label, + "previous": previous, + "remaining": item.count, + "threshold": item.threshold, + "timestamp": _now_iso(), + } + self._state.setdefault("history", []).append(event) + self._trim("history") + self._save_state() + return event + + +_STORE: InventoryStore | None = None + + +def get_inventory_store() -> InventoryStore: + global _STORE + if _STORE is None: + _STORE = InventoryStore() + return _STORE diff --git a/third_party/tuntunclaw/main.py b/third_party/tuntunclaw/main.py new file mode 100644 index 0000000000000000000000000000000000000000..8119f7a07803fa0d42ec310c8b4372a72ceed6dd --- /dev/null +++ b/third_party/tuntunclaw/main.py @@ -0,0 +1,1209 @@ +"""FastAPI entrypoint for the OpenClaw web frontend.""" + +from __future__ import annotations + +import json +from io import BytesIO +import os +import sys +import threading +import time +import uuid +import webbrowser +from dataclasses import dataclass, field +from pathlib import Path +from typing import Any + +import numpy as np +from PIL import Image +from fastapi import FastAPI, HTTPException +from fastapi.responses import FileResponse, Response, StreamingResponse +from fastapi.staticfiles import StaticFiles + +ROOT_DIR = Path(__file__).resolve().parent +if str(ROOT_DIR) not in sys.path: + sys.path.insert(0, str(ROOT_DIR)) + +from grasp_process import ( + TABLE_SURFACE_Z, + _move_joint_waypoint, + estimate_body_image_bbox, + estimate_direct_grasp_target_world, + estimate_place_target_world, + execute_grasp, + get_apple_rack_slot_world, + get_available_table_sponge_bodies, + get_sponge_rack_slot_world, + run_grasp_inference, +) +from manipulator_grasp.env.ur5_grasp_env import UR5GraspEnv +from integrations import notify_robot_backend +from vlm_process import segment_image +from workflow_hooks import get_inventory_store, record_task_success_effects + + +FRONTEND_DIR = ROOT_DIR / "frontend" +INDEX_FILE = FRONTEND_DIR / "index.html" + + +def _assert_frontend_present() -> None: + if not INDEX_FILE.exists(): + raise RuntimeError( + f"Frontend assets not found at {INDEX_FILE}. " + "Build or copy the frontend folder first." + ) + + +def _now_iso() -> str: + return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()) + + +def _normalize_text(value: str | None) -> str: + return (value or "").strip().lower() + + +def _extract_objects(text: str) -> list[str]: + aliases = { + "apple": ["apple", "apple_2", "pingguo", "苹果"], + "apple_rack": [ + "apple rack", + "fruit rack", + "fruit basket", + "apple basket", + "有苹果的架子", + "放苹果的架子", + "苹果架", + "苹果篮", + "果篮", + "果架", + ], + "banana": ["banana", "bananas", "xiangjiao", "香蕉"], + "chocolate": ["chocolate", "choco", "chocolate bar", "巧克力", "巧克力棒", "巧克力块"], + "sponge": ["sponge", "海绵", "海棉", "海绵块", "海绵垫", "海绵片"], + "duck": ["duck", "yellow duck", "toy duck", "duckie", "鸭子"], + "hammer": ["hammer", "锤子"], + "knife": ["knife", "刀", "小刀"], + "plate": ["plate", "dish", "saucer", "盘子", "盘里", "盘中", "盘上"], + "sponge_rack": ["sponge rack", "sponge shelf", "海绵架", "海绵货架", "海绵收纳架", "海绵架子", "海绵位"], + "shelf": ["shelf", "rack", "架子", "搁架"], + "glass_cup": ["glass cup", "glass", "cup", "玻璃杯", "杯子"], + "flower_vase": ["flower vase", "vase", "花瓶"], + } + hits: list[tuple[int, str]] = [] + for canonical, variants in aliases.items(): + for variant in variants: + idx = text.find(variant) + if idx >= 0: + hits.append((idx, canonical)) + break + hits.sort(key=lambda item: item[0]) + ordered: list[str] = [] + for _, canonical in hits: + if canonical not in ordered: + ordered.append(canonical) + return ordered + + +def _infer_relation(text: str) -> str: + for relation, variants in { + "in": [ + "in", + "into", + "inside", + "里面", + "里", + "放进", + "放入", + "放到里", + "放到里面", + "放回", + "放回去", + "归位", + "收纳", + "整理放回", + ], + "on_top_of": ["on top of", "on", "upon", "放到上", "放到盘上", "放到桌面上"], + "next_to": ["next to", "beside", "near", "旁边", "附近"], + "left_of": ["left of", "to the left of", "左边"], + "right_of": ["right of", "to the right of", "右边"], + "in_front_of": ["in front of", "front of", "前面"], + "behind": ["behind", "at the back of", "后面"], + }.items(): + if any(variant in text for variant in variants): + return relation + return "place" + + +def _parse_task(command: str) -> dict[str, Any]: + text = _normalize_text(command) + if not text: + return {"type": "idle", "source": None, "destination": None, "relation": None, "all_items": False} + if text in {"exit", "quit"}: + return {"type": "interrupted", "source": None, "destination": None, "relation": None, "all_items": False} + if any(keyword in text for keyword in ["teleop", "manual", "keyboard"]): + return {"type": "teleop", "source": None, "destination": None, "relation": None, "all_items": False} + if any(keyword in text for keyword in ["dance", "wave"]): + return {"type": "dance", "source": None, "destination": None, "relation": None, "all_items": False} + if any(keyword in text for keyword in ["drop", "throw", "扔", "抛", "摔", "丢"]): + objects = _extract_objects(text) + return { + "type": "drop", + "source": objects[0] if objects else "object", + "destination": None, + "relation": "drop", + "all_items": False, + } + + objects = _extract_objects(text) + relation = _infer_relation(text) + place_keywords = [ + "place", + "put", + "move", + "relocate", + "放回", + "放回去", + "放入", + "放进", + "放置", + "放到", + "放在", + "归位", + "整理放回", + "收纳", + ] + all_items = any(keyword in text for keyword in ["全部", "所有", "全都", "都", "一起", "批量"]) + if len(objects) >= 2 or any(keyword in text for keyword in place_keywords): + source = objects[0] if objects else "object" + destination = objects[1] if len(objects) > 1 else "target" + if source == "apple" and destination in {"target", "shelf", "apple"}: + if any( + keyword in text + for keyword in ["有苹果的架子", "放苹果的架子", "苹果架", "苹果篮", "果篮", "果架"] + ): + destination = "apple_rack" + if source == "apple" and destination == "apple_rack": + relation = "in" + if source == "sponge" and destination in {"target", "shelf"}: + destination = "sponge_rack" + if source == "sponge" and destination == "sponge": + destination = "sponge_rack" + if source == "sponge" and destination == "sponge_rack": + relation = "in" + return { + "type": "pick_place", + "source": source, + "destination": destination, + "relation": relation, + "all_items": all_items, + } + return { + "type": "grasp", + "source": objects[0] if objects else "object", + "destination": None, + "relation": None, + "all_items": False, + } + + +def _build_trace(task: dict[str, Any], blocked_reason: str | None = None) -> list[dict[str, Any]]: + task_type = task["type"] + library = { + "grasp": [ + "收到用户输入", + "语言解析", + "任务调度", + "场景采集", + "抓取目标估计", + "IK 求解", + "动作执行", + "结果", + ], + "pick_place": [ + "收到用户输入", + "语言解析", + "任务调度", + "目标分割", + "抓取目标估计", + "放置目标估计", + "IK 求解", + "动作执行", + "结果", + ], + "teleop": ["收到用户输入", "语言解析", "任务调度", "遥操作切换", "结果"], + "dance": ["收到用户输入", "语言解析", "任务调度", "轨迹回放", "结果"], + "drop": ["收到用户输入", "语言解析", "任务调度", "抛掷规划", "结果"], + "interrupted": ["收到用户输入", "任务调度", "会话结束"], + "blocked": ["收到用户输入", "策略检查", "结果"], + } + steps = library["blocked"] if blocked_reason else library.get(task_type, library["grasp"]) + trace: list[dict[str, Any]] = [] + for index, name in enumerate(steps): + status = "done" + if index == 1: + status = "running" + if index >= 2: + status = "pending" + if blocked_reason: + status = "failed" if index == 1 else "pending" + trace.append( + { + "name": name, + "status": status, + "detail": _trace_detail(name, task, blocked_reason), + } + ) + return trace + + +def _trace_detail(step: str, task: dict[str, Any], blocked_reason: str | None) -> str: + parts: list[str] = [] + if task.get("source"): + parts.append(f"source={task['source']}") + if task.get("destination"): + parts.append(f"destination={task['destination']}") + if task.get("relation"): + parts.append(f"relation={task['relation']}") + if blocked_reason and step == "策略检查": + parts.append(f"blocked by {blocked_reason}") + if step == "结果": + parts.append("等待执行摘要") + return " | ".join(parts) if parts else "queued" + + +def _fake_preview(task: dict[str, Any]) -> dict[str, Any]: + if task["type"] == "pick_place": + return { + "boxes": [ + {"label": task["source"], "x": 16, "y": 56, "w": 18, "h": 14}, + {"label": task["destination"], "x": 63, "y": 24, "w": 20, "h": 16}, + ] + } + if task["type"] == "grasp": + return {"boxes": [{"label": task["source"], "x": 54, "y": 40, "w": 18, "h": 16}]} + if task["type"] == "teleop": + return {"boxes": [{"label": "teleop target", "x": 42, "y": 36, "w": 18, "h": 18}]} + return {"boxes": []} + + +def _extract_block_reason(command: str) -> str: + lower = _normalize_text(command) + for token in ["self-harm", "suicide", "weapon", "bomb"]: + if token in lower: + return token + return "" + + +def _encode_frame_png(frame: np.ndarray) -> bytes: + # Encode directly from RGB so browser previews match the simulator output. + image = Image.fromarray(np.asarray(frame, dtype=np.uint8), mode="RGB") + buffer = BytesIO() + image.save(buffer, format="PNG", compress_level=3) + return buffer.getvalue() + + +def _task_label(task_type: str) -> str: + return { + "grasp": "抓取任务", + "pick_place": "放置任务", + "drop": "抛掷任务", + "teleop": "遥操作任务", + "dance": "舞蹈演示", + "interrupted": "会话", + }.get(task_type, task_type) + + +def _stage_label(stage: str) -> str: + return { + "home": "回到初始位", + "hub": "转运抬升", + "hover_pick": "目标上方定位", + "pregrasp": "抓取预位", + "grasp": "执行抓取", + "grasp_close": "夹爪闭合", + "lift": "抬升目标", + "hover_place": "放置上方定位", + "preplace": "放置预位", + "place": "执行放置", + "release": "释放目标", + "retreat": "后退脱离", + "hub_return": "返回中转位", + "reset": "回到初始位", + "start": "开始执行", + "capture": "采集图像", + "segment": "语义分割", + "infer": "抓取估计", + "prepare": "任务准备", + "dance": "轨迹回放", + "teleop": "遥操作准备", + "drop": "抛掷规划", + }.get(stage, stage) + + +class MuJoCoCommandRunner: + def __init__(self) -> None: + self._lock = threading.RLock() + self._env: UR5GraspEnv | None = None + + def _temp_image_path(self, session: "SessionRecord", stem: str) -> Path: + temp_dir = ROOT_DIR / "temp" / "images" + temp_dir.mkdir(parents=True, exist_ok=True) + return temp_dir / f"{session.session_id}_{stem}.png" + + def close(self) -> None: + with self._lock: + if self._env is not None: + try: + self._env.close() + finally: + self._env = None + + def _ensure_env(self) -> UR5GraspEnv: + if self._env is None: + self._env = UR5GraspEnv() + self._env.reset() + return self._env + + def _capture_rgbd(self) -> tuple[np.ndarray, np.ndarray]: + env = self._ensure_env() + imgs = env.render() + color = np.array(imgs["img"], copy=True) + depth = np.array(imgs["depth"], copy=True) + return color, depth + + def _refresh_trace( + self, + session: "SessionRecord", + *, + stage: str, + final: bool = False, + failed: bool = False, + ) -> None: + task_type = session.task.get("type", "grasp") + stage_index_map = { + "grasp": { + "capture": 3, + "segment": 4, + "infer": 4, + "prepare": 3, + "home": 6, + "hub": 6, + "hover_pick": 6, + "pregrasp": 6, + "grasp": 6, + "grasp_close": 6, + "lift": 6, + "hover_place": 6, + "preplace": 6, + "place": 6, + "release": 6, + "retreat": 6, + "hub_return": 6, + "reset": 6, + "result": 7, + "error": 6, + }, + "pick_place": { + "capture": 3, + "segment": 3, + "infer": 4, + "prepare": 3, + "home": 7, + "hub": 7, + "hover_pick": 7, + "pregrasp": 7, + "grasp": 7, + "grasp_close": 7, + "lift": 7, + "hover_place": 7, + "preplace": 7, + "place": 7, + "release": 7, + "retreat": 7, + "hub_return": 7, + "reset": 7, + "result": 8, + "error": 7, + }, + "drop": { + "capture": 3, + "segment": 3, + "infer": 3, + "prepare": 3, + "home": 3, + "hub": 3, + "hover_pick": 3, + "pregrasp": 3, + "grasp": 3, + "grasp_close": 3, + "lift": 3, + "hover_place": 3, + "preplace": 3, + "place": 3, + "release": 3, + "retreat": 3, + "hub_return": 3, + "reset": 3, + "drop": 3, + "result": 4, + "error": 3, + }, + "teleop": { + "capture": 3, + "prepare": 3, + "teleop": 3, + "home": 3, + "result": 4, + "error": 3, + }, + "dance": { + "capture": 3, + "prepare": 3, + "dance": 3, + "home": 3, + "result": 4, + "error": 3, + }, + } + indices = stage_index_map.get(task_type, stage_index_map["grasp"]) + progress_index = indices.get(stage, indices.get("infer", 0)) + if final: + progress_index = len(session.trace) + refreshed = [] + for index, item in enumerate(session.trace): + if final: + status = "failed" if failed and index == progress_index else "done" + elif index < progress_index: + status = "done" + elif index == progress_index: + status = "failed" if failed else "running" + else: + status = "pending" + refreshed.append({**item, "status": status}) + session.trace = refreshed + + def _touch_preview( + self, + session: "SessionRecord", + *, + stage: str, + note: str = "", + boxes: list[dict[str, Any]] | None = None, + ) -> None: + with session.condition: + self._refresh_trace(session, stage=stage) + session.current_step = _stage_label(stage) + env = self._ensure_env() + frame = env.render()["img"] + session.frame_jpeg = _encode_frame_png(frame) + session.preview = { + "image_url": f"/api/session/{session.session_id}/frame?rev={session.revision}", + "stage": stage, + "stage_label": _stage_label(stage), + "note": note or _stage_label(stage), + "boxes": boxes or [], + } + session.updated_at = _now_iso() + session.revision += 1 + session.condition.notify_all() + + def _set_running(self, session: "SessionRecord", stage: str, result: str | None = None) -> None: + session.current_step = _stage_label(stage) + if result is not None: + session.result = result + session.updated_at = _now_iso() + session.revision += 1 + session.condition.notify_all() + + def _run_dance(self, session: "SessionRecord") -> dict[str, Any]: + env = self._ensure_env() + from grasp_process import _move_joint_waypoint + + robot = env.robot + action = np.zeros(7, dtype=np.float64) + q_start = np.array(robot.get_joint(), dtype=np.float64) + waypoints = [ + np.array([0.35, -0.70, 1.45, -1.05, -1.25, 0.05], dtype=np.float64), + np.array([-0.35, -0.70, 1.45, -1.05, -1.25, -0.05], dtype=np.float64), + np.array([0.55, -1.05, 1.25, -0.75, -1.45, 0.75], dtype=np.float64), + np.array([-0.55, -1.05, 1.25, -0.75, -1.45, -0.75], dtype=np.float64), + q_start, + ] + for index, q_target in enumerate(waypoints): + _move_joint_waypoint( + env, + robot, + action, + q_target, + 0.75, + frame_callback=lambda _stage, _: self._touch_preview(session, stage="dance", note="舞蹈演示"), + stage_name=f"dance_{index}", + ) + return {"status": "ok", "task": "dance"} + + def _run_teleop(self, session: "SessionRecord") -> dict[str, Any]: + env = self._ensure_env() + from grasp_process import _move_joint_waypoint + + robot = env.robot + action = np.zeros(7, dtype=np.float64) + q_home = np.array([0.0, 0.0, np.pi / 2, 0.0, -np.pi / 2, 0.0], dtype=np.float64) + self._touch_preview(session, stage="teleop", note="遥操作准备") + _move_joint_waypoint( + env, + robot, + action, + q_home, + 0.9, + frame_callback=lambda _stage, _: self._touch_preview(session, stage="teleop", note="遥操作准备"), + stage_name="teleop", + ) + return {"status": "ok", "task": "teleop"} + + def _run_single_grasp_like( + self, + session: "SessionRecord", + task: dict[str, Any], + command: str, + *, + source_name_override: str | None = None, + destination_name_override: str | None = None, + place_target_override: np.ndarray | None = None, + note_prefix: str = "", + ) -> dict[str, Any]: + env = self._ensure_env() + color_img, depth_img = self._capture_rgbd() + capture_note = "采集仿真相机画面" + if note_prefix: + capture_note = f"{note_prefix}{capture_note}" + self._touch_preview(session, stage="capture", note=capture_note) + + source_name = source_name_override or task.get("source") + destination_name = destination_name_override or task.get("destination") + relation = task.get("relation") or "place" + + chocolate_like = isinstance(source_name, str) and source_name in { + "chocolate", + "chocolate_bar", + "snickers", + } + sponge_like = isinstance(source_name, str) and source_name == "sponge" + source_bbox = None + source_command = str(command) + source_label = str(source_name) if isinstance(source_name, str) and source_name else None + if chocolate_like: + source_command = f"{command}。请优先选择图中包装上写着 SNICKERS 的巧克力棒。" + source_label = "SNICKERS chocolate bar" + elif sponge_like: + source_command = f"{command}。请优先选择图中红圈标出的海绵。" + source_label = "sponge" + source_bbox = estimate_body_image_bbox(env, source_name, color_img.shape) + elif isinstance(source_name, str) and source_name: + source_bbox = estimate_body_image_bbox(env, source_name, color_img.shape) + + source_mask = segment_image( + color_img, + output_mask=str(self._temp_image_path(session, "mask_source")), + command_text=source_command, + bbox_override=source_bbox, + label_override=source_label, + ) + source_segment_note = "完成源目标分割" + if note_prefix: + source_segment_note = f"{note_prefix}{source_segment_note}" + self._touch_preview(session, stage="segment", note=source_segment_note) + + grasp_target_world = None + if isinstance(source_name, str) and source_name: + try: + grasp_target_world, _ = estimate_direct_grasp_target_world( + env, + depth_img, + source_mask, + source_name=source_name, + ) + except Exception: + grasp_target_world = None + + place_target_world = None if place_target_override is None else np.array(place_target_override, dtype=np.float64) + place_mode = None + if task["type"] == "pick_place": + if destination_name == "plate" and relation == "in": + relation = "on_top_of" + if destination_name == "plate": + place_mode = "drop_above_plate" + if place_target_world is None: + destination_command = str(destination_name or "") + destination_label = ( + str(destination_name) if isinstance(destination_name, str) and destination_name else None + ) + destination_bbox = ( + estimate_body_image_bbox(env, destination_name, color_img.shape) + if isinstance(destination_name, str) and destination_name + else None + ) + if isinstance(destination_name, str) and destination_name == "sponge_rack": + destination_command = f"{command}。请优先选择图中绿色圈出的海绵架放置位置。" + destination_label = "sponge rack" + destination_mask = segment_image( + color_img, + output_mask=str(self._temp_image_path(session, "mask_destination")), + command_text=destination_command, + bbox_override=destination_bbox, + label_override=destination_label, + ) + destination_segment_note = "完成放置目标分割" + if note_prefix: + destination_segment_note = f"{note_prefix}{destination_segment_note}" + self._touch_preview(session, stage="segment", note=destination_segment_note) + place_target_world = estimate_place_target_world( + env, + depth_img, + destination_mask, + source_mask=source_mask, + relation=relation, + source_name=source_name if isinstance(source_name, str) else None, + destination_name=destination_name if isinstance(destination_name, str) else None, + ) + elif task["type"] == "drop": + if grasp_target_world is not None: + place_target_world = np.array(grasp_target_world, dtype=np.float64).copy() + place_target_world[2] = max(TABLE_SURFACE_Z + 0.03, float(place_target_world[2])) + place_mode = "drop_above" + + infer_note = "完成抓取与放置估计" + if note_prefix: + infer_note = f"{note_prefix}{infer_note}" + self._touch_preview(session, stage="infer", note=infer_note) + gg = run_grasp_inference( + color_img, + depth_img, + source_mask, + camera_fovy_deg=getattr(env, "camera_fovy_deg", 45.0), + ) + infer_grasp_note = "完成抓取候选推理" + if note_prefix: + infer_grasp_note = f"{note_prefix}{infer_grasp_note}" + self._touch_preview(session, stage="infer", note=infer_grasp_note) + + execute_grasp( + env, + gg, + place_target_world=place_target_world, + grasp_target_world=grasp_target_world, + source_name=source_name if isinstance(source_name, str) else None, + place_mode=place_mode, + frame_callback=lambda stage, _: self._touch_preview( + session, + stage=stage or "motion", + note=f"{note_prefix}真实 MuJoCo 执行中" if note_prefix else "真实 MuJoCo 执行中", + ), + ) + return { + "status": "ok", + "task": task["type"], + "source": source_name, + "destination": destination_name, + "relation": relation, + "grasp_count": len(gg), + } + + def _run_grasp_like(self, session: "SessionRecord", task: dict[str, Any], command: str) -> dict[str, Any]: + env = self._ensure_env() + if ( + task.get("type") == "pick_place" + and task.get("source") == "apple" + and task.get("destination") == "apple_rack" + ): + slot_world = get_apple_rack_slot_world(env, slot_index=0) + if slot_world is None: + raise RuntimeError("未能确定苹果果篮位置。") + return self._run_single_grasp_like( + session, + task, + command, + source_name_override="apple", + destination_name_override="apple_rack", + place_target_override=slot_world, + ) + if ( + task.get("type") == "pick_place" + and task.get("source") == "sponge" + and task.get("destination") == "sponge_rack" + and task.get("all_items") + ): + source_names = get_available_table_sponge_bodies(env) + if not source_names: + raise RuntimeError("桌面上没有可整理的海绵。") + results = [] + for index, source_name in enumerate(source_names): + slot_world = get_sponge_rack_slot_world(env, slot_index=index) + if slot_world is None: + raise RuntimeError("未能确定海绵架篮格位置。") + results.append( + self._run_single_grasp_like( + session, + task, + command, + source_name_override=source_name, + destination_name_override="sponge_rack", + place_target_override=slot_world, + note_prefix=f"第{index + 1}块海绵：", + ) + ) + with session.condition: + session.logs.append( + f"[{_now_iso()}] INFO: sponge batch item {index + 1}/{len(source_names)} -> {source_name}" + ) + session.condition.notify_all() + return { + "status": "ok", + "task": task["type"], + "source": "sponge", + "destination": "sponge_rack", + "relation": task.get("relation"), + "grasp_count": sum(int(item.get("grasp_count", 0)) for item in results), + "batch_count": len(results), + } + return self._run_single_grasp_like(session, task, command) + + def run(self, session: "SessionRecord") -> None: + task = session.task or {"type": "grasp", "source": "object", "destination": None, "relation": None} + with self._lock: + try: + if task["type"] == "dance": + result = self._run_dance(session) + elif task["type"] == "teleop": + result = self._run_teleop(session) + else: + result = self._run_grasp_like(session, task, session.command) + + inventory_event = record_task_success_effects( + task=task, + command=session.command, + session_id=session.session_id, + ) + + with session.condition: + session.status = "success" + session.current_step = "结果" + session.result = { + "grasp": "已通过真实后端完成抓取任务。", + "pick_place": "已通过真实后端完成放置任务。", + "drop": "已通过真实后端完成抛掷仿真。", + "teleop": "遥操作演示已就绪。", + "dance": "舞蹈演示已完成。", + }.get(task["type"], "已通过真实后端完成任务。") + session.inventory_event = inventory_event or {} + session.inventory = get_inventory_store().snapshot() + session.logs.append(f"[{_now_iso()}] OK: 真实 MuJoCo 执行完成") + if inventory_event: + session.logs.append( + f"[{_now_iso()}] INFO: inventory {inventory_event['sku']} -> {inventory_event['remaining']}" + ) + if inventory_event.get("alert_sent"): + session.logs.append( + f"[{_now_iso()}] WARN: low stock alert emitted for {inventory_event['sku']}" + ) + self._refresh_trace(session, stage="result", final=True) + self._touch_preview(session, stage="result", note=session.result) + session.condition.notify_all() + except Exception as exc: + with session.condition: + session.status = "failure" + session.current_step = "结果" + session.result = f"执行失败：{exc}" + session.inventory = get_inventory_store().snapshot() + session.logs.append(f"[{_now_iso()}] ERROR: {exc}") + self._refresh_trace(session, stage="error", final=True, failed=True) + self._touch_preview(session, stage="error", note=str(exc)) + session.condition.notify_all() + + +BACKEND = MuJoCoCommandRunner() + + +def _step_delay(task_type: str, index: int) -> float: + plan = { + "grasp": [0.28, 0.34, 0.30, 0.34, 0.38, 0.34, 0.40, 0.32], + "pick_place": [0.28, 0.34, 0.30, 0.34, 0.36, 0.36, 0.34, 0.40, 0.34], + "teleop": [0.24, 0.28, 0.28, 0.36, 0.32], + "dance": [0.24, 0.28, 0.30, 0.42, 0.34], + "interrupted": [0.20, 0.20, 0.20], + } + steps = plan.get(task_type, plan["grasp"]) + return steps[min(index, len(steps) - 1)] + + +def _progress_trace(trace: list[dict[str, Any]], active_index: int | None, terminal: bool = False) -> list[dict[str, Any]]: + next_trace: list[dict[str, Any]] = [] + for index, item in enumerate(trace): + if terminal: + status = "failed" if item["status"] == "failed" else "done" + elif active_index is None: + status = item["status"] + elif index < active_index: + status = "done" + elif index == active_index: + status = "running" + else: + status = "pending" + next_trace.append({**item, "status": status}) + return next_trace + + +def _touch_session(session: "SessionRecord") -> None: + session.updated_at = _now_iso() + session.revision += 1 + session.condition.notify_all() + + +def _run_session(session_id: str) -> None: + with sessions_lock: + session = sessions.get(session_id) + if session is None: + return + + with session.condition: + if session.status != "running": + return + session.logs.append(f"[{_now_iso()}] INFO: 进入真实 MuJoCo 执行") + session.revision += 1 + session.condition.notify_all() + + BACKEND.run(session) + + +@dataclass +class SessionRecord: + session_id: str = field(default_factory=lambda: str(uuid.uuid4())) + created_at: str = field(default_factory=_now_iso) + updated_at: str = field(default_factory=_now_iso) + revision: int = 0 + command: str = "" + task: dict[str, Any] = field(default_factory=dict) + trace: list[dict[str, Any]] = field(default_factory=list) + logs: list[str] = field(default_factory=list) + status: str = "idle" + current_step: str = "Waiting" + result: str = "No result yet." + preview: dict[str, Any] = field(default_factory=dict) + inventory: dict[str, Any] = field(default_factory=dict) + inventory_event: dict[str, Any] = field(default_factory=dict) + frame_jpeg: bytes = b"" + condition: threading.Condition = field(default_factory=threading.Condition, repr=False) + + def payload(self) -> dict[str, Any]: + return { + "session_id": self.session_id, + "created_at": self.created_at, + "updated_at": self.updated_at, + "revision": self.revision, + "command": self.command, + "parsed": self.task, + "trace": self.trace, + "logs": self.logs, + "status": self.status, + "current_step": self.current_step, + "result": self.result, + "preview": self.preview, + "inventory": self.inventory, + "inventory_event": self.inventory_event, + "preview_url": self.preview.get("image_url", ""), + } + + +sessions: dict[str, SessionRecord] = {} +sessions_lock = threading.Lock() +app = FastAPI(title="OpenClaw Web Frontend") +INVENTORY = get_inventory_store() + + +@app.get("/healthz") +def healthz() -> dict[str, str]: + return {"status": "ok"} + + +@app.get("/api/inventory") +def get_inventory() -> dict[str, Any]: + return INVENTORY.snapshot() + + +def _inventory_order_html(order: dict[str, Any], snapshot: dict[str, Any]) -> Response: + item = next((entry for entry in snapshot.get("items", []) if entry.get("key") == order.get("sku")), {}) + title = f"{order.get('label') or order.get('sku') or '物资'} 已下单" + html = f""" + + + + + {title} + + + +
    +

    {title}

    +

    订单已经记录。你可以关闭这个页面，或返回 Feishu 继续查看通知。

    +
    +
    SKU: {order.get("sku")}
    +
    数量: {order.get("quantity")}
    +
    状态: {order.get("source")}
    +
    库存剩余: {item.get("count", "-")}
    +
    +

    当前库存快照已更新。

    + 返回控制台 +
    + +""" + return Response(content=html, media_type="text/html; charset=utf-8", headers={"Cache-Control": "no-store"}) + + +@app.get("/api/inventory/order") +def place_inventory_order_get( + sku: str, + quantity: int = 1, + source: str = "feishu", + token: str | None = None, +) -> Response: + order = INVENTORY.record_order( + sku=sku, + quantity=quantity, + source=source, + token=token, + ) + snapshot = INVENTORY.snapshot() + notify_robot_backend( + { + "kind": "inventory_order", + "order": order, + "inventory": snapshot, + } + ) + return _inventory_order_html(order, snapshot) + + +@app.post("/api/inventory/order") +def place_inventory_order_post(payload: dict[str, Any]) -> dict[str, Any]: + sku = str(payload.get("sku") or "").strip() + if not sku: + raise HTTPException(status_code=400, detail="sku is required") + quantity = int(payload.get("quantity") or 1) + source = str(payload.get("source") or "manual").strip() or "manual" + token = str(payload.get("token") or payload.get("order_token") or "").strip() or None + order = INVENTORY.record_order( + sku=sku, + quantity=quantity, + source=source, + token=token, + ) + snapshot = INVENTORY.snapshot() + notify_robot_backend( + { + "kind": "inventory_order", + "order": order, + "inventory": snapshot, + } + ) + return { + "order": order, + "inventory": snapshot, + } + + +@app.post("/api/inventory/replenish") +def replenish_inventory(payload: dict[str, Any]) -> dict[str, Any]: + sku = str(payload.get("sku") or "").strip() + if not sku: + raise HTTPException(status_code=400, detail="sku is required") + quantity = int(payload.get("quantity") or 0) + event = INVENTORY.replenish(sku=sku, quantity=quantity) + snapshot = INVENTORY.snapshot() + notify_robot_backend( + { + "kind": "inventory_replenish", + "event": event, + "inventory": snapshot, + } + ) + return { + "event": event, + "inventory": snapshot, + } + + +@app.post("/api/command") +def submit_command(payload: dict[str, Any]) -> dict[str, Any]: + command = _normalize_text(str(payload.get("command", ""))) + if not command: + raise HTTPException(status_code=400, detail="command is required") + + session_id = str(payload.get("session_id") or payload.get("sessionId") or "").strip() + with sessions_lock: + session = sessions.get(session_id) if session_id else None + if session is None: + session = SessionRecord() + sessions[session.session_id] = session + + task = _parse_task(command) + blocked_reason = _extract_block_reason(command) + trace = _build_trace(task, blocked_reason=blocked_reason or None) + + with session.condition: + session.command = command + session.task = task + session.trace = trace + session.preview = _fake_preview(task) + session.inventory = get_inventory_store().snapshot() + session.inventory_event = {} + session.logs = [ + f"[{_now_iso()}] INFO: command accepted: {command}", + f"[{_now_iso()}] INFO: parsed task: {task['type']}", + ] + session.updated_at = _now_iso() + session.revision += 1 + + if blocked_reason: + session.status = "failure" + session.current_step = "策略检查" + session.result = f"已被策略关键字拦截：{blocked_reason}" + session.logs.append(f"[{_now_iso()}] WARN: 策略拦截关键字：{blocked_reason}") + session.trace = _progress_trace(session.trace, 1, terminal=True) + session.revision += 1 + session.condition.notify_all() + elif task["type"] == "interrupted": + session.status = "interrupted" + session.current_step = "会话结束" + session.result = "会话已关闭。" + session.logs.append(f"[{_now_iso()}] OK: 会话已由用户中断") + session.trace = _progress_trace(session.trace, None, terminal=True) + session.revision += 1 + session.condition.notify_all() + else: + session.status = "running" + session.current_step = trace[0]["name"] if trace else "Running" + session.result = "指令正在执行中..." + session.trace = _progress_trace(session.trace, 0) + session.revision += 1 + session.condition.notify_all() + threading.Thread(target=_run_session, args=(session.session_id,), daemon=True).start() + + with sessions_lock: + sessions[session.session_id] = session + return session.payload() + + +@app.get("/api/session/{session_id}") +def get_session(session_id: str) -> dict[str, Any]: + with sessions_lock: + session = sessions.get(session_id) + if session is None: + raise HTTPException(status_code=404, detail="session not found") + return session.payload() + + +@app.get("/api/session/{session_id}/events") +def get_session_events(session_id: str) -> StreamingResponse: + with sessions_lock: + session = sessions.get(session_id) + if session is None: + raise HTTPException(status_code=404, detail="session not found") + + def stream(): + last_revision = -1 + yield f"data: {json.dumps(session.payload(), ensure_ascii=False)}\n\n" + last_revision = session.revision + while True: + with session.condition: + session.condition.wait(timeout=15) + current_revision = session.revision + current_status = session.status + payload = session.payload() + if current_revision != last_revision: + last_revision = current_revision + yield f"data: {json.dumps(payload, ensure_ascii=False)}\n\n" + if current_status != "running": + break + + return StreamingResponse(stream(), media_type="text/event-stream") + + +@app.get("/api/session/{session_id}/frame") +def get_session_frame(session_id: str) -> Response: + with sessions_lock: + session = sessions.get(session_id) + if session is None: + raise HTTPException(status_code=404, detail="session not found") + if not session.frame_jpeg: + raise HTTPException(status_code=404, detail="frame not ready") + return Response( + content=session.frame_jpeg, + media_type="image/png", + headers={"Cache-Control": "no-store, max-age=0"}, + ) + + +@app.get("/") +def root() -> FileResponse: + return FileResponse(INDEX_FILE) + + +app.mount("/", StaticFiles(directory=FRONTEND_DIR, html=True), name="frontend") + + +def _open_browser_later(url: str) -> None: + time.sleep(1.0) + try: + webbrowser.open(url) + except Exception: + pass + + +def main() -> None: + _assert_frontend_present() + os.environ.setdefault("OPENCLAW_RENDER_BACKEND", "glfw") + host = os.getenv("OPENCLAW_WEB_HOST", "127.0.0.1") + port = int(os.getenv("OPENCLAW_WEB_PORT", "8000")) + auto_open = os.getenv("OPENCLAW_WEB_AUTO_OPEN", "1").strip().lower() not in {"0", "false", "no"} + url = f"http://{host}:{port}/" + if auto_open: + threading.Thread(target=_open_browser_later, args=(url,), daemon=True).start() + + import uvicorn + + uvicorn.run(app, host=host, port=port, reload=False, log_level="info") + + +if __name__ == "__main__": + main() diff --git a/third_party/tuntunclaw/main_openclaw.py b/third_party/tuntunclaw/main_openclaw.py new file mode 100644 index 0000000000000000000000000000000000000000..ba242bf2814766d4d53f10833d62ea04a078f5ef --- /dev/null +++ b/third_party/tuntunclaw/main_openclaw.py @@ -0,0 +1,5 @@ +from openclaw_like.agent import IronClawLikeAgent + + +if __name__ == "__main__": + IronClawLikeAgent().run() diff --git a/third_party/tuntunclaw/main_vlm.py b/third_party/tuntunclaw/main_vlm.py new file mode 100644 index 0000000000000000000000000000000000000000..6bfed5792da60e67c3b69f19f1293ddf72e6cda5 --- /dev/null +++ b/third_party/tuntunclaw/main_vlm.py @@ -0,0 +1,99 @@ +import os +import sys +import cv2 +import mujoco +import matplotlib.pyplot as plt +import time + +ROOT_DIR = os.path.dirname(os.path.abspath(__file__)) +sys.path.append(os.path.join(ROOT_DIR, 'graspnet-baseline', 'models')) +sys.path.append(os.path.join(ROOT_DIR, 'graspnet-baseline', 'dataset')) +sys.path.append(os.path.join(ROOT_DIR, 'graspnet-baseline', 'utils')) +sys.path.append(os.path.join(ROOT_DIR, 'manipulator_grasp')) + +from manipulator_grasp.env.ur5_grasp_env import UR5GraspEnv + +from vlm_process import segment_image +from grasp_process import run_grasp_inference, execute_grasp + + +# 全局变量 +global color_img, depth_img, env +color_img = None +depth_img = None +env = None + + +#获取彩色和深度图像数据 +def get_image(env): + global color_img, depth_img + # 从环境渲染获取图像数据 + imgs = env.render() + + # 提取彩色和深度图像数据 + color_img = imgs['img'] # 这是RGB格式的图像数据 + depth_img = imgs['depth'] # 这是深度数据 + + # 将RGB图像转换为OpenCV常用的BGR格式 + color_img = cv2.cvtColor(color_img, cv2.COLOR_RGB2BGR) + + return color_img, depth_img + +#构造回调函数，不断调用 +def callback(color_frame, depth_frame): + global color_img, depth_img + scaling_factor_x = 1 + scaling_factor_y = 1 + + color_img = cv2.resize( + color_frame, None, + fx=scaling_factor_x, + fy=scaling_factor_y, + interpolation=cv2.INTER_AREA + ) + depth_img = cv2.resize( + depth_frame, None, + fx=scaling_factor_x, + fy=scaling_factor_y, + interpolation=cv2.INTER_NEAREST + ) + + if color_img is not None and depth_img is not None: + test_grasp() + + +def test_grasp(): + global color_img, depth_img, env + + if color_img is None or depth_img is None: + print("[WARNING] Waiting for image data...") + return + + # 图像处理部分 + masks = segment_image(color_img) + + gg = run_grasp_inference(color_img, depth_img, masks) + + execute_grasp(env, gg) + + + +if __name__ == '__main__': + + env = UR5GraspEnv() + env.reset() + + while True: + + for i in range(500): # 1000 + env.step() + + color_img, depth_img = get_image(env) + + callback(color_img, depth_img) + + + env.close() + + + \ No newline at end of file diff --git a/third_party/tuntunclaw/openclaw_like/__init__.py b/third_party/tuntunclaw/openclaw_like/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..4d4e97b49baef0a132c712c92857cb274968f555 --- /dev/null +++ b/third_party/tuntunclaw/openclaw_like/__init__.py @@ -0,0 +1 @@ +"""OpenClaw-like adaptation package.""" diff --git a/third_party/tuntunclaw/openclaw_like/agent.py b/third_party/tuntunclaw/openclaw_like/agent.py new file mode 100644 index 0000000000000000000000000000000000000000..87edf21d625fbf5514569e5f1533b9372ab06892 --- /dev/null +++ b/third_party/tuntunclaw/openclaw_like/agent.py @@ -0,0 +1,56 @@ +"""OpenClaw-like agent loop (CLI).""" + +from openclaw_like.session import Session +from openclaw_like.memory import MemoryStore +from openclaw_like.policy import check_user_command +from openclaw_like.tool_router import ToolRouter + + +class IronClawLikeAgent: + def __init__(self) -> None: + self.session = Session() + self.memory = MemoryStore() + self.tools = ToolRouter() + + def run(self) -> None: + print("[agent] OpenClaw-like loop started. Type 'exit' to stop.") + try: + while True: + command = input("claw> ").strip() + if not command: + continue + if command.lower() in {"exit", "quit"}: + break + + turn = self.session.next_turn() + allowed, reason = check_user_command(command) + if not allowed: + print(f"[policy] {reason}") + self.memory.append( + { + "session_id": self.session.session_id, + "turn": turn, + "role": "policy", + "status": "blocked", + "command": command, + "reason": reason, + } + ) + continue + + print("[router] grasp_once") + result = self.tools.grasp_once(command) + print(f"[done] {result}") + self.memory.append( + { + "session_id": self.session.session_id, + "turn": turn, + "role": "agent", + "status": "ok", + "command": command, + "result": result, + } + ) + finally: + self.tools.close() + print("[agent] closed") diff --git a/third_party/tuntunclaw/openclaw_like/memory.py b/third_party/tuntunclaw/openclaw_like/memory.py new file mode 100644 index 0000000000000000000000000000000000000000..23785ca11cbc081c9c49ef6acbc7992ff76a9ff4 --- /dev/null +++ b/third_party/tuntunclaw/openclaw_like/memory.py @@ -0,0 +1,20 @@ +"""Simple JSONL memory for agent interactions.""" + +import json +from datetime import datetime +from pathlib import Path + + +class MemoryStore: + def __init__(self, root: str = "temp/openclaw_memory") -> None: + self.root = Path(root) + self.root.mkdir(parents=True, exist_ok=True) + self.log_path = self.root / "events.jsonl" + + def append(self, payload: dict) -> None: + data = { + "ts": datetime.utcnow().isoformat(timespec="seconds") + "Z", + **payload, + } + with self.log_path.open("a", encoding="utf-8") as f: + f.write(json.dumps(data, ensure_ascii=False) + "\n") diff --git a/third_party/tuntunclaw/openclaw_like/policy.py b/third_party/tuntunclaw/openclaw_like/policy.py new file mode 100644 index 0000000000000000000000000000000000000000..a83a1076022957192bdd14c470cc2038db51df8b --- /dev/null +++ b/third_party/tuntunclaw/openclaw_like/policy.py @@ -0,0 +1,16 @@ +"""Minimal policy gate for user commands.""" + +BLOCKLIST = [ + "self-harm", + "suicide", + "weapon", + "bomb", +] + + +def check_user_command(command: str) -> tuple[bool, str]: + lower = command.lower() + for token in BLOCKLIST: + if token in lower: + return False, f"Blocked by policy token: {token}" + return True, "ok" diff --git a/third_party/tuntunclaw/openclaw_like/session.py b/third_party/tuntunclaw/openclaw_like/session.py new file mode 100644 index 0000000000000000000000000000000000000000..c2d26b29a3af864e6bfe20ebcc40e407109feccd --- /dev/null +++ b/third_party/tuntunclaw/openclaw_like/session.py @@ -0,0 +1,20 @@ +"""OpenClaw-like session primitives.""" + +from dataclasses import dataclass, field +from datetime import datetime +import uuid + + +def _now_iso() -> str: + return datetime.utcnow().isoformat(timespec="seconds") + "Z" + + +@dataclass +class Session: + session_id: str = field(default_factory=lambda: str(uuid.uuid4())) + created_at: str = field(default_factory=_now_iso) + turns: int = 0 + + def next_turn(self) -> int: + self.turns += 1 + return self.turns diff --git a/third_party/tuntunclaw/openclaw_like/tool_router.py b/third_party/tuntunclaw/openclaw_like/tool_router.py new file mode 100644 index 0000000000000000000000000000000000000000..e0f47684a37d206d70564bd3f2cc6d26599bdbe9 --- /dev/null +++ b/third_party/tuntunclaw/openclaw_like/tool_router.py @@ -0,0 +1,629 @@ +"""Tool router for the OpenClaw-like agent flow.""" + +import math +import os +import queue +import sys +import time + +import cv2 +import glfw +import mujoco +import mujoco.viewer +import numpy as np + +ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +sys.path.append(os.path.join(ROOT_DIR, "graspnet-baseline", "models")) +sys.path.append(os.path.join(ROOT_DIR, "graspnet-baseline", "dataset")) +sys.path.append(os.path.join(ROOT_DIR, "graspnet-baseline", "utils")) +sys.path.append(os.path.join(ROOT_DIR, "manipulator_grasp")) + +from camera_view import save_view_config +from manipulator_grasp.env.ur5_grasp_env import UR5GraspEnv + + +class _TeleopViewer: + COLLISION_DEBUG_BODIES = { + "apple_2", + "Duck", + "Knife", + "Hammer", + "Plate", + "Banana", + "DigitalScale", + "GlassCup", + "FlourBag", + "FlowerVase", + "Shelf", + "MugTree", + "KnifeBlock", + } + + def __init__(self, env: UR5GraspEnv) -> None: + self.env = env + self.command_queue: queue.Queue[int] = queue.Queue() + self.viewer = None + self.running = False + self.request_exit = False + + self.translation_step = float(os.getenv("OPENCLAW_TELEOP_STEP", "0.03")) + self.rotation_step_deg = float(os.getenv("OPENCLAW_TELEOP_YAW_DEG", "10")) + self.gripper_step = float(os.getenv("OPENCLAW_TELEOP_GRIP_STEP", "22")) + self.settle_steps = int(os.getenv("OPENCLAW_TELEOP_SETTLE_STEPS", "10")) + self.max_joint_jump = float(os.getenv("OPENCLAW_TELEOP_MAX_JOINT_JUMP", "1.25")) + self.max_joint_jump_norm = float(os.getenv("OPENCLAW_TELEOP_MAX_JOINT_JUMP_NORM", "1.90")) + self.current_gripper = 0.0 + self.action = np.zeros(7, dtype=np.float64) + self.show_collision = False + self.q_home = None + self.home_xyz = None + self.home_yaw = 0.0 + + def _handle_key(self, keycode: int) -> None: + self.command_queue.put(keycode) + + def _current_target_pose(self): + from grasp_process import _build_topdown_pose_from_world + + axis = np.array( + [math.cos(self.target_yaw), math.sin(self.target_yaw), 0.0], + dtype=np.float64, + ) + return _build_topdown_pose_from_world(self.target_xyz, axis) + + def _solve_pose_local(self, xyz: np.ndarray, yaw: float, seed_q: np.ndarray) -> np.ndarray: + robot = self.env.robot + target_pose = self._current_target_pose() if xyz is self.target_xyz and yaw == self.target_yaw else None + if target_pose is None: + from grasp_process import _build_topdown_pose_from_world + + axis = np.array([math.cos(yaw), math.sin(yaw), 0.0], dtype=np.float64) + target_pose = _build_topdown_pose_from_world(xyz, axis) + robot.set_joint(seed_q.tolist()) + q_target = np.array([]) + try: + sol = robot.robot.ikine_LM( + target_pose, + q0=seed_q, + ilimit=60, + slimit=18, + tol=5e-4, + joint_limits=False, + mask=[1, 1, 1, 1, 1, 1], + ) + if getattr(sol, "success", False): + q_target = np.array(sol.q, dtype=np.float64) + except Exception: + q_target = np.array([]) + if len(q_target) == 0: + try: + q_target = np.array(robot.ikine(target_pose), dtype=np.float64) + except Exception: + q_target = np.array([]) + robot.set_joint(seed_q.tolist()) + return q_target + + def _apply_joint_target(self, q_target: np.ndarray) -> None: + q_target = np.array(q_target, dtype=np.float64) + self.action[:6] = q_target + for _ in range(self.settle_steps): + self.env.step(self.action) + self.env.robot.set_joint(q_target.tolist()) + + def _fast_move_to_target(self, label: str, proposed_xyz=None, proposed_yaw=None) -> bool: + previous_q = np.array(self.env.robot.get_joint(), dtype=np.float64) + start_xyz = self.target_xyz.copy() + start_yaw = float(self.target_yaw) + goal_xyz = np.array(proposed_xyz if proposed_xyz is not None else self.target_xyz, dtype=np.float64) + goal_yaw = float(proposed_yaw if proposed_yaw is not None else self.target_yaw) + + for scale in [1.0, 0.5, 0.25, 0.125]: + cand_xyz = start_xyz + scale * (goal_xyz - start_xyz) + cand_yaw = start_yaw + scale * (goal_yaw - start_yaw) + q_target = self._solve_pose_local(cand_xyz, cand_yaw, previous_q) + if len(q_target) == 0: + continue + + wrapped = np.arctan2(np.sin(q_target - previous_q), np.cos(q_target - previous_q)) + if np.max(np.abs(wrapped)) > self.max_joint_jump or np.linalg.norm(wrapped) > self.max_joint_jump_norm: + continue + + self._apply_joint_target(q_target) + self.target_xyz[:] = cand_xyz + self.target_yaw = cand_yaw + if scale < 1.0: + print(f"[teleop] clipped step for {label} by scale={scale:.3f}") + return True + + print(f"[teleop] IK/jump failed for {label}") + return True + + def _clamp_target(self) -> None: + self.target_xyz[0] = float( + np.clip(self.target_xyz[0], self.table_x[0], self.table_x[1]) + ) + self.target_xyz[1] = float( + np.clip(self.target_xyz[1], self.table_y[0], self.table_y[1]) + ) + self.target_xyz[2] = float( + np.clip( + self.target_xyz[2], + self.table_z + 0.08, + self.table_z + 0.60, + ) + ) + + def _reset_home(self) -> None: + if self.q_home is None: + return + self._apply_joint_target(self.q_home) + self.target_xyz[:] = self.home_xyz + self.target_yaw = self.home_yaw + self._clamp_target() + return + + def _initialize_home(self) -> None: + from grasp_process import _build_topdown_pose_from_world + + seed_q = np.array([0.0, 0.0, np.pi / 2, 0.0, -np.pi / 2, 0.0], dtype=np.float64) + self.home_xyz = np.array( + [self.table_center[0], self.table_center[1], self.table_z + 0.30], + dtype=np.float64, + ) + best = None + for yaw in [0.0, math.pi / 2, -math.pi / 2, math.pi]: + axis = np.array([math.cos(yaw), math.sin(yaw), 0.0], dtype=np.float64) + pose = _build_topdown_pose_from_world(self.home_xyz, axis) + robot = self.env.robot + robot.set_joint(seed_q.tolist()) + try: + sol = robot.robot.ikine_LM( + pose, + q0=seed_q, + ilimit=80, + slimit=20, + tol=1e-4, + joint_limits=False, + mask=[1, 1, 1, 1, 1, 1], + ) + q_candidate = np.array(sol.q, dtype=np.float64) if getattr(sol, "success", False) else np.array([]) + except Exception: + q_candidate = np.array([]) + robot.set_joint(seed_q.tolist()) + if len(q_candidate) == 0: + continue + diff = np.arctan2(np.sin(q_candidate - seed_q), np.cos(q_candidate - seed_q)) + score = float(np.linalg.norm(diff)) + if best is None or score < best[0]: + best = (score, yaw, q_candidate) + + if best is None: + self.q_home = seed_q.copy() + self.home_yaw = 0.0 + else: + self.home_yaw = float(best[1]) + self.q_home = np.array(best[2], dtype=np.float64) + + def _set_collision_debug_group(self, enabled: bool) -> None: + model = self.env.mj_model + for geom_id in range(model.ngeom): + body_id = int(model.geom_bodyid[geom_id]) + body_name = mujoco.mj_id2name(model, mujoco.mjtObj.mjOBJ_BODY, body_id) + if body_name in self.COLLISION_DEBUG_BODIES and model.geom_group[geom_id] in {0, 2}: + model.geom_group[geom_id] = 2 if enabled else 0 + if model.geom_rgba[geom_id, 3] <= 0.0: + model.geom_rgba[geom_id] = np.array([0.2, 0.9, 0.2, 0.35], dtype=np.float32) + + def _set_overlay(self) -> None: + if self.viewer is None: + return + left = "\n".join( + [ + "OpenClaw Teleop", + "", + "Move XY: Arrow keys", + "Move Z: PageUp/PageDown", + "Rotate Z(yaw): F9 / F10", + "Gripper: O open / C close", + "Step size: - / =", + "Home: H", + "Collision debug: F3", + "Save view: F12", + "Quit: Esc / Q", + ] + ) + right = "\n".join( + [ + f"xyz = [{self.target_xyz[0]:.3f}, {self.target_xyz[1]:.3f}, {self.target_xyz[2]:.3f}]", + f"yaw = {math.degrees(self.target_yaw):.1f} deg", + f"gripper = {self.action[-1]:.1f}", + "", + f"translate step = {self.translation_step:.3f} m", + f"rotate step = {self.rotation_step_deg:.1f} deg", + f"settle steps = {self.settle_steps}", + f"jump limit = {self.max_joint_jump:.2f} rad", + f"collision debug = {self.show_collision}", + f"scene = {self.env.scene_path.name if self.env.scene_path else 'unknown'}", + ] + ) + texts = [ + ( + mujoco.mjtFontScale.mjFONTSCALE_150, + mujoco.mjtGridPos.mjGRID_TOPLEFT, + left, + right, + ) + ] + self.viewer.set_texts(texts) + + def _save_current_view(self) -> None: + if self.viewer is None or self.env.scene_path is None: + return + path = save_view_config( + self.env.scene_path, + lookat=self.viewer.cam.lookat, + azimuth=self.viewer.cam.azimuth, + elevation=self.viewer.cam.elevation, + distance=self.viewer.cam.distance, + ) + print(f"[teleop] saved view: {path}") + + def _process_commands(self) -> bool: + moved = False + delta_xyz = np.zeros(3, dtype=np.float64) + delta_yaw = 0.0 + while True: + try: + keycode = self.command_queue.get_nowait() + except queue.Empty: + break + + if keycode in (glfw.KEY_ESCAPE, glfw.KEY_Q): + self.request_exit = True + return False + if keycode == glfw.KEY_UP: + delta_xyz[0] += self.translation_step + moved = True + elif keycode == glfw.KEY_DOWN: + delta_xyz[0] -= self.translation_step + moved = True + elif keycode == glfw.KEY_LEFT: + delta_xyz[1] += self.translation_step + moved = True + elif keycode == glfw.KEY_RIGHT: + delta_xyz[1] -= self.translation_step + moved = True + elif keycode == glfw.KEY_PAGE_UP: + delta_xyz[2] += self.translation_step + moved = True + elif keycode == glfw.KEY_PAGE_DOWN: + delta_xyz[2] -= self.translation_step + moved = True + elif keycode == glfw.KEY_F9: + delta_yaw += math.radians(self.rotation_step_deg) + moved = True + elif keycode == glfw.KEY_F10: + delta_yaw -= math.radians(self.rotation_step_deg) + moved = True + elif keycode in (ord("O"), ord("o")): + self.current_gripper = float( + np.clip(self.current_gripper - self.gripper_step, 0.0, 255.0) + ) + self.action[-1] = self.current_gripper + elif keycode in (ord("C"), ord("c")): + self.current_gripper = float( + np.clip(self.current_gripper + self.gripper_step, 0.0, 255.0) + ) + self.action[-1] = self.current_gripper + elif keycode in (ord("-"),): + self.translation_step = max(0.005, self.translation_step - 0.005) + elif keycode in (ord("="),): + self.translation_step = min(0.08, self.translation_step + 0.005) + elif keycode in (ord("H"), ord("h")): + self._reset_home() + elif keycode == glfw.KEY_F3: + self.show_collision = not self.show_collision + self._set_collision_debug_group(self.show_collision) + try: + self.viewer.opt.geomgroup[2] = 1 if self.show_collision else 0 + except Exception: + pass + elif keycode == glfw.KEY_F12: + self._save_current_view() + + if moved: + proposed_xyz = self.target_xyz.copy() + delta_xyz + proposed_yaw = float(self.target_yaw + delta_yaw) + old_xyz = self.target_xyz.copy() + old_yaw = float(self.target_yaw) + self.target_xyz[:] = proposed_xyz + self.target_yaw = proposed_yaw + self._clamp_target() + proposed_xyz = self.target_xyz.copy() + proposed_yaw = float(self.target_yaw) + self.target_xyz[:] = old_xyz + self.target_yaw = old_yaw + self._fast_move_to_target("teleop", proposed_xyz=proposed_xyz, proposed_yaw=proposed_yaw) + return True + + def run(self): + from grasp_process import TABLE_SURFACE_Z, _table_workspace_bounds + + if self.env.mj_viewer is not None: + try: + self.env.mj_viewer.close() + except Exception: + pass + self.env.mj_viewer = None + + self.table_z = TABLE_SURFACE_Z + self.table_x, self.table_y = _table_workspace_bounds(self.env) + self.table_center = np.array( + [ + (self.table_x[0] + self.table_x[1]) * 0.5, + (self.table_y[0] + self.table_y[1]) * 0.5, + ], + dtype=np.float64, + ) + self.target_xyz = np.array([self.table_center[0], self.table_center[1], self.table_z + 0.30], dtype=np.float64) + self.target_yaw = 0.0 + + self.action[:] = 0.0 + self.action[:6] = np.array(self.env.robot.get_joint(), dtype=np.float64) + self.action[-1] = self.current_gripper + self._initialize_home() + self._reset_home() + + print("[teleop] viewer mode started") + + with mujoco.viewer.launch_passive( + self.env.mj_model, + self.env.mj_data, + key_callback=self._handle_key, + show_left_ui=True, + show_right_ui=True, + ) as viewer: + self.viewer = viewer + self.request_exit = False + self._set_collision_debug_group(False) + try: + self.viewer.opt.geomgroup[0] = 0 + self.viewer.opt.geomgroup[2] = 0 + except Exception: + pass + self.env._apply_saved_view(self.viewer) + self.running = True + + while viewer.is_running() and self.running: + with viewer.lock(): + if not self._process_commands(): + self.running = False + for _ in range(2): + self.env.step(self.action) + self._set_overlay() + if self.request_exit: + break + viewer.sync() + time.sleep(1.0 / 60.0) + + self.viewer = None + self.env._try_launch_viewer() + return {"status": "ok", "task": "teleop"} + + +class ToolRouter: + OBJECT_ALIASES = { + "banana": ["banana", "bananas", "xiangjiao", "香蕉"], + "apple": ["apple", "pingguo", "苹果"], + "chocolate": ["chocolate", "choco", "chocolate bar", "巧克力", "巧克力棒", "巧克力块"], + "duck": ["duck", "yellow duck", "little yellow duck", "toy duck", "duckie", "小黄鸭", "鸭子"], + "hammer": ["hammer", "锤子"], + "knife": ["knife", "刀", "小刀"], + "plate": ["plate", "dish", "saucer", "盘子", "碟子", "餐盘"], + "shelf": ["shelf", "rack", "layer shelf", "置物架", "架子", "层架"], + } + PLACE_KEYWORDS = ["place", "put", "move", "relocate", "放", "摆", "移到", "放到", "放在"] + RELATION_KEYWORDS = { + "in": ["in", "inside", "into", "放进", "放到里面", "放到盒子里", "里面"], + "on_top_of": ["on top of", "on", "top of", "上面", "顶上", "架子上", "层板上"], + "left_of": ["left of", "to the left of", "左边", "左侧"], + "right_of": ["right of", "to the right of", "右边", "右侧"], + "in_front_of": ["in front of", "front of", "前面", "前方"], + "behind": ["behind", "at the back of", "后面", "后方"], + "next_to": ["next to", "beside", "near", "旁边", "附近", "边上"], + } + DANCE_KEYWORDS = ["dance", "跳舞", "wave", "摇摆"] + TELEOP_KEYWORDS = [ + "teleop", + "tele-operation", + "manual", + "keyboard", + "tail off", + "遥操作", + "手动", + "键盘控制", + ] + + def __init__(self) -> None: + self.env = UR5GraspEnv() + self.env.reset() + + def close(self) -> None: + self.env.close() + + def _capture_rgbd(self): + for _ in range(500): + self.env.step() + imgs = self.env.render() + color_img = cv2.cvtColor(imgs["img"], cv2.COLOR_RGB2BGR) + depth_img = imgs["depth"] + return color_img, depth_img + + def _extract_objects(self, command_text: str): + text = command_text.lower() + hits = [] + for canonical, aliases in self.OBJECT_ALIASES.items(): + best_index = None + for alias in aliases: + index = text.find(alias.lower()) + if index >= 0 and (best_index is None or index < best_index): + best_index = index + if best_index is not None: + hits.append((best_index, canonical)) + hits.sort(key=lambda item: item[0]) + ordered = [] + for _, canonical in hits: + if canonical not in ordered: + ordered.append(canonical) + return ordered + + def _parse_task(self, command_text: str): + text = command_text.lower() + if any(keyword in text for keyword in self.TELEOP_KEYWORDS): + return {"type": "teleop", "source": None, "destination": None, "relation": None} + if any(keyword in text for keyword in self.DANCE_KEYWORDS): + return {"type": "dance", "source": None, "destination": None, "relation": None} + + objects = self._extract_objects(command_text) + relation = "place" + for relation_name, keywords in self.RELATION_KEYWORDS.items(): + if any(keyword in text for keyword in keywords): + relation = relation_name + break + + has_place_verb = any(keyword in text for keyword in self.PLACE_KEYWORDS) + has_to_connector = " to " in f" {text} " + is_place = len(objects) >= 2 and (has_place_verb or relation != "place" or has_to_connector) + + if is_place: + return { + "type": "pick_place", + "source": objects[0], + "destination": objects[1], + "relation": relation, + } + source = objects[0] if objects else command_text + return {"type": "grasp", "source": source, "destination": None, "relation": None} + + def teleop_once(self): + return _TeleopViewer(self.env).run() + + def dance_once(self): + from grasp_process import _move_joint_waypoint + + robot = self.env.robot + action = np.zeros(7) + q_start = np.array(robot.get_joint(), dtype=np.float64) + dance_targets = [ + np.array([0.4, -0.8, 1.6, -1.2, -1.2, 0.0], dtype=np.float64), + np.array([-0.4, -0.8, 1.6, -1.2, -1.2, 0.0], dtype=np.float64), + np.array([0.5, -1.1, 1.3, -0.8, -1.5, 0.8], dtype=np.float64), + np.array([-0.5, -1.1, 1.3, -0.8, -1.5, -0.8], dtype=np.float64), + q_start, + ] + for q_target in dance_targets: + _move_joint_waypoint(self.env, robot, action, q_target, 0.8) + return {"status": "ok", "task": "dance"} + + def grasp_once(self, command_text: str): + from grasp_process import ( + estimate_body_image_bbox, + estimate_direct_grasp_target_world, + estimate_place_target_world, + execute_grasp, + run_grasp_inference, + ) + from vlm_process import segment_image + + color_img, depth_img = self._capture_rgbd() + task = self._parse_task(command_text) + if task["type"] == "teleop": + return self.teleop_once() + if task["type"] == "dance": + return self.dance_once() + + source_bbox = ( + estimate_body_image_bbox(self.env, task["source"], color_img.shape) + if isinstance(task["source"], str) + else None + ) + source_mask = segment_image( + color_img, + output_mask="mask_source.png", + command_text=task["source"], + bbox_override=source_bbox, + label_override=task["source"] if isinstance(task["source"], str) else None, + ) + gg = run_grasp_inference( + color_img, + depth_img, + source_mask, + camera_fovy_deg=getattr(self.env, "camera_fovy_deg", 45.0), + ) + source_target_world = None + if task["source"] in {"apple", "duck"}: + source_target_world, _ = estimate_direct_grasp_target_world( + self.env, + depth_img, + source_mask, + source_name=task["source"], + ) + print(f"[grasp] direct top-down target for {task['source']}: {source_target_world.tolist()}") + + place_target_world = None + place_mode = None + if task["type"] == "pick_place": + if task["destination"] == "plate" and task["relation"] == "in": + task["relation"] = "on_top_of" + if task["destination"] == "plate": + place_mode = "drop_above_plate" + destination_bbox = ( + estimate_body_image_bbox(self.env, task["destination"], color_img.shape) + if isinstance(task["destination"], str) + else None + ) + destination_mask = segment_image( + color_img, + output_mask="mask_destination.png", + command_text=task["destination"], + bbox_override=destination_bbox, + label_override=task["destination"] if isinstance(task["destination"], str) else None, + ) + place_target_world = estimate_place_target_world( + self.env, + depth_img, + destination_mask, + source_mask=source_mask, + relation=task["relation"], + source_name=task["source"], + destination_name=task["destination"], + ) + print( + f"[place] source={task['source']} destination={task['destination']} " + f"relation={task['relation']} target={place_target_world.tolist()}" + ) + + execute_grasp( + self.env, + gg, + place_target_world=place_target_world, + grasp_target_world=source_target_world, + source_name=task["source"] if isinstance(task["source"], str) else None, + place_mode=place_mode, + ) + from workflow_hooks import get_inventory_store, record_task_success_effects + + inventory_event = record_task_success_effects( + task=task, + command=command_text, + session_id=None, + ) + return { + "status": "ok", + "task": task["type"], + "source": task["source"], + "destination": task["destination"], + "grasp_count": len(gg), + "inventory_event": inventory_event, + "inventory": get_inventory_store().snapshot(), + } diff --git a/third_party/tuntunclaw/requirements-py311-lock.txt b/third_party/tuntunclaw/requirements-py311-lock.txt new file mode 100644 index 0000000000000000000000000000000000000000..66fae640c6424acbfc8c7f9a87589e259e2b49a5 --- /dev/null +++ b/third_party/tuntunclaw/requirements-py311-lock.txt @@ -0,0 +1,31 @@ +# Resolved versions from current py311 environment +--extra-index-url https://download.pytorch.org/whl/cu124 + +numpy==1.26.4 +scipy==1.16.0 +mpmath==1.3.0 +sympy==1.13.1 +jinja2==3.1.6 +networkx==3.4.2 +pillow==11.3.0 +opencv-python==4.11.0.86 +open3d==0.19.0 +plotly==5.24.1 +mujoco==3.3.7 +scikit-learn==1.5.2 +torch==2.6.0+cu124 +torchvision==0.21.0+cu124 +torchaudio==2.6.0+cu124 +openai==2.26.0 +ultralytics==8.3.98 +fastapi +uvicorn +spatialmath-python==1.1.14 +roboticstoolbox-python==1.1.1 +modern-robotics==1.1.1 +transforms3d==0.4.2 +ik-geo==1.0.3 +autolab-core==1.1.1 +cvxopt==1.3.3 +pyhull==2015.2.1 +pydub==0.25.1 diff --git a/third_party/tuntunclaw/requirements-py311.txt b/third_party/tuntunclaw/requirements-py311.txt new file mode 100644 index 0000000000000000000000000000000000000000..45e8b353c1a86b5583b0188606e6cf5bfacb94f9 --- /dev/null +++ b/third_party/tuntunclaw/requirements-py311.txt @@ -0,0 +1,46 @@ +# Core dependencies for VLM_Grasp_Interactive on Python 3.11 +# Install with: python -m pip install -r requirements-py311.txt + +--extra-index-url https://download.pytorch.org/whl/cu124 + +numpy==1.26.4 +scipy==1.16.0 +mpmath==1.3.0 +sympy==1.13.1 +jinja2==3.1.6 +networkx==3.4.2 +pillow==11.3.0 +opencv-python==4.11.0.86 +open3d==0.19.0 +plotly==5.24.1 +mujoco==3.3.7 +scikit-learn==1.5.2 + +# PyTorch CUDA 12.4 stack +torch==2.6.0+cu124 +torchvision==0.21.0+cu124 +torchaudio==2.6.0+cu124 + +# LLM/VLM + segmentation +openai==2.26.0 +ultralytics==8.3.98 +fastapi +uvicorn + +# Robotics stack +spatialmath-python==1.1.14 +roboticstoolbox-python==1.1.1 +modern-robotics==1.1.1 +transforms3d==0.4.2 +ik-geo==1.0.3 + +# GraspNet API dependencies +autolab-core==1.1.1 +cvxopt==1.3.3 +pyhull==2015.2.1 + +# Audio utilities used by original code (optional but kept for compatibility) +openai-whisper +soundfile +sounddevice +pydub diff --git a/third_party/tuntunclaw/scripts/download_large_assets.py b/third_party/tuntunclaw/scripts/download_large_assets.py new file mode 100644 index 0000000000000000000000000000000000000000..73bb1adbb29850c76c921dc09e3b71e4efc6e204 --- /dev/null +++ b/third_party/tuntunclaw/scripts/download_large_assets.py @@ -0,0 +1,38 @@ +from __future__ import annotations + +import os +import urllib.request +from pathlib import Path + + +REPO_URL = "https://huggingface.co/datasets/Datawhale/tuntunclaw-assets/resolve/main" + +FILES = [ + "assets/fig.png", + "manipulator_grasp/assets/target_basket_medium/materials/textures/texture.png", + "manipulator_grasp/assets/libero_basket/texture.png", +] + + +def download_file(rel_path: str, root: Path) -> None: + target = root / rel_path + target.parent.mkdir(parents=True, exist_ok=True) + request = urllib.request.Request(f"{REPO_URL}/{rel_path}") + token = os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACE_HUB_TOKEN") + if token: + request.add_header("Authorization", f"Bearer {token}") + + print(f"Downloading {rel_path}") + with urllib.request.urlopen(request) as response, target.open("wb") as output: + output.write(response.read()) + + +def main() -> None: + root = Path(__file__).resolve().parents[1] + for rel_path in FILES: + download_file(rel_path, root) + print("Large assets are ready.") + + +if __name__ == "__main__": + main() diff --git a/third_party/tuntunclaw/setup_py311_mamba.ps1 b/third_party/tuntunclaw/setup_py311_mamba.ps1 new file mode 100644 index 0000000000000000000000000000000000000000..93ea885bea684c8cfa8d92e3f340957984fb50f3 --- /dev/null +++ b/third_party/tuntunclaw/setup_py311_mamba.ps1 @@ -0,0 +1,41 @@ +param( + [string]$EnvName = "vlm_grasp311", + [string]$ProjectRoot = "C:\\oc\\VLM_Grasp_Interactive" +) + +$ErrorActionPreference = "Stop" + +function Resolve-Mamba { + if (Get-Command mamba -ErrorAction SilentlyContinue) { return "mamba" } + if (Get-Command micromamba -ErrorAction SilentlyContinue) { return "micromamba" } + throw "Neither mamba nor micromamba is available in PATH." +} + +$mambaExe = Resolve-Mamba +Write-Host "Using: $mambaExe" + +Push-Location $ProjectRoot +try { + $env:PYTHONNOUSERSITE = "1" + & $mambaExe create -n $EnvName python=3.11 pip cmake ninja -y + & $mambaExe run -n $EnvName python -m pip install -r requirements-py311.txt + # Hard-lock critical ABI-sensitive packages to avoid NumPy 2.x binary mismatch. + & $mambaExe run -n $EnvName python -m pip install --force-reinstall --no-deps ` + numpy==1.26.4 scipy==1.16.0 matplotlib==3.10.6 pillow==11.3.0 roboticstoolbox-python==1.1.1 + + Push-Location "$ProjectRoot\graspnet-baseline\pointnet2" + try { + & $mambaExe run -n $EnvName python setup.py install + } + finally { + Pop-Location + } + + & $mambaExe run -n $EnvName python -c "import numpy,scipy,roboticstoolbox; print('numpy',numpy.__version__); print('scipy',scipy.__version__); print('rtb',roboticstoolbox.__version__)" + + Write-Host "Install completed for env: $EnvName" + Write-Host "Run: $mambaExe run -n $EnvName python main_openclaw.py" +} +finally { + Pop-Location +} diff --git a/third_party/tuntunclaw/sitecustomize.py b/third_party/tuntunclaw/sitecustomize.py new file mode 100644 index 0000000000000000000000000000000000000000..7237c7456e42af59611cd3ac143d81094794986b --- /dev/null +++ b/third_party/tuntunclaw/sitecustomize.py @@ -0,0 +1,27 @@ +import site +import sys + + +def _drop_user_site_packages() -> None: + paths_to_remove = set() + + user_site = None + try: + user_site = site.getusersitepackages() + except Exception: + user_site = None + + if user_site: + paths_to_remove.add(user_site) + + for path in list(sys.path): + if "AppData\\Roaming\\Python\\Python311\\site-packages" in path: + paths_to_remove.add(path) + + if not paths_to_remove: + return + + sys.path[:] = [p for p in sys.path if p not in paths_to_remove] + + +_drop_user_site_packages() diff --git a/third_party/tuntunclaw/vlm_process.py b/third_party/tuntunclaw/vlm_process.py new file mode 100644 index 0000000000000000000000000000000000000000..7e2bbd72bca9a8c525d911d2009dd5db417d2cd3 --- /dev/null +++ b/third_party/tuntunclaw/vlm_process.py @@ -0,0 +1,548 @@ +import base64 +import json +import os +import re +import textwrap +import time +import urllib.error +import urllib.request +from io import BytesIO + +import cv2 +import numpy as np +import torch +from openai import OpenAI +from PIL import Image +from ultralytics.models.sam import Predictor as SAMPredictor + + +def _load_env_from_file(path: str) -> None: + if not os.path.exists(path): + return + with open(path, "r", encoding="utf-8") as f: + for raw in f: + line = raw.strip() + if not line or line.startswith("#") or "=" not in line: + continue + key, value = line.split("=", 1) + os.environ.setdefault(key.strip(), value.strip().strip('"').strip("'")) + + +def _bootstrap_env() -> None: + # Priority: process env > project .env > ~/.env + _load_env_from_file(os.path.expanduser("~/.env")) + _load_env_from_file(os.path.join(os.getcwd(), ".env")) + + +def _build_client_and_model() -> tuple[OpenAI, str]: + _bootstrap_env() + + api_key = os.getenv("OPENAI_API_KEY", "").strip() + base_url = os.getenv("OPENAI_BASE_URL", "").strip() + model = os.getenv("VLM_MODEL", "qwen-vl-plus").strip() + + if not api_key and os.getenv("GEMINI_API_KEY"): + api_key = os.getenv("GEMINI_API_KEY", "").strip() + base_url = os.getenv( + "GEMINI_BASE_URL", + "https://generativelanguage.googleapis.com/v1beta/openai/", + ).strip() + model = os.getenv("GEMINI_MODEL", "gemini-3-flash").strip() + + if not api_key: + raise RuntimeError( + "Missing API key. Set OPENAI_API_KEY or GEMINI_API_KEY in ~/.env." + ) + + kwargs = {"api_key": api_key} + if base_url: + kwargs["base_url"] = base_url + return OpenAI(**kwargs), model + + +def encode_np_array(image_np: np.ndarray) -> str: + image = Image.fromarray(np.asarray(image_np, dtype=np.uint8), mode="RGB") + buffer = BytesIO() + image.save(buffer, format="JPEG", quality=95) + return base64.b64encode(buffer.getvalue()).decode("utf-8") + + +def generate_robot_actions(user_command: str, image_input: np.ndarray | None = None) -> dict: + """Call multimodal LLM and parse natural language + JSON bbox.""" + client, model_name = _build_client_and_model() + + system_prompt = textwrap.dedent( + """ + 你是机械臂视觉控制助手。请从图像和用户指令中选出目标物体， + 输出两部分： + 1) 一句自然语言说明（仅说明目标） + 2) 下一行输出 JSON: + { + "name": "object_name", + "bbox": [x1, y1, x2, y2] + } + 注意：只输出上述两部分，不要多余解释。 + """ + ).strip() + + messages = [{"role": "system", "content": system_prompt}] + user_content = [] + + if image_input is not None: + base64_img = encode_np_array(image_input) + user_content.append( + { + "type": "image_url", + "image_url": {"url": f"data:image/jpeg;base64,{base64_img}"}, + } + ) + + user_content.append({"type": "text", "text": user_command}) + messages.append({"role": "user", "content": user_content}) + + last_error = None + for attempt in range(1, 4): + try: + completion = client.chat.completions.create( + model=model_name, + messages=messages, + temperature=0.1, + timeout=60, + ) + + content = completion.choices[0].message.content or "" + match = re.search(r"(\{.*\})", content, re.DOTALL) + if match: + json_str = match.group(1) + try: + coord = json.loads(json_str) + except Exception: + coord = {} + natural_response = content[: match.start()].strip() + else: + natural_response = content.strip() + coord = {} + + return {"response": natural_response, "coordinates": coord} + except Exception as exc: + last_error = exc + print(f"LLM request failed (attempt {attempt}/3): {exc}") + time.sleep(1.5 * attempt) + + print(f"LLM request failed permanently: {last_error}") + return {"response": "处理失败", "coordinates": {}} + + +def _default_sam_device() -> str: + configured = os.getenv("OPENCLAW_SAM_DEVICE", "").strip() + if configured: + return configured + + if not torch.cuda.is_available(): + return "cpu" + + total_memory = torch.cuda.get_device_properties(0).total_memory + if total_memory <= 8 * 1024**3: + return "cpu" + + return "cuda:0" + + +def choose_model() -> SAMPredictor: + device = _default_sam_device() + overrides = { + "task": "segment", + "mode": "predict", + "model": "sam_b.pt", + "conf": 0.25, + "save": False, + "device": device, + } + print(f"[sam] local_device={device}") + return SAMPredictor(overrides=overrides) + + +def process_sam_results(results): + if not results or not results[0].masks: + return None, None + + mask = results[0].masks.data[0].cpu().numpy() + mask = (mask > 0).astype(np.uint8) * 255 + + contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) + if not contours: + return None, None + + m = cv2.moments(contours[0]) + if m["m00"] == 0: + return None, mask + + cx = int(m["m10"] / m["m00"]) + cy = int(m["m01"] / m["m00"]) + return (cx, cy), mask + + +def _bbox_mask(shape: tuple[int, int], bbox) -> np.ndarray | None: + if not bbox or len(bbox) != 4: + return None + height, width = shape + x1, y1, x2, y2 = [int(v) for v in bbox] + x1 = max(0, min(width - 1, x1)) + x2 = max(0, min(width - 1, x2)) + y1 = max(0, min(height - 1, y1)) + y2 = max(0, min(height - 1, y2)) + if x2 <= x1 or y2 <= y1: + return None + mask = np.zeros((height, width), dtype=np.uint8) + mask[y1:y2, x1:x2] = 255 + return mask + + +def _full_image_mask(shape: tuple[int, int]) -> np.ndarray: + height, width = shape + mask = np.zeros((height, width), dtype=np.uint8) + mask[:, :] = 255 + return mask + + +def _normalize_object_name(name: str) -> str: + text = (name or "").strip().lower() + aliases = { + "banana": ["banana", "bananas", "xiangjiao", "香蕉"], + "apple": ["apple", "pingguo", "苹果"], + "hammer": ["hammer", "chui", "chuizi", "锤子"], + "knife": ["knife", "dao", "xiaodao", "刀", "小刀"], + "duck": ["duck", "yellow duck", "toy duck", "ya", "yazi", "鸭子", "小黄鸭"], + } + for canonical, values in aliases.items(): + if text == canonical or text in values: + return canonical + return text or "object" + + +def _extract_segmentation_label(command_text: str, detection_info: dict) -> str: + name = str(detection_info.get("name", "")).strip() + if name: + return _normalize_object_name(name) + + command = command_text or "" + command_lower = command.lower() + english_aliases = { + "banana": "banana", + "apple": "apple", + "hammer": "hammer", + "knife": "knife", + "duck": "duck", + } + for key, value in english_aliases.items(): + if key in command_lower: + return value + + chinese_aliases = { + "香蕉": "banana", + "苹果": "apple", + "锤子": "hammer", + "小刀": "knife", + "刀": "knife", + "小黄鸭": "duck", + "鸭子": "duck", + } + for key, value in chinese_aliases.items(): + if key in command: + return value + + return "object" + + +def _segment_with_roboflow(image_input: np.ndarray, label: str) -> np.ndarray | None: + api_key = os.getenv("ROBOFLOW_API_KEY", "").strip() + if not api_key: + return None + + base_url = os.getenv( + "ROBOFLOW_SAM_URL", + "https://serverless.roboflow.com/sam3/concept_segment", + ).strip() + payload = { + "image": {"type": "base64", "value": encode_np_array(image_input)}, + "prompts": [{"type": "text", "text": label}], + "format": "polygon", + "output_prob_thresh": 0.2, + } + + data = None + last_error = None + for attempt in range(1, 4): + request = urllib.request.Request( + url=f"{base_url}?api_key={api_key}", + data=json.dumps(payload).encode("utf-8"), + headers={"Content-Type": "application/json"}, + method="POST", + ) + try: + with urllib.request.urlopen(request, timeout=60) as response: + data = json.loads(response.read().decode("utf-8")) + break + except urllib.error.HTTPError as exc: + body = exc.read().decode("utf-8", errors="ignore") + print(f"[sam] Roboflow HTTP {exc.code} (attempt {attempt}/3): {body[:300]}") + last_error = exc + except Exception as exc: + print(f"[sam] Roboflow request failed (attempt {attempt}/3): {exc}") + last_error = exc + time.sleep(1.5 * attempt) + + if data is None: + print(f"[sam] Roboflow failed permanently for '{label}': {last_error}") + return None + + prompt_results = data.get("prompt_results") or [] + predictions = [] + for prompt_result in prompt_results: + predictions.extend(prompt_result.get("predictions") or []) + + if not predictions: + print(f"[sam] Roboflow returned no predictions for '{label}'.") + return None + + height, width = image_input.shape[:2] + mask = np.zeros((height, width), dtype=np.uint8) + best_prediction = max( + predictions, + key=lambda item: float(item.get("confidence") or 0.0), + ) + polygons = best_prediction.get("masks") or [] + for polygon in polygons: + points = np.asarray(polygon, dtype=np.int32) + if points.ndim != 2 or len(points) < 3: + continue + points[:, 0] = np.clip(points[:, 0], 0, width - 1) + points[:, 1] = np.clip(points[:, 1], 0, height - 1) + cv2.fillPoly(mask, [points], 255) + + if not np.any(mask): + print("[sam] Roboflow prediction did not produce a valid mask.") + return None + + print( + f"[sam] Roboflow SAM3 success: label={label}, " + f"confidence={float(best_prediction.get('confidence') or 0.0):.3f}" + ) + return mask + + +def _segment_with_local_sam( + image_input: np.ndarray, + bbox, +) -> np.ndarray | None: + # image_input from MuJoCo render() is already RGB. + image_rgb = np.asarray(image_input, dtype=np.uint8) + + if torch.cuda.is_available(): + torch.cuda.empty_cache() + + predictor = None + try: + predictor = choose_model() + predictor.set_image(image_rgb) + + if bbox: + results = predictor(bboxes=[bbox]) + _, mask = process_sam_results(results) + print(f"Using bbox from VLM: {bbox}") + else: + print("VLM did not return bbox. Click object in window.") + cv2.namedWindow("Select Object", cv2.WINDOW_NORMAL) + cv2.imshow("Select Object", cv2.cvtColor(image_rgb, cv2.COLOR_RGB2BGR)) + point = [] + + def click_handler(event, x, y, flags, param): + if event == cv2.EVENT_LBUTTONDOWN: + point.extend([x, y]) + cv2.setMouseCallback("Select Object", lambda *args: None) + + cv2.setMouseCallback("Select Object", click_handler) + while True: + _ = cv2.waitKey(100) + if point: + break + if cv2.getWindowProperty("Select Object", cv2.WND_PROP_VISIBLE) < 1: + print("Selection window closed.") + return None + cv2.destroyAllWindows() + results = predictor(points=[point], labels=[1]) + _, mask = process_sam_results(results) + + return mask + except torch.OutOfMemoryError as exc: + print(f"[sam] local SAM OOM: {exc}") + return None + except Exception as exc: + print(f"[sam] local SAM failed: {exc}") + return None + finally: + if predictor is not None: + del predictor + if torch.cuda.is_available(): + torch.cuda.empty_cache() + + +def _segment_with_fallback( + image_input: np.ndarray, + bbox, + label: str, +) -> tuple[np.ndarray | None, str]: + backend = os.getenv("OPENCLAW_SEGMENT_BACKEND", "auto").strip().lower() + + if backend in {"auto", "roboflow"}: + mask = _segment_with_roboflow(image_input, label) + if mask is not None: + return mask, "roboflow_sam3" + if backend == "roboflow": + return _bbox_mask(image_input.shape[:2], bbox), "bbox_fallback" + + if backend in {"auto", "local", "sam", "ultralytics"}: + mask = _segment_with_local_sam(image_input, bbox) + if mask is not None: + return mask, "local_sam" + if backend in {"local", "sam", "ultralytics"}: + return _bbox_mask(image_input.shape[:2], bbox), "bbox_fallback" + + return _bbox_mask(image_input.shape[:2], bbox), "bbox_fallback" + + +def _save_segmentation_debug( + image_input: np.ndarray, + mask: np.ndarray | None, + bbox, + output_mask: str, + label: str, + backend: str, +) -> None: + stem, _ = os.path.splitext(output_mask) + input_path = f"{stem}_input.png" + bbox_path = f"{stem}_bbox.png" + overlay_path = f"{stem}_overlay.png" + + cv2.imwrite(input_path, cv2.cvtColor(image_input, cv2.COLOR_RGB2BGR)) + + bbox_image = image_input.copy() + if bbox and len(bbox) == 4: + x1, y1, x2, y2 = [int(v) for v in bbox] + cv2.rectangle(bbox_image, (x1, y1), (x2, y2), (0, 180, 255), 2) + cv2.putText( + bbox_image, + f"{label} [{backend}]", + (max(0, x1), max(20, y1 - 10)), + cv2.FONT_HERSHEY_SIMPLEX, + 0.6, + (0, 180, 255), + 2, + cv2.LINE_AA, + ) + else: + cv2.putText( + bbox_image, + f"{label} [{backend}]", + (12, 28), + cv2.FONT_HERSHEY_SIMPLEX, + 0.7, + (0, 180, 255), + 2, + cv2.LINE_AA, + ) + cv2.imwrite(bbox_path, cv2.cvtColor(bbox_image, cv2.COLOR_RGB2BGR)) + + overlay = image_input.copy() + if mask is not None and np.any(mask > 0): + colored = np.zeros_like(overlay) + colored[:, :] = (60, 220, 60) + alpha = 0.35 + overlay = np.where( + mask[..., None] > 0, + (overlay * (1.0 - alpha) + colored * alpha).astype(np.uint8), + overlay, + ) + contours, _ = cv2.findContours( + (mask > 0).astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE + ) + cv2.drawContours(overlay, contours, -1, (0, 255, 0), 2) + if bbox and len(bbox) == 4: + x1, y1, x2, y2 = [int(v) for v in bbox] + cv2.rectangle(overlay, (x1, y1), (x2, y2), (0, 180, 255), 2) + cv2.putText( + overlay, + f"{label} [{backend}]", + (12, 28), + cv2.FONT_HERSHEY_SIMPLEX, + 0.7, + (0, 255, 255), + 2, + cv2.LINE_AA, + ) + cv2.imwrite(overlay_path, cv2.cvtColor(overlay, cv2.COLOR_RGB2BGR)) + print( + f"[sam] debug images: {input_path}, {bbox_path}, {overlay_path}" + ) + + +def segment_image( + image_input: np.ndarray, + output_mask: str = "mask1.png", + command_text: str | None = None, + bbox_override=None, + label_override: str | None = None, +): + if command_text is None: + print("Please describe target object and grasp intent.") + command_text = input("Enter command: ").strip() + + if not command_text: + print("No command provided.") + return None + + result = generate_robot_actions(command_text, image_input) + natural_response = result.get("response", "") + detection_info = result.get("coordinates", {}) or {} + + if natural_response: + print(f"VLM: {natural_response}") + + bbox = bbox_override if bbox_override is not None else detection_info.get("bbox") + label = label_override or _extract_segmentation_label(command_text, detection_info) + print(f"[sam] target_label={label}") + if bbox_override is not None: + print(f"[sam] using scene bbox override: {bbox}") + mask, backend = _segment_with_fallback(image_input, bbox, label) + print(f"[sam] backend={backend}") + if mask is None: + print("[sam] all segmentation backends failed, using full-image fallback mask.") + mask = _full_image_mask(image_input.shape[:2]) + backend = "full_image_fallback" + + if mask is not None: + if bbox: + print(f"Using bbox from VLM: {bbox}") + cv2.imwrite(output_mask, mask, [cv2.IMWRITE_PNG_BILEVEL, 1]) + print(f"Saved segmentation mask: {output_mask}") + if os.getenv("OPENCLAW_SEGMENT_DEBUG", "1").strip().lower() not in { + "0", + "false", + "no", + }: + _save_segmentation_debug( + image_input, + mask, + bbox, + output_mask, + label, + backend, + ) + else: + print("Segmentation failed.") + + return mask + + +if __name__ == "__main__": + print("This module is designed to be imported by main_vlm.py.") diff --git a/third_party/tuntunclaw/workflow_hooks.py b/third_party/tuntunclaw/workflow_hooks.py new file mode 100644 index 0000000000000000000000000000000000000000..bdcd6e02dfe79aa32f9cb4f10f2ed1f5f9db2ebe --- /dev/null +++ b/third_party/tuntunclaw/workflow_hooks.py @@ -0,0 +1,45 @@ +"""Shared workflow side-effects for successful robot actions.""" + +from __future__ import annotations + +from functools import lru_cache +from typing import Any + +from integrations import get_feishu_notifier, notify_robot_backend +from inventory import InventoryStore + + +@lru_cache(maxsize=1) +def get_inventory_store() -> InventoryStore: + return InventoryStore() + + +def record_task_success_effects( + *, + task: dict[str, Any], + command: str | None = None, + session_id: str | None = None, +) -> dict[str, Any] | None: + """Record inventory consumption and fan out notifications.""" + + store = get_inventory_store() + event = store.record_task_success(task=task, command=command, session_id=session_id) + + webhook_payload = { + "kind": "task_success", + "task": task, + "command": command, + "session_id": session_id, + "inventory_event": event, + "timestamp": event.get("timestamp") if event else None, + } + notify_robot_backend(webhook_payload) + + if event and event.get("alert_sent"): + try: + get_feishu_notifier().send_low_stock_alert(event) + except Exception: + # Notifications should never block the robot workflow. + pass + + return event diff --git "a/third_party/tuntunclaw/\351\241\271\347\233\256\345\274\200\345\217\221\346\265\201\347\250\213\344\270\216\347\263\273\347\273\237\346\236\266\346\236\204\350\257\264\346\230\216.md" "b/third_party/tuntunclaw/\351\241\271\347\233\256\345\274\200\345\217\221\346\265\201\347\250\213\344\270\216\347\263\273\347\273\237\346\236\266\346\236\204\350\257\264\346\230\216.md" new file mode 100644 index 0000000000000000000000000000000000000000..88b1f0c6a46ead3711b5f3933a3fefd2b4e5cfc8 --- /dev/null +++ "b/third_party/tuntunclaw/\351\241\271\347\233\256\345\274\200\345\217\221\346\265\201\347\250\213\344\270\216\347\263\273\347\273\237\346\236\266\346\236\204\350\257\264\346\230\216.md" @@ -0,0 +1,576 @@ +# 项目开发流程与系统架构说明 + +本文面向项目维护者与二次开发者，系统说明当前 `VLM_Grasp_Interactive` 的整体架构、前后端调用链、MuJoCo 仿真执行流程、连续任务机制，以及当前工程中各个关键文件的职责分工。 + +阅读完成后，读者应当能够： + +- 理解本项目从“网页输入自然语言”到“MuJoCo 中完成抓取与放置”的完整链路。 +- 明确前端、FastAPI、VLM/SAM 分割、GraspNet、运动执行和库存通知之间的关系。 +- 理解为什么本项目支持“连续任务”而不是每条命令都重置环境。 +- 在不破坏已有抓取任务的前提下，继续扩展新的对象、新的放置逻辑和新的业务接口。 + +## 1. 项目目标 + +本项目的目标不是单纯做一个机器人控制界面，而是构建一个“可视化、可交互、可连续执行”的仿真演示系统。系统接收自然语言任务，通过网页端展示执行过程，在后端调用视觉分割、抓取候选推理和 MuJoCo 仿真执行模块，最终完成抓取、放置、抛掷等动作。 + +当前工程已经重点完成了以下能力： + +- 中文自然语言指令输入与快捷预设。 +- Web 前端与 FastAPI 后端打通。 +- MuJoCo 仿真实时画面在网页端展示。 +- VLM + SAM 的目标定位与分割。 +- GraspNet 抓取候选推理。 +- 目标物体的专用逻辑适配，例如巧克力、苹果、海绵、盘子、果篮等。 +- 连续任务执行，即第二条命令在第一条命令执行后的场景状态上继续进行。 + +## 2. 启动方式与运行入口 + +当前统一使用 `vlm_grasp311` 环境。 + +### 2.1 Web 前端与后端一体入口 + +```powershell +micromamba run -n vlm_grasp311 python main.py +``` + +执行后会启动 FastAPI 服务，并自动打开浏览器。默认地址为： + +```text +http://127.0.0.1:8000/ +``` + +### 2.2 其他历史入口 + +- [main_openclaw.py](./main_openclaw.py)：早期主程序入口。 +- [main_vlm.py](./main_vlm.py)：偏实验性质的 VLM 调用入口。 + +当前实际演示链路以 [main.py](./main.py) 为准。 + +## 3. 总体架构 + +系统可以分成五层： + +1. 前端交互层 +2. Web 服务与会话管理层 +3. 感知与任务理解层 +4. 抓取推理与运动执行层 +5. 扩展业务层 + +下面给出当前项目的主调用关系。 + +```mermaid +flowchart TD + A["前端页面
    frontend/index.html + frontend/app.js"] --> B["FastAPI 入口
    main.py"] + B --> C["会话与状态管理
    SessionRecord + SSE"] + C --> D["MuJoCo 执行调度
    MuJoCoCommandRunner"] + D --> E["环境与渲染
    UR5GraspEnv"] + D --> F["分割模块
    vlm_process.py"] + D --> G["抓取与放置推理
    grasp_process.py"] + G --> H["GraspNet / 点云 / IK / 执行动作"] + C --> I["库存与通知
    workflow_hooks.py + inventory.py + integrations.py"] +``` + +## 4. 核心目录说明 + +### 4.1 Web 层 + +- [frontend/index.html](./frontend/index.html) + 页面结构、静态按钮、兜底事件脚本、预设按钮模板。 + +- [frontend/app.js](./frontend/app.js) + 前端状态机、会话提交、SSE 订阅、预览更新、快捷预设写入文本框、调试信息展示。 + +- [frontend/styles.css](./frontend/styles.css) + 页面样式、面板悬停发光效果、预览区布局与整体视觉主题。 + +### 4.2 Web 后端与主控制层 + +- [main.py](./main.py) + 当前系统主入口。负责： + - 启动 FastAPI。 + - 挂载前端静态文件。 + - 接收 `/api/command` 指令。 + - 创建与维护会话。 + - 将任务交给 MuJoCo 执行器。 + - 通过 `/api/session/{id}` 与 `/api/session/{id}/events` 向前端推送状态。 + - 通过 `/api/session/{id}/frame` 向前端输出实时预览帧。 + +### 4.3 感知与执行层 + +- [vlm_process.py](./vlm_process.py) + VLM 与图像分割模块。负责： + - 调用多模态模型理解用户命令和图像。 + - 输出目标自然语言描述与图像框。 + - 调用本地或远端 SAM 分割。 + - 生成 `mask_source`、`mask_destination` 以及调试叠层图。 + +- [grasp_process.py](./grasp_process.py) + 抓取与放置推理核心模块。负责： + - 根据深度图和 mask 构建点云。 + - 调用 GraspNet 生成抓取候选。 + - 根据目标物体几何信息估算抓取点、放置点。 + - 求解 IK。 + - 控制机械臂在 MuJoCo 中完成抓取、抬升、移动、放置、回位。 + - 提供对象级专用逻辑，例如巧克力、苹果、海绵架、苹果果篮的特殊映射。 + +- [manipulator_grasp/env/ur5_grasp_env.py](./manipulator_grasp/env/ur5_grasp_env.py) + MuJoCo 环境封装。负责： + - 加载 XML 场景。 + - 初始化机械臂与夹爪。 + - 管理离屏渲染和被动 viewer。 + - 统一网页端与仿真端的视角。 + - 在渲染异常时只重建渲染后端，不重置世界状态。 + +### 4.4 场景与视角配置 + +- [scene_robocasa_layout51_style34.xml](./manipulator_grasp/assets/scenes/scene_robocasa_layout51_style34.xml) + 当前实际使用的主场景文件。 + +- `scene_robocasa_layout51_style34.view.json` + 当前主场景的默认视角配置文件。网页端和 MuJoCo viewer 统一读取这份视角。该文件可由本地调试流程生成，不属于公开教程必须提交的源码。 + +### 4.5 业务扩展层 + +- [workflow_hooks.py](./workflow_hooks.py) + 成功任务后的副作用处理，例如库存变更、低库存通知、向外部系统同步。 + +- [inventory.py](./inventory.py) + 文件持久化的库存系统，记录某些任务完成后物资数量变化。 + +- [integrations.py](./integrations.py) + 外部 webhook 与飞书通知接口。 + +## 5. 前端工作流程 + +前端的核心职责不是执行机器人动作，而是把用户命令、后端会话状态和仿真画面组织成一个可演示、可调试的交互界面。 + +### 5.1 页面组成 + +网页端主要由三个面板组成： + +- 左侧：指令输入区 +- 中间：场景预览区 +- 右侧：执行时间线与调试输出区 + +左侧用于输入自然语言命令，并通过快捷预设按钮快速写入文本框。中间区域显示当前 MuJoCo 实时画面或占位图。右侧显示当前会话的状态推进，例如语言解析、目标分割、抓取推理、IK 求解、动作执行和最终结果。 + +### 5.2 指令提交 + +当前前端支持两种提交方式： + +- 点击“执行指令”按钮 +- 在输入框中按 `Enter` + +对应逻辑位于 [frontend/app.js](./frontend/app.js)。前端会将命令发送到： + +```text +POST /api/command +``` + +提交后，前端进入“running”状态，并开始订阅该会话的 SSE 流。 + +### 5.3 会话状态更新 + +前端通过以下接口获得任务执行进度： + +- `GET /api/session/{session_id}` +- `GET /api/session/{session_id}/events` +- `GET /api/session/{session_id}/frame` + +其中： + +- `events` 负责推送 trace、日志、阶段名、结果等结构化状态。 +- `frame` 负责提供当前最新的 PNG 预览帧。 + +这意味着前端并不直接访问 MuJoCo，也不参与执行规划，而是完全通过 FastAPI 会话状态进行驱动。 + +## 6. 后端会话与调度流程 + +### 6.1 会话对象 + +在 [main.py](./main.py) 中，每条命令对应一个 `SessionRecord`。它保存以下核心信息： + +- `session_id` +- 当前命令字符串 +- 解析后的任务结构 +- 当前 trace 列表 +- 当前状态，例如 `running`、`success`、`failure` +- 当前结果文案 +- 预览图 URL +- 调试日志 +- 库存快照 + +前端每次提交命令后，后端会生成新会话或继续使用指定会话，然后启动后台线程执行真正的 MuJoCo 任务。 + +### 6.2 命令解析 + +命令解析在 [main.py](./main.py) 内完成，主要由以下函数负责： + +- `_normalize_text` +- `_extract_objects` +- `_infer_relation` +- `_parse_task` + +解析结果会统一规约成结构化任务： + +```python +{ + "type": "pick_place", + "source": "apple", + "destination": "apple_rack", + "relation": "in", + "all_items": False, +} +``` + +这一步是整个系统的任务入口，也是后续专用逻辑分流的基础。 + +### 6.3 通用任务与专用任务 + +当前后端不是完全依赖统一泛化逻辑，而是采用“通用框架 + 专用对象适配”的方式。 + +例如： + +- 巧克力任务会优先锁定 `SNICKERS` 对应的场景实体。 +- 苹果任务会区分菜板上的苹果和果篮中的苹果。 +- 海绵任务会区分桌上的海绵与海绵架中的海绵。 +- 果篮和海绵架的放置位置不是简单的“架子中心”，而是专门计算的有效槽位。 + +这样做的原因很直接：纯依赖泛化文本理解和纯分割在复杂场景里不够稳定，容易出现识别到错误同类物体或放置到不合理位置的情况。当前工程用对象级规则把这些高频失败点收敛掉。 + +## 7. MuJoCo 执行主链路 + +真实执行的主体位于 `MuJoCoCommandRunner` 中。 + +其单次抓取放置主流程可以概括为： + +1. 保证环境已初始化 +2. 采集 RGB 与深度 +3. 对源物体执行分割 +4. 估算抓取目标世界坐标 +5. 对目标放置区域执行分割或直接使用专用放置槽位 +6. 构建点云并运行 GraspNet +7. 求解抓取、抬升、移动、放置、回位的 IK +8. 在 MuJoCo 中逐段执行动作 +9. 将实时帧和阶段状态持续推送给前端 + +### 7.1 RGB-D 采集 + +采集逻辑位于： + +- [main.py](./main.py) 中的 `_capture_rgbd` +- [ur5_grasp_env.py](./manipulator_grasp/env/ur5_grasp_env.py) 中的 `render` + +这里后端拿到的是： + +- `img`：当前相机 RGB 图像 +- `depth`：同一视角下的深度图 + +后续所有分割、点云和抓取推理都建立在这对同步的 RGB-D 数据上。 + +### 7.2 源目标分割 + +源目标分割使用 [vlm_process.py](./vlm_process.py) 中的 `segment_image` 及其相关逻辑完成。 + +这一步支持三种输入方式： + +- 纯命令文本 +- 文本 + 场景 bbox 提示 +- 文本 + 显式标签覆盖 + +在当前项目中，很多稳定性修复都依赖这一层。例如： + +- 巧克力会附加“包装上写着 SNICKERS”的提示。 +- 海绵会附加“优先选择红圈标出的海绵”的提示。 +- 苹果架会走专用目标，不再仅仅依赖“架子”这个泛化词。 + +### 7.3 点云与 GraspNet + +抓取候选推理位于 [grasp_process.py](./grasp_process.py)。 + +核心处理链路如下： + +1. 根据 RGB、深度、mask 构建有组织点云。 +2. 根据深度阈值过滤无效点。 +3. 调用 GraspNet 生成抓取候选。 +4. 进行碰撞过滤。 +5. 结合目标中心、抓取方向和距离进行排序。 +6. 选出最终抓取姿态。 + +如果这里报错： + +```text +No valid masked point cloud points after depth filtering +``` + +一般不是 IK 问题，而是更前面的输入出了问题，常见原因包括： + +- mask 落到了错误物体上 +- 深度图失效 +- 离屏渲染出现异常 + +### 7.4 IK 与动作执行 + +动作执行同样位于 [grasp_process.py](./grasp_process.py)。 + +当前执行顺序为： + +- `home` +- `hub` +- `hover_pick` +- `pregrasp` +- `grasp` +- `grasp_close` +- `lift` +- `hover_place` +- `preplace` +- `place` +- `release` +- `retreat` +- `hub_return` +- `reset` + +每个阶段都会通过回调写回前端，前端据此显示当前阶段名和最新画面。 + +## 8. 连续任务机制 + +这是本项目当前最关键的工程设计之一。 + +### 8.1 设计目标 + +本项目要求第二条任务在第一条任务执行完成后的世界状态上继续运行，而不是每次都把 MuJoCo 场景恢复到初始状态。 + +例如： + +1. 先执行“请把巧克力放到盘里” +2. 巧克力放到盘中 +3. 再执行“将菜板上的苹果放置有苹果的架子上保存” +4. 这时仿真中巧克力仍应保留在盘里 + +### 8.2 当前实现 + +环境管理位于 [main.py](./main.py) 的 `MuJoCoCommandRunner` 中。 + +其原则是： + +- `UR5GraspEnv` 只在首次使用时 `reset()` +- 后续任务复用同一个 `self._env` +- 因此 `mj_model` 和 `mj_data` 会保留上一个任务执行后的状态 + +### 8.3 渲染异常的修复策略 + +在连续任务过程中，曾经出现过离屏渲染后端损坏，导致网页端出现： + +- 预览黑屏 +- 深度图恒定为一个大常数 +- 后续点云构建失败 + +为解决这个问题，当前在 [ur5_grasp_env.py](./manipulator_grasp/env/ur5_grasp_env.py) 中加入了以下机制： + +- 当检测到渲染输出无效时，不重置整个 MuJoCo 场景 +- 只重建离屏渲染资源，例如 renderer、GLFW window、offscreen context +- 保留 `mj_model` 与 `mj_data` + +因此，当前系统同时满足两点： + +- 世界状态连续 +- 渲染异常可恢复 + +## 9. 相机视角与场景编辑器 + +### 9.1 统一视角来源 + +网页端和 MuJoCo viewer 的默认视角统一来源于场景视角文件： + +```text +scene_robocasa_layout51_style34.view.json +``` + +读取逻辑位于： + +- [ur5_grasp_env.py](./manipulator_grasp/env/ur5_grasp_env.py) + +### 9.2 视角配置如何生效 + +当 `scene_robocasa_layout51_style34.view.json` 存在时，仿真端会读取这套相机视角配置。之后： + +- 仿真器 viewer 会使用这套视角 +- 网页端离屏渲染也会使用这套视角 + +这保证了“前端看到的相机”和“本地 MuJoCo 调试器看到的相机”保持一致。公开仓库保留的是运行所需的场景与读取逻辑，不包含本地场景编辑工具。 + +## 10. 调试产物与中间文件 + +当前项目会将大量中间结果写入 `temp/`，便于问题定位。 + +### 10.1 图像与分割结果 + +常见输出目录： + +```text +temp/images/ +``` + +其中包括： + +- `*_mask_source.png` +- `*_mask_destination.png` +- `*_mask_source_overlay.png` +- `*_mask_destination_overlay.png` + +这些文件可以直接用来判断： + +- VLM/SAM 是否识别到了正确目标 +- bbox 是否落在正确物体上 +- 叠层与真实图像是否一致 + +### 10.2 库存状态 + +库存状态会持久化在： + +```text +temp/inventory/ +``` + +这是演示业务侧逻辑的基础数据目录。 + +## 11. 业务扩展：库存、下单与飞书通知 + +当前项目除了抓取演示，还接入了一个轻量业务闭环。 + +### 11.1 库存扣减 + +在某些成功任务后，会调用 [workflow_hooks.py](./workflow_hooks.py) 中的： + +```python +record_task_success_effects(...) +``` + +该函数会： + +- 更新本地库存 +- 判断是否低库存 +- 向外部 webhook 通知 +- 必要时向飞书发送提醒 + +### 11.2 对外集成 + +[integrations.py](./integrations.py) 负责： + +- 机器人外部 webhook +- 飞书通知 +- 读取本地配置文件 + +这一层不参与抓取控制，只负责将仿真成功事件同步到其他系统。 + +## 12. 当前对象级专用逻辑 + +目前工程中已经为若干对象做了专用适配，这一点是系统稳定运行的重要原因。 + +### 12.1 巧克力 + +- 使用 `SNICKERS` 语义提示锁定正确巧克力。 +- 避免将巧克力误识别到同场景的其他小物体。 + +### 12.2 苹果 + +- `apple` 默认映射到菜板上的苹果。 +- `apple_rack` 映射到果篮。 +- 苹果的放置点不是整个架子中心，而是果篮内的专用位置。 + +### 12.3 海绵 + +- 支持海绵与海绵架分离建模。 +- 支持批量整理逻辑。 +- 放置点使用海绵架内的专用槽位，而不是泛化的“架子中心”。 + +## 13. 当前开发流程建议 + +如果后续继续开发，建议遵循下面的顺序。 + +### 13.1 新对象接入流程 + +1. 在场景 XML 中确认目标 body 名称。 +2. 在 [main.py](./main.py) 中补充中文命令别名。 +3. 在 [grasp_process.py](./grasp_process.py) 中补充 `SCENE_BODY_NAMES` 映射。 +4. 如有必要，为放置区编写专用世界坐标函数。 +5. 用网页端连续执行两条任务，检查状态是否能正确保留。 + +### 13.2 调试顺序 + +遇到问题时，建议按以下顺序排查： + +1. 网页端日志是否显示进入真实 MuJoCo 执行 +2. `temp/images` 中的源 mask 和目标 mask 是否正确 +3. 网页端预览是否黑屏或偏色 +4. 深度图是否异常 +5. `grasp_process.py` 的源物体和目标物体映射是否正确 +6. 放置点是否用了泛化逻辑而不是专用逻辑 + +## 14. 常见故障与恢复方法 + +### 14.1 网页端黑屏 + +优先怀疑离屏渲染后端失效，而不是前端代码本身。当前系统已支持自动重建渲染资源，但如果旧进程已经异常，最直接的恢复方法仍然是重启 [main.py](./main.py)。 + +### 14.2 深度过滤后没有点云 + +错误形式通常为： + +```text +No valid masked point cloud points after depth filtering +``` + +优先检查： + +- 分割目标是否正确 +- 深度是否正常 +- 当前视角下目标是否在相机可视范围内 + +### 14.3 物体抓错或放错 + +优先检查： + +- 该对象是否已有专用映射 +- 是否仍在走 `shelf` 这类泛化目标 +- 目标放置点是不是整个大容器中心，而不是容器内部有效落点 + +## 15. 建议的后续维护方向 + +从当前代码状态出发，后续建议优先做以下三类工作： + +### 15.1 稳定性 + +- 将更多高频对象接入专用映射。 +- 为更多容器类目标建立“容器内部有效槽位”逻辑。 +- 将渲染异常检测继续标准化。 + +### 15.2 可维护性 + +- 将对象别名、场景实体名、放置策略统一整理成配置文件。 +- 将当前散落在 `main.py` 与 `grasp_process.py` 中的对象规则抽离成单独模块。 + +### 15.3 演示能力 + +- 扩展更多连续任务脚本。 +- 增加环境重置按钮，让“连续执行”和“手动回到初始状态”两种模式共存。 +- 在前端展示更多中间状态，例如分割叠层、抓取候选数量、当前目标实体名。 + +## 16. 本文关联的关键文件 + +- [main.py](./main.py) +- [grasp_process.py](./grasp_process.py) +- [vlm_process.py](./vlm_process.py) +- [manipulator_grasp/env/ur5_grasp_env.py](./manipulator_grasp/env/ur5_grasp_env.py) +- [workflow_hooks.py](./workflow_hooks.py) +- [inventory.py](./inventory.py) +- [integrations.py](./integrations.py) +- [frontend/index.html](./frontend/index.html) +- [frontend/app.js](./frontend/app.js) +- [frontend/styles.css](./frontend/styles.css) + +按使用场景看，这份说明可以对应三类阅读路径： + +- 面向演示使用者的运行手册 +- 面向开发者的系统架构说明 +- 面向调试者的故障排查手册