Page d'accueil>Lié à la programmation>Python
Télécharger


Pointcept est une base de code puissante et flexible pour la recherche sur la perception des nuages de points. Il s'agit également d'une mise en œuvre officielle du document suivant:

  • Point Transformer V3: plus simple, plus rapide, plus fort
    Xiaoyang Wu, Li Jiang, Peng-Shuai Wang, Zhijian Liu, Xihui Liu, Yu Qiao, Wanli Ouyang, Tong He, Hengshuang Zhao
    Conférence IEEE sur la vision par ordinateur et la reconnaissance des modèles ( CVPR ) 2024 - oral
    [Backbone] [ptv3] - [arXiv] [Bib] [Project] → Ici

  • OA-CNNS: CNNS clairsemé omni-adaptif pour la segmentation sémantique 3D
    Bohao Peng, Xiaoyang Wu, Li Jiang, Yukang Chen, Hengshuang Zhao, Zhuotao Tian, Jiaya Jia
    Conférence IEEE sur la vision par ordinateur et la reconnaissance des modèles ( CVPR ) 2024
    [Backbone] [OA-CNNS] - [arXiv] [Bib] → Ici

  • Vers la représentation 3D à grande échelle avec une formation rapide sur le point multi-dataset
    Xiaoyang Wu, Zhuotao Tian, Xin Wen, Bohao Peng, Xihui Liu, Kaicheng Yu, Hengshuang Zhao
    Conférence IEEE sur la vision par ordinateur et la reconnaissance des modèles ( CVPR ) 2024
    [Pretrain] [ppt] - [arXiv] [Bib] → Ici

  • Contraste de scène masquée: un cadre évolutif pour l'apprentissage de la représentation 3D non supervisée
    Xiaoyang Wu, Xin Wen, Xihui Liu, Hengshuang Zhao
    Conférence IEEE sur la vision par ordinateur et la reconnaissance des modèles ( CVPR ) 2023
    [Pretrain] [MSC] - [arXiv] [Bib] → Ici

  • Classificateur d'apprentissage au contexte pour la segmentation sémantique (partie 3D)
    Zhuotao Tian, Jiequan Cui, Li Jiang, Xiaojuan Qi, Xin Lai, Yixin Chen, Shu Liu, Jiaya Jia
    Conférence AAAI sur l'intelligence artificielle ( AAAI ) 2023 - oral
    [SEMSEG] [CAC] - [ARXIV] [BIB] [Partie 2D] → Ici

  • Point Transformateur V2: l'attention des vecteurs groupés et la mise en commun basée sur la partition
    Xiaoyang Wu, Yixing Lao, Li Jiang, Xihui Liu, Hengshuang Zhao
    Conférence sur les systèmes de traitement de l'information neuronaux ( NIRIPS ) 2022
    [Backbone] [ptv2] - [arXiv] [Bib] → Ici

  • Transformateur de points
    Hengshuang Zhao, Li Jiang, Jiaya Jia, Philip Torr, Vladlen Koltun
    IEEE International Conference on Computer Vision ( ICCV ) 2021 - oral
    [Backbone] [ptv1] - [arXiv] [Bib] → Ici

De plus, Pointcept intègre l'excellent travail suivant (contenir ci-dessus):
Backbone: Minkunet (ici), SPUNET (ici), spvcnn (ici), oaCnns (ici), ptv1 (ici), ptv2 (ici), ptv3 (ici), stratifiedFormer (ici), octoformer (ici), Swin3d (ici);
Segmentation sémantique: mix3d (ici), CAC (ici);
Segmentation des instances: PointGroup (ici);
Pré-formation: Point-Contrast (ici), Contextes de scène contrastives (ici), contraste de scène masquée (ici), formation rapide de points (ici);
Ensembles de données: scannet (ici), scannet200 (ici), scannet ++ (ici), s3dis (ici), Matterport3d (ici), arkitscene, Structured3d (ici), Semantictickitti (ici), nuscenes (ici), ModelNet40 (ici), waymo (ici).

Points forts

  • Mai 2024 : Dans V1.5.2, nous avons repensé la structure par défaut de chaque ensemble de données pour de meilleures performances. Veuillez refaire des ensembles de données ou télécharger nos ensembles de données prétraités à partir d' ici .
  • Avr, 2024 : PTV3 est sélectionné comme l'un des 90 articles oraux (3,3% de documents acceptés, 0,78% de soumissions) par CVPR'24!
  • MAR, 2024 : Nous libérons le code pour OA-CNNS , accepté par CVPR'24. Le problème lié à OA-CNNS peut @pbihao.
  • Février 2024 : PTV3 et PPT sont acceptés par CVPR'24, deux autres articles de notre équipe Pointcept ont également été acceptés par CVPR'24 ???. Nous les rendrons publiquement disponibles publiquement!
  • Dec, 2023 : PTV3 est publié sur ArXIV, et le code est disponible dans Pointcept. PTV3 est un modèle de squelette efficace qui réalise des performances SOTA à travers les scénarios intérieurs et extérieurs.
  • Août 2023 : PPT est publié sur Arxiv. PPT présente un cadre pré-formation multi-dataset qui réalise les performances SOTA dans les scénarios intérieurs et extérieurs . Il est compatible avec divers frameworks et squelette pré-formation existants. Une version pré-libération du code est accessible; Pour les personnes intéressées, n'hésitez pas à me contacter directement pour l'accès.
  • MAR, 2023 : Nous avons publié notre base de code, Pointcept , un outil très puissant pour l'apprentissage et la perception de la représentation du nuage de points. Nous nous réjouissons de nouveaux travaux pour rejoindre la famille Pointcept et recommandons vivement lire le démarrage rapide avant de commencer votre sentier.
  • Février 2023 : MSC et CECO acceptés par CVPR 2023. MSC est un cadre de pré-formation très efficace et efficace qui facilite la pré-élaction à grande échelle en dataset à grande échelle, tandis que le CECO est une méthode de segmentation spécifiquement conçue pour les ensembles de données à longue queue. Les deux approches sont compatibles avec tous les modèles d'épine dorsale existants de notre base de code, et nous rendrons bientôt le code disponible pour un usage public.
  • Janvier 2023 : CAC , travail oral de AAAI 2023, a élargi son résultat 3D avec l'incorporation de Pointcept. Cet ajout permettra à CAC de servir de segmentant enfichable dans notre base de code.
  • SEP, 2022 : PTV2 accepté par les Neirips 2022. Il s'agit d'une continuation du transformateur ponctuel. La théorie GVA proposée peut s'appliquer à la plupart des mécanismes d'attention existants, tandis que la mise en commun des grilles est également un ajout pratique aux méthodes de mise en commun existantes.

Citation

