wangyueft / prnet Goto Github PK

Hi, @WangYueFt Thanks for sharing your code! In your paper, you claim the method to handle partial-to-partial point set registration. But under your setting, especially I checked your dataloader, it seems you only sample one point, and get the nearest 768 points for both the source and target shape. In my opinion, this will generate two point sets with large overlap, especially you pick the point from a very large distance from the shape (random_p1 = np.random.random(size=(1, 3)) + np.array([[500, 500, 500]]) * np.random.choice([1, -1, 1, -1])). I visualized some pairs and found the source point sets and target points have a large part of overlaps.

When I generate source and target point sets with two different samplings, i.e., random_p2 is picked instead of 'random_p2 = random_p1', I got the following performance, which falls a lot behind the one you report in the paper.

exp1: identical sampling for source and target:
A->B:: Stage: best_test, Epoch: 58, Loss: 0.018334, Feature_alignment_loss: 0.001463, Cycle_consistency_loss: 0.002618, Scale_consensus_loss: 0.000000, Rot_MSE: 9.122054, Rot_RMSE: 3.020274, Rot_MAE: 1.405421, Rot_R2: 0.945782, Trans_MSE: 0.000274, Trans_RMSE: 0.016538, Trans_MAE: 0.010954, Trans_R2: 0.996694

exp2: independent point sampling for each shape
A->B:: Stage: best_test, Epoch: 94, Loss: 0.036311, Feature_alignment_loss: 0.003807, Cycle_consistency_loss: 0.002531, Scale_consensus_loss: 0.000000, Rot_MSE: 32.466419, Rot_RMSE: 5.697931, Rot_MAE: 3.089283, Rot_R2: 0.807019, Trans_MSE: 0.001563, Trans_RMSE: 0.039535, Trans_MAE: 0.026601, Trans_R2: 0.981015

This is not a problem with the repo it self, but rather the underlying packages. I thought I could add it here if anyone else was experiencing the same issues.

When I run it, I get the error CUDNN_STATUS_NOT_SUPPORTED. I managed to work around this by adding the following to main.py: torch.backends.cudnn.enabled = False. Essentially disabling cuDNN.

Traceback (most recent call last):
  File "main.py", line 177, in <module>
    main()
  File "main.py", line 171, in main
    train(args, net, train_loader, test_loader)
  File "main.py", line 49, in train
    info_train = net._train_one_epoch(epoch=epoch, train_loader=train_loader, opt=opt)
  File "/home/grans/Documents/prnet/model.py", line 704, in _train_one_epoch
    opt)
  File "/home/grans/Documents/prnet/model.py", line 643, in _train_one_batch
    total_loss.backward()
  File "/home/grans/.local/lib/python3.6/site-packages/torch/tensor.py", line 195, in backward
    torch.autograd.backward(self, gradient, retain_graph, create_graph)
  File "/home/grans/.local/lib/python3.6/site-packages/torch/autograd/__init__.py", line 99, in backward
    allow_unreachable=True)  # allow_unreachable flag
RuntimeError: cuDNN error: CUDNN_STATUS_NOT_SUPPORTED. This error may appear if you passed in a non-contiguous input.

Hi, thanks for your paper and code!

However, after reading your paper, I'm confusing about the key point matching step:
How can you guarantee that the K key points appeared in both point clouds are the same points? What if they are not coincident? Matching those points may produce large error.
In my opinion, the current algorithm dose not apply to point clouds with smaller overlaps, as mentioned in #3 and #4 . As previous methods, finding the correct matching is always a bottleneck.

Thank you for your project，I meet the error, How do you solve it ？

Hello, I have read your PR-Net recently, which is really impressive and innovative. I am currently learning 3D point cloud registration and I think PR-Net is quite outstanding. I want to do some experiments, so could you share a pre-trained model with me through github? Thank you very much. I am looking forward to your reply!

There was an error called "index out of bounds" when I ran the code.

Hi @WangYueFt Thanks for your sharing! In the paper, you claimed PRNET is able to handle partial-to-partial registration, but I think in the experiment, you use the rotation sample from [0, 45] and translation in [-0.5, 0.5], which might still result in two point clouds with a quite large overlap. So I wonder have you ever test the model on real world dataset like 3DMatch where the overlap between two point clouds are small?

random_p1 = np.random.random(size=(1, 3)) + np.array([[500, 500, 500]]) * np.random.choice([1, -1, 1, -1]) idx1 = nbrs1.kneighbors(random_p1, return_distance=False).reshape((num_subsampled_points,))

In this part, could you explain what this part does? Why is it 500 multiplied by 1 or -1?
Is it a random "big" number to create a 3D point that acts as a "pivot" point from which distances to all the points are calculated and then select the top 784 closest points?

Hi,

I would like to try your network, but the readme doesn't explain how to run it, but just how to train it.
Could you please provide a brief explanation on how to use it?

Regards

Dear authors,

thank you for making the code public. I have tried to run your method on our own data (partial point clouds of the ShapeNet cars) and have stumbled on a CUDA error as already mentioned in a previous issue.

We have tried following things to mitigate the error:

1. As mentioned in one of the issues we have tried replacing top-k with sort().
2. We have tried to improve the conditioning of the ill-contioned covariance-matrices by adding small constant values to the diagonal.
3. Running the SVD on the GPU instead of the CPU.
4. Using a newer version of pytorch (1.5). In this case there was no CUDA error did not occur but the SVD did not converge "SBDSC did not converged error"

We are wondering if you maybe have some other suggestions or know what could be done to alleviate this problem. Do you know hot other people managed to solve this issues?

Thanks for your help

Zan

Thank you for realizing the code.
Will you provide any pretrained models?

Do you have a trained checkpoint file available somewhere online that you can share, if possible?
Thanks in advance.

I use 'conda env create -f environment.yml --name a_prnet' and get an error :
ResolvePackageNotFound:

• autowrap==0.18.1=py36h14c3975_1000
• jpeg==9b=h024ee3a_2
• libxml2==2.9.9=he19cac6_0
• matplotlib==3.0.3=py36h5429711_0
• readline==7.0=h7b6447c_5
• libgcc-ng==8.2.0=hdf63c60_1
• scikit-learn==0.20.3=py36hd81dba3_0
• ············································································

What is the reason that dgcnn does not use Dynamic graph update in this paper?