OcCo: Unsupervised Point Cloud Pre-training via Occlusion Completion
This repository is the official implementation of paper: "Unsupervised Point Cloud Pre-training via Occlusion Completion"
[Paper] [Project Page]
Intro
In this work, we train a completion model that learns how to reconstruct the occluded points, given the partial observations. In this way, our method learns a pre-trained encoder that can identify the visual constraints inherently embedded in real-world point clouds.
We call our method Occlusion Completion (OcCo). We demonstrate that OcCo learns representations that: improve generalization on downstream tasks over prior pre-training methods, transfer to different datasets, reduce training time, and improve labeled sample efficiency.
Citation
Our paper is preprinted on arxiv:
@inproceedings{OcCo,
title = {Unsupervised Point Cloud Pre-Training via Occlusion Completion},
author = {Hanchen Wang and Qi Liu and Xiangyu Yue and Joan Lasenby and Matthew J. Kusner},
year = 2021,
booktitle = {International Conference on Computer Vision, ICCV}
}
Usage
We provide codes in both PyTorch (1.3): OcCo_Torch and TensorFlow (1.13-1.15): OcCo_TF. We also provide with docker configuration docker. Our recommended development environment PyTorch + docker, the following descriptions are based on OcCo_Torch, we refer the readme in the OcCo_TF for the details of TensorFlow implementation.
1) Prerequisite
Docker
In the docker folder, we provide the build, configuration and launch scripts:
docker
| - Dockerfile_Torch # configuration
| - build_docker_torch.sh # scripts for building up from the docker images
| - launch_docker_torch.sh # launch from the built image
| - .dockerignore # ignore the log and data folder while building up
which can be automatically set up as following:
# build up from docker images
cd OcCo_Torch/docker
sh build_docker_torch.sh
# launch the docker image, conduct completion/classification/segmentation experiments
cd OcCo_Torch/docker
sh launch_docker_torch.sh
Non-Docker Setup
Just go with pip install -r Requirements_Torch.txt with the PyTorch 1.3.0, CUDA 10.1, CUDNN 7 (otherwise you may encounter errors while building the C++ extension chamfer_distance for calculating the Chamfer Distance), my development environment besides docker is Ubuntu 16.04.6 LTS, gcc/g++ 5.4.0, cuda10.1, CUDNN 7.
2) Pre-Training via Occlusion Completion (OcCo)
Data Usage:
For the details in the data setup, please see data/readme.md.
Training Scripts:
We unify the training of all three models (PointNet, PCN and DGCNN) in train_completion.py as well as the bash templates, see bash_template/train_completion_template.sh for details:
#!/usr/bin/env bash
cd ../
# train pointnet-occo model on ModelNet, from scratch
python train_completion.py \
--gpu 0,1 \
--dataset modelnet \
--model pointnet_occo \
--log_dir modelnet_pointnet_vanilla ;
# train dgcnn-occo model on ShapeNet, from scratch
python train_completion.py \
--gpu 0,1 \
--batch_size 16 \
--dataset shapenet \
--model dgcnn_occo \
--log_dir shapenet_dgcnn_vanilla ;
Pre-Trained Weights
We will provide the OcCo pre-trained models for all the three models here, you can use them for visualization of completing self-occluded point cloud, fine tuning on classification, scene semantic and object part segmentation tasks.
3) Sanity Check on Pre-Training
We use single channel values as well as the t-SNE for dimensionality reduction to visualize the learned object embeddings on objects from the ShapeNet10, while the encoders are pre-trained on the ModelNet40 dataset, see utils/TSNE_Visu.py for details.
We also train a Support Vector Machine (SVM) based on the learned embeddings object recognition. It is in train_svm.py. We also provide the bash template for this, see bash_template/train_svm_template.sh for details:
#!/usr/bin/env bash
cd ../
# fit a simple linear SVM on ModelNet40 with OcCo PCN
python train_svm.py \
--gpu 0 \
--model pcn_util \
--dataset modelnet40 \
--restore_path log/completion/modelnet_pcn_vanilla/checkpoints/best_model.pth ;
# grid search the best svm parameters with rbf kernel on ScanObjectNN(OBJ_BG) with OcCo DGCNN
python train_svm.py \
--gpu 0 \
--grid_search \
--batch_size 8 \
--model dgcnn_util \
--dataset scanobjectnn \
--bn \
--restore_path log/completion/modelnet_dgcnn_vanilla/checkpoints/best_model.pth ;
4) Fine Tuning Task - Classification
Data Usage:
For the details in the data setup, please see data/readme.md.
Training/Testing Scripts:
We unify the training and testing of all three models (PointNet, PCN and DGCNN) in train_cls.py. We also provide the bash template for training each models from scratch, JigSaw/OcCo pre-trained checkpoints, see bash_template/train_cls_template.sh for details:
#!/usr/bin/env bash
cd ../
# training pointnet on ModelNet40, from scratch
python train_cls.py \
--gpu 0 \
--model pointnet_cls \
--dataset modelnet40 \
--log_dir modelnet40_pointnet_scratch ;
# fine tuning pcn on ScanNet10, using jigsaw pre-trained checkpoints
python train_cls.py \
--gpu 0 \
--model pcn_cls \
--dataset scannet10 \
--log_dir scannet10_pcn_jigsaw \
--restore \
--restore_path log/completion/modelnet_pcn_vanilla/checkpoints/best_model.pth ;
# fine tuning dgcnn on ScanObjectNN(OBJ_BG), using jigsaw pre-trained checkpoints
python train_cls.py \
--gpu 0,1 \
--epoch 250 \
--use_sgd \
--scheduler cos \
--model dgcnn_cls \
--dataset scanobjectnn \
--bn \
--log_dir scanobjectnn_dgcnn_occo \
--restore \
--restore_path log/completion/modelnet_dgcnn_vanilla/checkpoints/best_model.pth ;
# test pointnet on ModelNet40 from pre-trained checkpoints
python train_cls.py \
--gpu 1 \
--mode test \
--model pointnet_cls \
--dataset modelnet40 \
--log_dir modelnet40_pointnet_scratch \
--restore \
--restore_path log/cls/modelnet40_pointnet_scratch/checkpoints/best_model.pth ;
5) Fine Tuning Task - Semantic Segmentation
Data Usage:
For the details in the data setup, please see data/readme.md.
Training/Testing Scripts:
We unify the training and testing of all three models (PointNet, PCN and DGCNN) in train_semseg.py. We also provide the bash template for training each models from scratch, JigSaw/OcCo pre-trained checkpoints, see bash_template/train_semseg_template.sh for details:
#!/usr/bin/env bash
cd ../
# train pointnet_semseg on 6-fold cv of S3DIS, from scratch
for area in $(seq 1 1 6)
do
python train_semseg.py \
--gpu 0,1 \
--model pointnet_semseg \
--bn_decay \
--xavier_init \
--test_area ${area} \
--scheduler step \
--log_dir pointnet_area${area}_scratch ;
done
# fine tune pcn_semseg on 6-fold cv of S3DIS, using jigsaw pre-trained weights
for area in $(seq 1 1 6)
do
python train_semseg.py \
--gpu 0,1 \
--model pcn_semseg \
--bn_decay \
--test_area ${area} \
--log_dir pcn_area${area}_jigsaw \
--restore \
--restore_path log/jigsaw/modelnet_pcn_vanilla/checkpoints/best_model.pth ;
done
# fine tune dgcnn_semseg on 6-fold cv of S3DIS, using occo pre-trained weights
for area in $(seq 1 1 6)
do
python train_semseg.py \
--gpu 0,1 \
--test_area ${area} \
--optimizer sgd \
--scheduler cos \
--model dgcnn_semseg \
--log_dir dgcnn_area${area}_occo \
--restore \
--restore_path log/completion/modelnet_dgcnn_vanilla/checkpoints/best_model.pth ;
done
# test pointnet_semseg on 6-fold cv of S3DIS, from saved checkpoints
for area in $(seq 1 1 6)
do
python train_semseg.py \
--gpu 0,1 \
--mode test \
--model pointnet_semseg \
--test_area ${area} \
--scheduler step \
--log_dir pointnet_area${area}_scratch \
--restore \
--restore_path log/semseg/pointnet_area${area}_scratch/checkpoints/best_model.pth ;
done
Visualization:
We recommended using relevant code snippets in RandLA-Net for visualization.
6) Fine Tuning Task - Part Segmentation
Data Usage:
For the details in the data setup, please see data/readme.md.
Training/Testing Scripts:
We unify the training and testing of all three models (PointNet, PCN and DGCNN) in train_partseg.py. We also provide the bash template for training each models from scratch, JigSaw/OcCo pre-trained checkpoints, see bash_template/train_partseg_template.sh for details:
#!/usr/bin/env bash
cd ../
# training pointnet on ShapeNetPart, from scratch
python train_partseg.py \
--gpu 0 \
--normal \
--bn_decay \
--xavier_init \
--model pointnet_partseg \
--log_dir pointnet_scratch ;
# fine tuning pcn on ShapeNetPart, using jigsaw pre-trained checkpoints
python train_partseg.py \
--gpu 0 \
--normal \
--bn_decay \
--xavier_init \
--model pcn_partseg \
--log_dir pcn_jigsaw \
--restore \
--restore_path log/jigsaw/modelnet_pcn_vanilla/checkpoints/best_model.pth ;
# fine tuning dgcnn on ShapeNetPart, using occo pre-trained checkpoints
python train_partseg.py \
--gpu 0,1 \
--normal \
--use_sgd \
--xavier_init \
--scheduler cos \
--model dgcnn_partseg \
--log_dir dgcnn_occo \
--restore \
--restore_path log/completion/modelnet_dgcnn_vanilla/checkpoints/best_model.pth ;
# test fine tuned pointnet on ShapeNetPart, using multiple votes
python train_partseg.py \
--gpu 1 \
--epoch 1 \
--mode test \
--num_votes 3 \
--model pointnet_partseg \
--log_dir pointnet_scratch \
--restore \
--restore_path log/partseg/pointnet_occo/checkpoints/best_model.pth ;
6) OcCo Data Generation (Create Your Own Dataset for OcCo Pre-Training)
For the details in the self-occluded point cloud generation, please see render/readme.md.
7) Just Completion (Complete Your Own Data with Pre-Trained Model)
You can use it for completing your occluded point cloud data with our provided OcCo checkpoints.
8) Jigsaw Puzzle
We also provide our implementation (developed from scratch) on pre-training point cloud models via solving 3d jigsaw puzzles tasks as well as data generation, the method is described in this paper, while the authors did not reprocess to our code request. The details of our implementation is reported in our paper appendix.
For the details of our implementation, please refer to description in the appendix of our paper and relevant code snippets, i.e., train_jigsaw.py, utils/3DPC_Data_Gen.py and train_jigsaw_template.sh.
Results
Generated Dataset:
Completed Occluded Point Cloud:
-- PointNet:
-- PCN:
-- Failure Examples:
Visualization of learned features:
Classification (linear SVM):
Classification:
Sample Efficiency:
Learning Efficiency:
For the description and discussion of the results, please refer to our paper, thanks :)
Contributing
The code of this project is released under the MIT License.
We would like to thank and acknowledge referenced codes from the following repositories:
https://github.com/wentaoyuan/pcn
https://github.com/hansen7/NRS_3D
https://github.com/WangYueFt/dgcnn
https://github.com/charlesq34/pointnet
https://github.com/charlesq34/pointnet2
https://github.com/PointCloudLibrary/pcl
https://github.com/AnTao97/dgcnn.pytorch
https://github.com/HuguesTHOMAS/KPConv
https://github.com/QingyongHu/RandLA-Net
https://github.com/chrdiller/pyTorchChamferDistance
https://github.com/yanx27/Pointnet_Pointnet2_pytorch
https://github.com/AnTao97/UnsupervisedPointCloudReconstruction
We appreciate the help from the supportive technicians, Peter and Raf, from Cambridge Engineering :)
347 Dec 24, 2022
73 Nov 30, 2022
30 Dec 18, 2022
109 Nov 22, 2022
88 Dec 1, 2022
123 Jan 1, 2023
148 Dec 30, 2022
84 Dec 26, 2022
91 Dec 14, 2022
83 Dec 15, 2022
64 Nov 19, 2022
143 Dec 23, 2022
75 Dec 9, 2022
40 Dec 14, 2022
95 Nov 22, 2022
46 Nov 17, 2022
281 Dec 30, 2022
25 Dec 17, 2022