Si vous trouvez Pointcept utile à vos recherches, veuillez citer notre travail comme des encouragements. (੭ˊ꒳ˋ) ੭✧ 

 @misc{pointcept2023,
    title={Pointcept: A Codebase for Point Cloud Perception Research},
    author={Pointcept Contributors},
    howpublished = {url{https://github.com/Pointcept/Pointcept}},
    year={2023}
}

Aperçu

  • Installation
  • Préparation des données
  • Démarrage rapide
  • Zoo modèle
  • Citation
  • Reconnaissance

Installation

Exigences

  • Ubuntu: 18.04 et plus.
  • Cuda: 11,3 et plus.
  • Pytorch: 1.10.0 et supérieur.

Environnement conda 

conda create -n pointcept python=3.8 -y
conda activate pointcept
conda install ninja -y
# Choose version you want here: https://pytorch.org/get-started/previous-versions/
conda install pytorch==1.12.1 torchvision==0.13.1 torchaudio==0.12.1 cudatoolkit=11.3 -c pytorch -y
conda install h5py pyyaml -c anaconda -y
conda install sharedarray tensorboard tensorboardx yapf addict einops scipy plyfile termcolor timm -c conda-forge -y
conda install pytorch-cluster pytorch-scatter pytorch-sparse -c pyg -y
pip install torch-geometric

# spconv (SparseUNet)
# refer https://github.com/traveller59/spconv
pip install spconv-cu113

# PPT (clip)
pip install ftfy regex tqdm
pip install git+https://github.com/openai/CLIP.git

# PTv1 & PTv2 or precise eval
cd libs/pointops
# usual
python setup.py install
# docker & multi GPU arch
TORCH_CUDA_ARCH_LIST= " ARCH LIST " python  setup.py install
# e.g. 7.5: RTX 3000; 8.0: a100 More available in: https://developer.nvidia.com/cuda-gpus
TORCH_CUDA_ARCH_LIST= " 7.5 8.0 " python  setup.py install
cd ../..

# Open3D (visualization, optional)
pip install open3d

Préparation des données

Scanne v2

Le prétraitement prend en charge la segmentation sémantique et d'instance pour les données ScanNet20 , ScanNet200 et ScanNet Data Efficient .

  • Téléchargez l'ensemble de données Scanet V2.

  • Exécutez le code de prétraitement pour la scanne brute comme suit: 

     # RAW_SCANNET_DIR: the directory of downloaded ScanNet v2 raw dataset.
# PROCESSED_SCANNET_DIR: the directory of the processed ScanNet dataset (output dir).
python pointcept/datasets/preprocessing/scannet/preprocess_scannet.py --dataset_root ${RAW_SCANNET_DIR} --output_root ${PROCESSED_SCANNET_DIR}

  • (Facultatif) Télécharger les données SCANNET Data Efficient Fichiers: 

     # download-scannet.py is the official download script
# or follow instructions here: https://kaldir.vc.in.tum.de/scannet_benchmark/data_efficient/documentation#download
python download-scannet.py --data_efficient -o ${RAW_SCANNET_DIR}
# unzip downloads
cd ${RAW_SCANNET_DIR} /tasks
unzip limited-annotation-points.zip
unzip limited-reconstruction-scenes.zip
# copy files to processed dataset folder
mkdir ${PROCESSED_SCANNET_DIR} /tasks
cp -r ${RAW_SCANNET_DIR} /tasks/points ${PROCESSED_SCANNET_DIR} /tasks
cp -r ${RAW_SCANNET_DIR} /tasks/scenes ${PROCESSED_SCANNET_DIR} /tasks

  • (Alternative) Nos données de prétraitement peuvent être directement téléchargées [ici], veuillez convenir de la licence officielle avant de les télécharger.

  • Lien de jeu de données traité à la base de code: 

     # PROCESSED_SCANNET_DIR: the directory of the processed ScanNet dataset.
mkdir data
ln -s ${PROCESSED_SCANNET_DIR} ${CODEBASE_DIR} /data/scannet

Scanne ++

  • Téléchargez l'ensemble de données scannet ++.
  • Exécutez le code de prétraitement pour brute scanne ++ comme suit: 
     # RAW_SCANNETPP_DIR: the directory of downloaded ScanNet++ raw dataset.
# PROCESSED_SCANNETPP_DIR: the directory of the processed ScanNet++ dataset (output dir).
# NUM_WORKERS: the number of workers for parallel preprocessing.
python pointcept/datasets/preprocessing/scannetpp/preprocess_scannetpp.py --dataset_root ${RAW_SCANNETPP_DIR} --output_root ${PROCESSED_SCANNETPP_DIR} --num_workers ${NUM_WORKERS}
  • Échantillonnage et bunking de grandes données de nuages de points dans le train / Val Split comme suit (uniquement utilisé pour la formation): 
     # PROCESSED_SCANNETPP_DIR: the directory of the processed ScanNet++ dataset (output dir).
# NUM_WORKERS: the number of workers for parallel preprocessing.
python pointcept/datasets/preprocessing/sampling_chunking_data.py --dataset_root ${PROCESSED_SCANNETPP_DIR} --grid_size 0.01 --chunk_range 6 6 --chunk_stride 3 3 --split train --num_workers ${NUM_WORKERS}
python pointcept/datasets/preprocessing/sampling_chunking_data.py --dataset_root ${PROCESSED_SCANNETPP_DIR} --grid_size 0.01 --chunk_range 6 6 --chunk_stride 3 3 --split val --num_workers ${NUM_WORKERS}
  • (Alternative) Nos données de prétraitement peuvent être directement téléchargées [ici], veuillez convenir de la licence officielle avant de les télécharger.
  • Lien de jeu de données traité à la base de code: 
     # PROCESSED_SCANNETPP_DIR: the directory of the processed ScanNet dataset.
mkdir data
ln -s ${PROCESSED_SCANNETPP_DIR} ${CODEBASE_DIR} /data/scannetpp

S3dis

  • Téléchargez les données S3DIS en remplissant ce formulaire Google. Téléchargez le fichier Stanford3dDataset_v1.2.zip et dézip.

  • Correction de l'erreur dans Area_5/office_19/Annotations/ceiling 323474 (103.0�0000 => 103.000000).

  • (Facultatif) Télécharger un ensemble de données S3DIS complet complet 2D-3D (pas de XYZ) d'ici pour l'analyse normale.

  • Exécutez le code de prétraitement pour S3DIS comme suit: 

     # S3DIS_DIR: the directory of downloaded Stanford3dDataset_v1.2 dataset.
# RAW_S3DIS_DIR: the directory of Stanford2d3dDataset_noXYZ dataset. (optional, for parsing normal)
# PROCESSED_S3DIS_DIR: the directory of processed S3DIS dataset (output dir).

# S3DIS without aligned angle
python pointcept/datasets/preprocessing/s3dis/preprocess_s3dis.py --dataset_root ${S3DIS_DIR} --output_root ${PROCESSED_S3DIS_DIR}
# S3DIS with aligned angle
python pointcept/datasets/preprocessing/s3dis/preprocess_s3dis.py --dataset_root ${S3DIS_DIR} --output_root ${PROCESSED_S3DIS_DIR} --align_angle
# S3DIS with normal vector (recommended, normal is helpful)
python pointcept/datasets/preprocessing/s3dis/preprocess_s3dis.py --dataset_root ${S3DIS_DIR} --output_root ${PROCESSED_S3DIS_DIR} --raw_root ${RAW_S3DIS_DIR} --parse_normal
python pointcept/datasets/preprocessing/s3dis/preprocess_s3dis.py --dataset_root ${S3DIS_DIR} --output_root ${PROCESSED_S3DIS_DIR} --raw_root ${RAW_S3DIS_DIR} --align_angle --parse_normal

  • (Alternative) Nos données de prétraitement peuvent également être téléchargées [ici] (avec un vecteur normal et un angle aligné), veuillez être d'accord avec la licence officielle avant de les télécharger.

  • Lien de jeu de données traité à la base de code. 

     # PROCESSED_S3DIS_DIR: the directory of processed S3DIS dataset.
mkdir data
ln -s ${PROCESSED_S3DIS_DIR} ${CODEBASE_DIR} /data/s3dis

Structuré3d

  • Téléchargez les fichiers ZIP liés à Panorama Structured3D (complet) en remplissant ce formulaire Google (pas besoin de les décompresser).
  • Organisez tous les fichiers zip téléchargés dans un dossier ( ${STRUCT3D_DIR} ).
  • Exécutez le code de prétraitement pour Structured3D comme suit: 
     # STRUCT3D_DIR: the directory of downloaded Structured3D dataset.
# PROCESSED_STRUCT3D_DIR: the directory of processed Structured3D dataset (output dir).
# NUM_WORKERS: Number for workers for preprocessing, default same as cpu count (might OOM).
export PYTHONPATH=./
python pointcept/datasets/preprocessing/structured3d/preprocess_structured3d.py --dataset_root ${STRUCT3D_DIR} --output_root ${PROCESSED_STRUCT3D_DIR} --num_workers ${NUM_WORKERS} --grid_size 0.01 --fuse_prsp --fuse_pano

Suite à l'instruction de SWIN3D, nous conservons 25 catégories avec des fréquences de plus de 0,001, sur les 40 catégories d'origine.

  • (Alternative) Nos données de prétraitement peuvent également être téléchargées [ici] (avec des vues en perspective et Panorama View, 471,7g après la décompression), veuillez convenir de la licence officielle avant de la télécharger.

  • Lien de jeu de données traité à la base de code. 

     # PROCESSED_STRUCT3D_DIR: the directory of processed Structured3D dataset (output dir).
mkdir data
ln -s ${PROCESSED_STRUCT3D_DIR} ${CODEBASE_DIR} /data/structured3d

Matterport3d

  • Suivez cette page pour demander l'accès à l'ensemble de données.
  • Téléchargez le type "Region_segmentation", qui représente la division d'une scène dans des pièces individuelles. 
     # download-mp.py is the official download script
# MATTERPORT3D_DIR: the directory of downloaded Matterport3D dataset.
python download-mp.py -o {MATTERPORT3D_DIR} --type region_segmentations
  • Décomposer les données de la région_segments 
     # MATTERPORT3D_DIR: the directory of downloaded Matterport3D dataset.
python pointcept/datasets/preprocessing/matterport3d/unzip_matterport3d_region_segmentation.py --dataset_root {MATTERPORT3D_DIR}
  • Exécutez le code de prétraitement pour Matterport3d comme suit: 
     # MATTERPORT3D_DIR: the directory of downloaded Matterport3D dataset.
# PROCESSED_MATTERPORT3D_DIR: the directory of processed Matterport3D dataset (output dir).
# NUM_WORKERS: the number of workers for this preprocessing.
python pointcept/datasets/preprocessing/matterport3d/preprocess_matterport3d_mesh.py --dataset_root ${MATTERPORT3D_DIR} --output_root ${PROCESSED_MATTERPORT3D_DIR} --num_workers ${NUM_WORKERS}
  • Lien de jeu de données traité à la base de code. 
     # PROCESSED_MATTERPORT3D_DIR: the directory of processed Matterport3D dataset (output dir).
mkdir data
ln -s ${PROCESSED_MATTERPORT3D_DIR} ${CODEBASE_DIR} /data/matterport3d

Suite à l'instruction des Open Rooms, nous avons remontré les catégories de Matterport3D à SCANNET 20 catégories sémantiques avec l'ajout d'une catégorie de plafond.

  • (Alternative) Nos données de prétraitement peuvent également être téléchargées ici, veuillez convenir de la licence officielle avant de les télécharger.

Semantictickitti

  • Téléchargez un ensemble de données Semantictickitti.
  • Lien de l'ensemble de données vers CodeBase. 
     # SEMANTIC_KITTI_DIR: the directory of SemanticKITTI dataset.
# |- SEMANTIC_KITTI_DIR
#   |- dataset
#     |- sequences
#       |- 00
#       |- 01
#       |- ...

mkdir -p data
ln -s ${SEMANTIC_KITTI_DIR} ${CODEBASE_DIR} /data/semantic_kitti

nuscenes

  • Téléchargez l'ensemble de données officiel en nusce (avec segmentation Lidar) et organisez les fichiers téléchargés comme suit: 

    NUSCENES_DIR
│── samples
│── sweeps
│── lidarseg
...
│── v1.0-trainval 
│── v1.0-test

  • Exécutez le code de prétraitement des informations (modifié à partir d'OpenPCDET) pour nuscenes comme suit: 

     # NUSCENES_DIR: the directory of downloaded nuScenes dataset.
# PROCESSED_NUSCENES_DIR: the directory of processed nuScenes dataset (output dir).
# MAX_SWEEPS: Max number of sweeps. Default: 10.
pip install nuscenes-devkit pyquaternion
python pointcept/datasets/preprocessing/nuscenes/preprocess_nuscenes_info.py --dataset_root ${NUSCENES_DIR} --output_root ${PROCESSED_NUSCENES_DIR} --max_sweeps ${MAX_SWEEPS} --with_camera

  • (Alternative) Nos données d'informations sur les nuscenes de prétraitement peuvent également être téléchargées [ici] (seules les informations traitées, doivent toujours télécharger un ensemble de données bruts et un lien vers le dossier), veuillez convenir de la licence officielle avant de les télécharger.

  • Lienz le dossier de données brutes au dossier de données NUSCECE traité: 

     # NUSCENES_DIR: the directory of downloaded nuScenes dataset.
# PROCESSED_NUSCENES_DIR: the directory of processed nuScenes dataset (output dir).
ln -s ${NUSCENES_DIR} {PROCESSED_NUSCENES_DIR}/raw

    Ensuite, le dossier Nuscenes traité est organisé comme suit: 

    nuscene
| ── raw
    │── samples
    │── sweeps
    │── lidarseg
    ...
    │── v1.0-trainval
    │── v1.0-test
| ── info

  • Lien de jeu de données traité à la base de code. 

     # PROCESSED_NUSCENES_DIR: the directory of processed nuScenes dataset (output dir).
mkdir data
ln -s ${PROCESSED_NUSCENES_DIR} ${CODEBASE_DIR} /data/nuscenes

Waymo

  • Téléchargez l'ensemble de données Waymo officiel (V1.4.3) et organisez les fichiers téléchargés comme suit: 

    WAYMO_RAW_DIR
│── training
│── validation
│── testing

  • Installez la dépendance suivante: 

     # If shows "No matching distribution found", download whl directly from Pypi and install the package.
conda create -n waymo python=3.10 -y
conda activate waymo
pip install waymo-open-dataset-tf-2-12-0

  • Exécutez le code de prétraitement comme suit: 

     # WAYMO_DIR: the directory of the downloaded Waymo dataset.
# PROCESSED_WAYMO_DIR: the directory of the processed Waymo dataset (output dir).
# NUM_WORKERS: num workers for preprocessing
python pointcept/datasets/preprocessing/waymo/preprocess_waymo.py --dataset_root ${WAYMO_DIR} --output_root ${PROCESSED_WAYMO_DIR} --splits training validation --num_workers ${NUM_WORKERS}

  • Lien de jeu de données traité à la base de code. 

     # PROCESSED_WAYMO_DIR: the directory of the processed Waymo dataset (output dir).
mkdir data
ln -s ${PROCESSED_WAYMO_DIR} ${CODEBASE_DIR} /data/waymo

Modèle

  • Télécharger ModelNet40_Normal_Resampled.Zip et Unzip
  • Lienz l'ensemble de données à la base de code. 
    mkdir -p data
ln -s ${MODELNET_DIR} ${CODEBASE_DIR} /data/modelnet40_normal_resampled

Démarrage rapide

Entraînement

Train à partir de zéro. Le traitement de la formation est basé sur des configurations dans le dossier configs . Le script de formation générera un dossier d'expérience dans le dossier exp et le code essentiel de sauvegarde dans le dossier Experiment. La configuration de formation, le journal, le tensorboard et les points de contrôle seront également enregistrés dans le dossier de l'expérience pendant le processus de formation. 

 export CUDA_VISIBLE_DEVICES= ${CUDA_VISIBLE_DEVICES}
# Script (Recommended)
sh scripts/train.sh -p ${INTERPRETER_PATH} -g ${NUM_GPU} -d ${DATASET_NAME} -c ${CONFIG_NAME} -n ${EXP_NAME}
# Direct
export PYTHONPATH=./
python tools/train.py --config-file ${CONFIG_PATH} --num-gpus ${NUM_GPU} --options save_path= ${SAVE_PATH}

Par exemple: 

 # By script (Recommended)
# -p is default set as python and can be ignored
sh scripts/train.sh -p python -d scannet -c semseg-pt-v2m2-0-base -n semseg-pt-v2m2-0-base
# Direct
export PYTHONPATH=./
python tools/train.py --config-file configs/scannet/semseg-pt-v2m2-0-base.py --options save_path=exp/scannet/semseg-pt-v2m2-0-base

Reprendre la formation de Checkpoint. Si le processus de formation est interrompu par accident, le script suivant peut reprendre la formation d'un point de contrôle donné. 

 export CUDA_VISIBLE_DEVICES= ${CUDA_VISIBLE_DEVICES}
# Script (Recommended)
# simply add "-r true"
sh scripts/train.sh -p ${INTERPRETER_PATH} -g ${NUM_GPU} -d ${DATASET_NAME} -c ${CONFIG_NAME} -n ${EXP_NAME} -r true
# Direct
export PYTHONPATH=./
python tools/train.py --config-file ${CONFIG_PATH} --num-gpus ${NUM_GPU} --options save_path= ${SAVE_PATH} resume=True weight= ${CHECKPOINT_PATH}

Essai

Pendant la formation, l'évaluation du modèle est effectuée sur des nuages ponctuels après échantillonnage de grille (voxélisation), fournissant une évaluation initiale des performances du modèle. Cependant, pour obtenir des résultats d'évaluation précis, des tests sont essentiels . Le processus de test consiste à sous-échantillonner un nuage de points dense dans une séquence de nuages ponctuels voxélisés, assurant une couverture complète de tous les points. Ces sous-résultats sont ensuite prédits et collectés pour former une prédiction complète de l'ensemble du nuage de points. Cette approche donne des résultats d'évaluation plus élevés par rapport à la simple cartographie / interpolation de la prédiction. De plus, notre code de test prend en charge les tests TTA (Test Time Augmentation), ce qui améliore encore la stabilité des performances d'évaluation. 

 # By script (Based on experiment folder created by training script)
sh scripts/test.sh -p ${INTERPRETER_PATH} -g ${NUM_GPU} -d ${DATASET_NAME} -n ${EXP_NAME} -w ${CHECKPOINT_NAME}
# Direct
export PYTHONPATH=./
python tools/test.py --config-file ${CONFIG_PATH} --num-gpus ${NUM_GPU} --options save_path= ${SAVE_PATH} weight= ${CHECKPOINT_PATH}

Par exemple: 

 # By script (Based on experiment folder created by training script)
# -p is default set as python and can be ignored
# -w is default set as model_best and can be ignored
sh scripts/test.sh -p python -d scannet -n semseg-pt-v2m2-0-base -w model_best
# Direct
export PYTHONPATH=./
python tools/test.py --config-file configs/scannet/semseg-pt-v2m2-0-base.py --options save_path=exp/scannet/semseg-pt-v2m2-0-base weight=exp/scannet/semseg-pt-v2m2-0-base/model/model_best.pth

Le TTA peut être désactivé en Remplacer data.test.test_cfg.aug_transform = [...] par: 

 data = dict (
    train = dict (...),
    val = dict (...),
    test = dict (
        ...,
        test_cfg = dict (
            ...,
            aug_transform = [
                [ dict ( type = "RandomRotateTargetAngle" , angle = [ 0 ], axis = "z" , center = [ 0 , 0 , 0 ], p = 1 )]
            ]
        )
    )
)

Compenser

Offset est le séparateur des nuages ponctuels dans les données par lots, et il est similaire au concept de Batch dans PYG. Une illustration visuelle du lot et du décalage est la suivante:


Zoo modèle

1. Écran et segmentation sémantique

Sterseunet

Pointcept fournit SparseUNet mis en œuvre par SpConv et MinkowskiEngine . La version SPCONV est recommandée car SPCONV est facile à installer et plus rapidement que Minkowskienne. Pendant ce temps, SPCONV est également largement appliqué dans la perception du plein air.

  • SPCONV (Recommander)

La version SPCONV SparseUNet dans la base de code a été entièrement réécrite à partir de la version MinkowskiEngine , l'exemple d'exécution du script est le suivant: 

 # ScanNet val
sh scripts/train.sh -g 4 -d scannet -c semseg-spunet-v1m1-0-base -n semseg-spunet-v1m1-0-base
# ScanNet200
sh scripts/train.sh -g 4 -d scannet200 -c semseg-spunet-v1m1-0-base -n semseg-spunet-v1m1-0-base
# S3DIS
sh scripts/train.sh -g 4 -d s3dis -c semseg-spunet-v1m1-0-base -n semseg-spunet-v1m1-0-base
# S3DIS (with normal)
sh scripts/train.sh -g 4 -d s3dis -c semseg-spunet-v1m1-0-cn-base -n semseg-spunet-v1m1-0-cn-base
# SemanticKITTI
sh scripts/train.sh -g 4 -d semantic_kitti -c semseg-spunet-v1m1-0-base -n semseg-spunet-v1m1-0-base
# nuScenes
sh scripts/train.sh -g 4 -d nuscenes -c semseg-spunet-v1m1-0-base -n semseg-spunet-v1m1-0-base
# ModelNet40
sh scripts/train.sh -g 2 -d modelnet40 -c cls-spunet-v1m1-0-base -n cls-spunet-v1m1-0-base

# ScanNet Data Efficient
sh scripts/train.sh -g 4 -d scannet -c semseg-spunet-v1m1-2-efficient-la20 -n semseg-spunet-v1m1-2-efficient-la20
sh scripts/train.sh -g 4 -d scannet -c semseg-spunet-v1m1-2-efficient-la50 -n semseg-spunet-v1m1-2-efficient-la50
sh scripts/train.sh -g 4 -d scannet -c semseg-spunet-v1m1-2-efficient-la100 -n semseg-spunet-v1m1-2-efficient-la100
sh scripts/train.sh -g 4 -d scannet -c semseg-spunet-v1m1-2-efficient-la200 -n semseg-spunet-v1m1-2-efficient-la200
sh scripts/train.sh -g 4 -d scannet -c semseg-spunet-v1m1-2-efficient-lr1 -n semseg-spunet-v1m1-2-efficient-lr1
sh scripts/train.sh -g 4 -d scannet -c semseg-spunet-v1m1-2-efficient-lr5 -n semseg-spunet-v1m1-2-efficient-lr5
sh scripts/train.sh -g 4 -d scannet -c semseg-spunet-v1m1-2-efficient-lr10 -n semseg-spunet-v1m1-2-efficient-lr10
sh scripts/train.sh -g 4 -d scannet -c semseg-spunet-v1m1-2-efficient-lr20 -n semseg-spunet-v1m1-2-efficient-lr20

# Profile model run time
sh scripts/train.sh -g 4 -d scannet -c semseg-spunet-v1m1-0-enable-profiler -n semseg-spunet-v1m1-0-enable-profiler
  • Minkowngine

La version Minkowskienne, SparseUNet dans la base de code a été modifiée à partir du dépôt d'origine MinkowskienEngine, et l'exemple de scripts en cours d'exécution sont les suivants:

  1. Installez Minkowskienne, référer https://github.com/nvidia/minkowskiennegine
  2. Formation avec l'exemple suivant Scripts: 
 # Uncomment "# from .sparse_unet import *" in "pointcept/models/__init__.py"
# Uncomment "# from .mink_unet import *" in "pointcept/models/sparse_unet/__init__.py"
# ScanNet
sh scripts/train.sh -g 4 -d scannet -c semseg-minkunet34c-0-base -n semseg-minkunet34c-0-base
# ScanNet200
sh scripts/train.sh -g 4 -d scannet200 -c semseg-minkunet34c-0-base -n semseg-minkunet34c-0-base
# S3DIS
sh scripts/train.sh -g 4 -d s3dis -c semseg-minkunet34c-0-base -n semseg-minkunet34c-0-base
# SemanticKITTI
sh scripts/train.sh -g 2 -d semantic_kitti -c semseg-minkunet34c-0-base -n semseg-minkunet34c-0-base

OA-CNNS

Présentation des CNN 3D omni-adaptatifs ( OA-CNN ), une famille de réseaux qui intègre un module léger pour améliorer considérablement l'adaptivité des CNN clairsemés à un coût de calcul minimal. Sans aucun module d'auto-agencement, OA-CNNS dépasse favorablement les transformateurs ponctuels en termes de précision dans les scènes intérieures et extérieures, avec beaucoup moins de latence et de coût de la mémoire. Le problème lié à OA-CNNS peut @pbihao. 

 # ScanNet
sh scripts/train.sh -g 4 -d scannet -c semseg-oacnns-v1m1-0-base -n semseg-oacnns-v1m1-0-base

Transformateurs de point

  • Ptv3

PTV3 est un modèle de squelette efficace qui réalise des performances SOTA à travers les scénarios intérieurs et extérieurs. Le PTV3 complet repose sur Flashattention, tandis que Flashattention repose sur CUDA 11.6 et plus, assurez-vous que votre environnement point-point local satisfait aux exigences.

Si vous ne pouvez pas mettre à niveau votre environnement local pour satisfaire les exigences (CUDA> = 11.6), vous pouvez désactiver FlashAttation en définissant le paramètre du modèle enable_flash pour false et en réduisant l' enc_patch_size et dec_patch_size à un niveau (par exemple 128).

FlashAntiser la force désactive RPE et force la précision réduite à FP16. Si vous avez besoin de ces fonctionnalités, veuillez désactiver enable_flash et ajuster enable_rpe , upcast_attention et upcast_softmax .

Des instructions détaillées et des enregistrements d'expérience (contenant des poids) sont disponibles sur le référentiel du projet. Exemple de scripts en cours d'exécution est le suivant: 

 # Scratched ScanNet
sh scripts/train.sh -g 4 -d scannet -c semseg-pt-v3m1-0-base -n semseg-pt-v3m1-0-base
# PPT joint training (ScanNet + Structured3D) and evaluate in ScanNet
sh scripts/train.sh -g 8 -d scannet -c semseg-pt-v3m1-1-ppt-extreme -n semseg-pt-v3m1-1-ppt-extreme

# Scratched ScanNet200
sh scripts/train.sh -g 4 -d scannet200 -c semseg-pt-v3m1-0-base -n semseg-pt-v3m1-0-base
# Fine-tuning from  PPT joint training (ScanNet + Structured3D) with ScanNet200
# PTV3_PPT_WEIGHT_PATH: Path to model weight trained by PPT multi-dataset joint training
# e.g. exp/scannet/semseg-pt-v3m1-1-ppt-extreme/model/model_best.pth
sh scripts/train.sh -g 4 -d scannet200 -c semseg-pt-v3m1-1-ppt-ft -n semseg-pt-v3m1-1-ppt-ft -w ${PTV3_PPT_WEIGHT_PATH}

# Scratched ScanNet++
sh scripts/train.sh -g 4 -d scannetpp -c semseg-pt-v3m1-0-base -n semseg-pt-v3m1-0-base
# Scratched ScanNet++ test
sh scripts/train.sh -g 4 -d scannetpp -c semseg-pt-v3m1-1-submit -n semseg-pt-v3m1-1-submit


# Scratched S3DIS
sh scripts/train.sh -g 4 -d s3dis -c semseg-pt-v3m1-0-base -n semseg-pt-v3m1-0-base
# an example for disbale flash_attention and enable rpe.
sh scripts/train.sh -g 4 -d s3dis -c semseg-pt-v3m1-1-rpe -n semseg-pt-v3m1-0-rpe
# PPT joint training (ScanNet + S3DIS + Structured3D) and evaluate in ScanNet
sh scripts/train.sh -g 8 -d s3dis -c semseg-pt-v3m1-1-ppt-extreme -n semseg-pt-v3m1-1-ppt-extreme
# S3DIS 6-fold cross validation
# 1. The default configs are evaluated on Area_5, modify the "data.train.split", "data.val.split", and "data.test.split" to make the config evaluated on Area_1 ~ Area_6 respectively.
# 2. Train and evaluate the model on each split of areas and gather result files located in "exp/s3dis/EXP_NAME/result/Area_x.pth" in one single folder, noted as RECORD_FOLDER.
# 3. Run the following script to get S3DIS 6-fold cross validation performance:
export PYTHONPATH=./
python tools/test_s3dis_6fold.py --record_root ${RECORD_FOLDER}

# Scratched nuScenes
sh scripts/train.sh -g 4 -d nuscenes -c semseg-pt-v3m1-0-base -n semseg-pt-v3m1-0-base
# Scratched Waymo
sh scripts/train.sh -g 4 -d waymo -c semseg-pt-v3m1-0-base -n semseg-pt-v3m1-0-base

# More configs and exp records for PTv3 will be available soon.

Segmentation sémantique intérieure

Modèle Référence Données supplémentaires Num gpus Val Miou Configurer Tensorboard EXP Record
Ptv3 Scannet ✗ 4 77,6% lien lien lien
Ptv3 + ppt Scannet ✓ 8 78,5% lien lien lien
Ptv3 Scannet200 ✗ 4 35,3% lien lien lien
Ptv3 + ppt Scannet200 ✓ (ft) 4
Ptv3 S3DIS (Area5) ✗ 4 73,6% lien lien lien
Ptv3 + ppt S3DIS (Area5) ✓ 8 75,4% lien lien lien

Segmentation sémantique extérieure

Modèle Référence Données supplémentaires Num gpus Val Miou Configurer Tensorboard EXP Record
Ptv3 nuscenes ✗ 4 80.3 lien lien lien
Ptv3 + ppt nuscenes ✓ 8
Ptv3 Semantictickitti ✗ 4
Ptv3 + ppt Semantictickitti ✓ 8
Ptv3 Waymo ✗ 4 71.2 lien lien lien (journal uniquement)
Ptv3 + ppt Waymo ✓ 8

* Les poids des modèles libérés sont formés pour la V1.5.1, les poids pour V1.5.2 et plus tard sont toujours en cours.

  • PTV2 MODE2

Le PTV2 d'origine a été formé sur 4 * RTX A6000 (mémoire 48g). Même en permettant AMP, le coût de la mémoire du PTV2 d'origine est légèrement supérieur à 24 g. Considérant que les GPU avec une mémoire 24g sont beaucoup plus accessibles, j'ai réglé le PTV2 sur le dernier point de vue et je l'ai rendu à la course sur 4 * RTX 3090 Machines.

PTv2 Mode2 permet l'ampli et désactive le multiplicateur de codage de position et le linéaire groupé . Au cours de nos recherches supplémentaires, nous avons constaté que des coordonnées précises ne sont pas nécessaires pour la compréhension des nuages de points (le remplacement des coordonnées précises par des coordonnées de la grille n'influence pas les performances. De plus, Sparseunet est un exemple). Quant à la linéaire groupée, mon implémentation de linéaire groupé semble coûter plus de mémoire que la couche linéaire fournie par Pytorch. Bénéficiant de la base de code et du meilleur réglage des paramètres, nous soulageons également le problème de sur-ajustement. Les performances de reproduction sont encore meilleures que les résultats rapportés dans notre article.

Exemple de scripts en cours d'exécution est le suivant: 

 # ptv2m2: PTv2 mode2, disable PEM & Grouped Linear, GPU memory cost < 24G (recommend)
# ScanNet
sh scripts/train.sh -g 4 -d scannet -c semseg-pt-v2m2-0-base -n semseg-pt-v2m2-0-base
sh scripts/train.sh -g 4 -d scannet -c semseg-pt-v2m2-3-lovasz -n semseg-pt-v2m2-3-lovasz

# ScanNet test
sh scripts/train.sh -g 4 -d scannet -c semseg-pt-v2m2-1-submit -n semseg-pt-v2m2-1-submit
# ScanNet200
sh scripts/train.sh -g 4 -d scannet200 -c semseg-pt-v2m2-0-base -n semseg-pt-v2m2-0-base
# ScanNet++
sh scripts/train.sh -g 4 -d scannetpp -c semseg-pt-v2m2-0-base -n semseg-pt-v2m2-0-base
# ScanNet++ test
sh scripts/train.sh -g 4 -d scannetpp -c semseg-pt-v2m2-1-submit -n semseg-pt-v2m2-1-submit
# S3DIS
sh scripts/train.sh -g 4 -d s3dis -c semseg-pt-v2m2-0-base -n semseg-pt-v2m2-0-base
# SemanticKITTI
sh scripts/train.sh -g 4 -d semantic_kitti -c semseg-pt-v2m2-0-base -n semseg-pt-v2m2-0-base
# nuScenes
sh scripts/train.sh -g 4 -d nuscenes -c semseg-pt-v2m2-0-base -n semseg-pt-v2m2-0-base
  • Mode PTV21

PTv2 mode1 est le PTV2 d'origine que nous avons signalé dans notre article, les exemples de scripts en cours d'exécution sont les suivants: 

 # ptv2m1: PTv2 mode1, Original PTv2, GPU memory cost > 24G
# ScanNet
sh scripts/train.sh -g 4 -d scannet -c semseg-pt-v2m1-0-base -n semseg-pt-v2m1-0-base
# ScanNet200
sh scripts/train.sh -g 4 -d scannet200 -c semseg-pt-v2m1-0-base -n semseg-pt-v2m1-0-base
# S3DIS
sh scripts/train.sh -g 4 -d s3dis -c semseg-pt-v2m1-0-base -n semseg-pt-v2m1-0-base
  • Ptv1

Le PTV1 d'origine est également disponible dans notre base de code Pointcept. Je n'ai pas exécuté PTV1 depuis longtemps, mais j'ai veillé à ce que l'exemple de script en cours d'exécution fonctionne bien. 

 # ScanNet
sh scripts/train.sh -g 4 -d scannet -c semseg-pt-v1-0-base -n semseg-pt-v1-0-base
# ScanNet200
sh scripts/train.sh -g 4 -d scannet200 -c semseg-pt-v1-0-base -n semseg-pt-v1-0-base
# S3DIS
sh scripts/train.sh -g 4 -d s3dis -c semseg-pt-v1-0-base -n semseg-pt-v1-0-base

Transformateur stratifié

  1. Exigences supplémentaires: 
pip install torch-points3d
# Fix dependence, caused by installing torch-points3d 
pip uninstall SharedArray
pip install SharedArray==3.2.1

cd libs/pointops2
python setup.py install
cd ../..
  1. Décomment # from .stratified_transformer import * dans pointcept/models/__init__.py .
  2. Référer une installation facultative pour installer la dépendance.
  3. Formation avec l'exemple suivant Scripts: 
 # stv1m1: Stratified Transformer mode1, Modified from the original Stratified Transformer code.
# PTv2m2: Stratified Transformer mode2, My rewrite version (recommend).

# ScanNet
sh scripts/train.sh -g 4 -d scannet -c semseg-st-v1m2-0-refined -n semseg-st-v1m2-0-refined
sh scripts/train.sh -g 4 -d scannet -c semseg-st-v1m1-0-origin -n semseg-st-v1m1-0-origin
# ScanNet200
sh scripts/train.sh -g 4 -d scannet200 -c semseg-st-v1m2-0-refined -n semseg-st-v1m2-0-refined
# S3DIS
sh scripts/train.sh -g 4 -d s3dis -c semseg-st-v1m2-0-refined -n semseg-st-v1m2-0-refined

Spvcnn

SPVCNN est un modèle de référence des SPVNA, il est également une base de référence pratique pour les ensembles de données extérieurs.

  1. Installez Torchsparse: 
 # refer https://github.com/mit-han-lab/torchsparse
# install method without sudo apt install
conda install google-sparsehash -c bioconda
export C_INCLUDE_PATH= ${CONDA_PREFIX} /include: $C_INCLUDE_PATH
export CPLUS_INCLUDE_PATH= ${CONDA_PREFIX} /include:CPLUS_INCLUDE_PATH
pip install --upgrade git+https://github.com/mit-han-lab/torchsparse.git
  1. Formation avec l'exemple suivant Scripts: 
 # SemanticKITTI
sh scripts/train.sh -g 2 -d semantic_kitti -c semseg-spvcnn-v1m1-0-base -n semseg-spvcnn-v1m1-0-base

Octformer

OctFormer de OctFormer: Transformers basés sur OCTREE pour les nuages de points 3D .

  1. Exigences supplémentaires: 
 cd libs
git clone https://github.com/octree-nn/dwconv.git
pip install ./dwconv
pip install ocnn
  1. Décomment # from .octformer import * pointcept/models/__init__.py
  2. Formation avec l'exemple suivant Scripts: 
 # ScanNet
sh scripts/train.sh -g 4 -d scannet -c semseg-octformer-v1m1-0-base -n semseg-octformer-v1m1-0-base

Swin3d

SWIN3D de SWIN3D: une épine dorsale de transformateur pré-entraîné pour la compréhension de la scène intérieure 3D .

  1. Exigences supplémentaires: 
 # 1. Install MinkEngine v0.5.4, follow readme in https://github.com/NVIDIA/MinkowskiEngine;
# 2. Install Swin3D, mainly for cuda operation:
cd libs
git clone https://github.com/microsoft/Swin3D.git
cd Swin3D
pip install ./
  1. Décomment # from .swin3d import * dans pointcept/models/__init__.py .
  2. Pré-formation avec l'exemple suivant Scripts (prétraitement structuré3D Reportez-vous ici): 
 # Structured3D + Swin-S
sh scripts/train.sh -g 4 -d structured3d -c semseg-swin3d-v1m1-0-small -n semseg-swin3d-v1m1-0-small
# Structured3D + Swin-L
sh scripts/train.sh -g 4 -d structured3d -c semseg-swin3d-v1m1-1-large -n semseg-swin3d-v1m1-1-large

# Addition
# Structured3D + SpUNet
sh scripts/train.sh -g 4 -d structured3d -c semseg-spunet-v1m1-0-base -n semseg-spunet-v1m1-0-base
# Structured3D + PTv2
sh scripts/train.sh -g 4 -d structured3d -c semseg-pt-v2m2-0-base -n semseg-pt-v2m2-0-base
  1. Affiner avec l'exemple suivant Scripts: 
 # ScanNet + Swin-S
sh scripts/train.sh -g 4 -d scannet -w exp/structured3d/semseg-swin3d-v1m1-1-large/model/model_last.pth -c semseg-swin3d-v1m1-0-small -n semseg-swin3d-v1m1-0-small
# ScanNet + Swin-L
sh scripts/train.sh -g 4 -d scannet -w exp/structured3d/semseg-swin3d-v1m1-1-large/model/model_last.pth -c semseg-swin3d-v1m1-1-large -n semseg-swin3d-v1m1-1-large

# S3DIS + Swin-S (here we provide config support S3DIS normal vector)
sh scripts/train.sh -g 4 -d s3dis -w exp/structured3d/semseg-swin3d-v1m1-1-large/model/model_last.pth -c semseg-swin3d-v1m1-0-small -n semseg-swin3d-v1m1-0-small
# S3DIS + Swin-L (here we provide config support S3DIS normal vector)
sh scripts/train.sh -g 4 -d s3dis -w exp/structured3d/semseg-swin3d-v1m1-1-large/model/model_last.pth -c semseg-swin3d-v1m1-1-large -n semseg-swin3d-v1m1-1-large

Classificateur de contexte

Context-Aware Classifier est un segmentant qui peut encore augmenter les performances de chaque épine dorsale, en remplacement du Default Segmentor . Formation avec l'exemple suivant Scripts: 

 # ScanNet
sh scripts/train.sh -g 4 -d scannet -c semseg-cac-v1m1-0-spunet-base -n semseg-cac-v1m1-0-spunet-base
sh scripts/train.sh -g 4 -d scannet -c semseg-cac-v1m1-1-spunet-lovasz -n semseg-cac-v1m1-1-spunet-lovasz
sh scripts/train.sh -g 4 -d scannet -c semseg-cac-v1m1-2-ptv2-lovasz -n semseg-cac-v1m1-2-ptv2-lovasz

# ScanNet200
sh scripts/train.sh -g 4 -d scannet200 -c semseg-cac-v1m1-0-spunet-base -n semseg-cac-v1m1-0-spunet-base
sh scripts/train.sh -g 4 -d scannet200 -c semseg-cac-v1m1-1-spunet-lovasz -n semseg-cac-v1m1-1-spunet-lovasz
sh scripts/train.sh -g 4 -d scannet200 -c semseg-cac-v1m1-2-ptv2-lovasz -n semseg-cac-v1m1-2-ptv2-lovasz

2. Segmentation des instances

Groupe de points

PointGroup est un cadre de base pour la segmentation des instances de cloud de point.

  1. Exigences supplémentaires: 
conda install -c bioconda google-sparsehash 
cd libs/pointgroup_ops
python setup.py install --include_dirs= ${CONDA_PREFIX} /include
cd ../..
  1. Décomment # from .point_group import * dans pointcept/models/__init__.py .
  2. Formation avec l'exemple suivant Scripts: 
 # ScanNet
sh scripts/train.sh -g 4 -d scannet -c insseg-pointgroup-v1m1-0-spunet-base -n insseg-pointgroup-v1m1-0-spunet-base
# S3DIS
sh scripts/train.sh -g 4 -d scannet -c insseg-pointgroup-v1m1-0-spunet-base -n insseg-pointgroup-v1m1-0-spunet-base

3. Pré-formation

Contraste de scène masquée (MSC)

  1. Pré-formation avec l'exemple suivant Scripts: 
 # ScanNet
sh scripts/train.sh -g 8 -d scannet -c pretrain-msc-v1m1-0-spunet-base -n pretrain-msc-v1m1-0-spunet-base
  1. Affiner avec l'exemple suivant Scripts:
    Activez le groupe PointGroup (ici) avant de régler la tâche de segmentation des instances. 
 # ScanNet20 Semantic Segmentation
sh scripts/train.sh -g 8 -d scannet -w exp/scannet/pretrain-msc-v1m1-0-spunet-base/model/model_last.pth -c semseg-spunet-v1m1-4-ft -n semseg-msc-v1m1-0f-spunet-base
# ScanNet20 Instance Segmentation (enable PointGroup before running the script)
sh scripts/train.sh -g 4 -d scannet -w exp/scannet/pretrain-msc-v1m1-0-spunet-base/model/model_last.pth -c insseg-pointgroup-v1m1-0-spunet-base -n insseg-msc-v1m1-0f-pointgroup-spunet-base
  1. Exemple de journal et de poids: [Pretrain] [Semseg]

Formation rapide (PPT)

PPT présente un cadre de pré-formation multi-dataset, et il est compatible avec divers frameworks et épine dorsale pré-formation existants.

  1. PPT a supervisé la formation conjointe avec l'exemple suivant Scripts: 
 # ScanNet + Structured3d, validate on ScanNet (S3DIS might cause long data time, w/o S3DIS for a quick validation) >= 3090 * 8 
sh scripts/train.sh -g 8 -d scannet -c semseg-ppt-v1m1-0-sc-st-spunet -n semseg-ppt-v1m1-0-sc-st-spunet
sh scripts/train.sh -g 8 -d scannet -c semseg-ppt-v1m1-1-sc-st-spunet-submit -n semseg-ppt-v1m1-1-sc-st-spunet-submit
# ScanNet + S3DIS + Structured3d, validate on S3DIS (>= a100 * 8)
sh scripts/train.sh -g 8 -d s3dis -c semseg-ppt-v1m1-0-s3-sc-st-spunet -n semseg-ppt-v1m1-0-s3-sc-st-spunet
# SemanticKITTI + nuScenes + Waymo, validate on SemanticKITTI (bs12 >= 3090 * 4 >= 3090 * 8, v1m1-0 is still on tuning)
sh scripts/train.sh -g 4 -d semantic_kitti -c semseg-ppt-v1m1-0-nu-sk-wa-spunet -n semseg-ppt-v1m1-0-nu-sk-wa-spunet
sh scripts/train.sh -g 4 -d semantic_kitti -c semseg-ppt-v1m2-0-sk-nu-wa-spunet -n semseg-ppt-v1m2-0-sk-nu-wa-spunet
sh scripts/train.sh -g 4 -d semantic_kitti -c semseg-ppt-v1m2-1-sk-nu-wa-spunet-submit -n semseg-ppt-v1m2-1-sk-nu-wa-spunet-submit
# SemanticKITTI + nuScenes + Waymo, validate on nuScenes (bs12 >= 3090 * 4; bs24 >= 3090 * 8, v1m1-0 is still on tuning))
sh scripts/train.sh -g 4 -d nuscenes -c semseg-ppt-v1m1-0-nu-sk-wa-spunet -n semseg-ppt-v1m1-0-nu-sk-wa-spunet
sh scripts/train.sh -g 4 -d nuscenes -c semseg-ppt-v1m2-0-nu-sk-wa-spunet -n semseg-ppt-v1m2-0-nu-sk-wa-spunet
sh scripts/train.sh -g 4 -d nuscenes -c semseg-ppt-v1m2-1-nu-sk-wa-spunet-submit -n semseg-ppt-v1m2-1-nu-sk-wa-spunet-submit

Terrain de point

  1. Ensemble de données de scannet-paire de prétraitement et de liaison (correspondance par paire avec un cadre RVB D brut scannet, ~ 1,5T): 
 # RAW_SCANNET_DIR: the directory of downloaded ScanNet v2 raw dataset.
# PROCESSED_SCANNET_PAIR_DIR: the directory of processed ScanNet pair dataset (output dir).
python pointcept/datasets/preprocessing/scannet/scannet_pair/preprocess.py --dataset_root ${RAW_SCANNET_DIR} --output_root ${PROCESSED_SCANNET_PAIR_DIR}
ln -s ${PROCESSED_SCANNET_PAIR_DIR} ${CODEBASE_DIR} /data/scannet
  1. Pré-formation avec l'exemple suivant Scripts: 
 # ScanNet
sh scripts/train.sh -g 8 -d scannet -c pretrain-msc-v1m1-1-spunet-pointcontrast -n pretrain-msc-v1m1-1-spunet-pointcontrast
  1. Fonction de référence MSC.

Contextes de scène contrastives

  1. Ensemble de données de prétraitement et de paire scannet de liaison (référer PointCast):
  2. Pré-formation avec l'exemple suivant Scripts: 
 # ScanNet
sh scripts/train.sh -g 8 -d scannet -c pretrain-msc-v1m2-0-spunet-csc -n pretrain-msc-v1m2-0-spunet-csc
  1. Fonction de référence MSC.

Reconnaissance

Pointcept est conçu par Xiaoyang, nommé par Yixing et le logo est créé par Yuechen. Il est dérivé de Semseg de Hengshuang et inspiré par plusieurs reposs, par exemple, Minkowskiengine, PointNet2, MMCV et Detectron2.

Développer
Informations supplémentaires
Applications connexes
Recommandé pour vous
Actualités connexes Tout