Hi @yzqin,
I had a couple of questions I was hoping to get some insight on.

1. Upon inspecting load_ycb_object() in dexpoint-release/dexpoint/utils/ycb_object_utils, I see that one needs the following files for loading an object:

• textured_simple.obj
• collision.obj
  However, in order to load a new object (like a spoon for example) in the codebase, I am unable to find the corresponding collision.obj on the YCB dataset website. Where may I obtain these assets?

2. I was trying to replicate the training of the policy in the codebase but encountered an error in doing so.

Here's a replication of my error:
After cloning the modified codebase here.
Run the command: python training_ppo.py
I get the following error:

It would be great if you could kindly give some insight to resolve these issues.

Thanking you in anticipation!

Thank you for your contribution.
I noticed that the data file in the readme are different from the scenarios presented in this article. Could you kindly provide the scenario files or methods for creating them?
I would appreciate your help. Thank you.

Hi yz:
I am currently following your dex-series work, nice job!
However, I follow the instrument to copy the dexpoint env under dexart training root. The main training code are organized like this, some env setting code are omitted and the policy is trained by ycb dataset instead of shapenet:
`

def get_3d_policy_kwargs(extractor_name):
    feature_extractor_class = PointNetImaginationExtractorGP
    feature_extractor_kwargs = {"pc_key": "relocate-point_cloud",
                                # "pc_key": "instance_1-point_cloud",
                                # "gt_key": "instance_1-seg_gt",
                                "extractor_name": extractor_name,
                                "imagination_keys": [f'imagination_{key}' for key in IMG_CONFIG['relocate_goal_robot'].keys()],
                                "state_key": "state"
    }
    policy_kwargs = {
        "features_extractor_class": feature_extractor_class,
        "features_extractor_kwargs": feature_extractor_kwargs,
        # "net_arch": [dict(pi=[64, 64], vf=[64, 64])],
        "activation_fn": nn.ReLU,
    }
    return policy_kwargs
def training():
        env_params = dict(object_name=object_name, rotation_reward_weight=rotation_reward_weight,
                          randomness_scale=1, use_visual_obs=use_visual_obs, use_gui=False,
                          # no_rgb=True
                          )
        if "CUDA_VISIBLE_DEVICES" in os.environ:
            env_params["device"] = "cuda"
        environment = AllegroRelocateRLEnv(**env_params)
        model = PPO("PointCloudPolicy", env, verbose=1,
                    n_epochs=args.ep,
                    n_steps=(args.n // args.workers) * horizon,
                    learning_rate=args.lr,
                    batch_size=args.bs,
                    seed=seed,
                    policy_kwargs=get_3d_policy_kwargs(extractor_name=extractor_name),
                    min_lr=args.lr,
                    max_lr=args.lr,
                    adaptive_kl=0.02,
                    target_kl=0.2,
                    )
        obs=env.reset()
        if pretrain_path is not None:
            state_dict: OrderedDict = torch.load(pretrain_path)
            model.policy.features_extractor.extractor.load_state_dict(state_dict, strict=False)
            print("load pretrained model: ", pretrain_path)
        rollout = int(model.num_timesteps / (horizon * args.n))
        if args.freeze:
            model.policy.features_extractor.extractor.eval()
            for param in model.policy.features_extractor.extractor.parameters():
                param.requires_grad = False
            print("freeze model!")
        model.learn(
            total_timesteps=int(env_iter),
            reset_num_timesteps=False,
            iter_start=rollout,
            callback=None
    )

`
And the experiment result just like this:

Is the training code organized well? Or can you give some advice to reproduce the experiment result?

Hi！
I find that when set use_obs to True, the environment will return a dict of observation after invoking get-observation function.
However, the dict is not supported when invoking the feature_extractor of stable baseline3.
So, in order to employ dexpoint env based on dexart, should the get_observation fn in env be modified to return array instead of dict？

Specific: modify the get_observation fn in:
dexpoint-release-main/dexpoint/env/rl_env/base.py

Hi! Great work of yours.

I'm trying to reproduce the training stage of dexpoint(mostly copied from dex-art), and I noticed that you give a code to train in an issue , but when I ran it, it has this error, do you have any idea about what might be missing here?

Thanks for your wonderful work.
During the execution of the Dexpoint example, I observed a collision issue between the hand and the object during grasping, leading to unrealistic behavior as shown in the figure.

The collision settings between the hands and objects are defined in the source program. Could you assist me in resolving this error?
Thank you for any help！

Hi, @yzqin @dexpc-rl

Thanks for the wonderful work.
How to draw the visual point cloud simulation like in Project?

Thanks for any help:)

Hi, @yzqin
Thanks for your great work!

Can you provide the code to get point clouds by D435 in the real world?

Thanks for any help:)
Best,
Charlie