Startseite>Programmierbezogen>Python
Herunterladen


AUFTECTECE ist eine leistungsstarke und flexible Codebasis für die Point Cloud -Wahrnehmungsforschung. Es ist auch eine offizielle Umsetzung des folgenden Papiers:

  • Punkttransformator V3: einfacher, schneller, stärker
    Xiaoyang Wu, Li Jiang, Peng-Shuai Wang, Zhijian Liu, Xihui Liu, Yu Qiao, Wanli Ouyang, Tong He, Hengshuang Zhao
    IEEE -Konferenz über Computer Vision und Mustererkennung ( CVPR ) 2024 - Orales
    [Backbone] [Ptv3] - [Arxiv] [BIB] [Projekt] → Hier

  • OA-CNNs: Omni-adaptive spärliche CNNs für die semantische 3D-Segmentierung
    Bohao Peng, Xiaoyang Wu, Li Jiang, Yukang Chen, Hengshuang Zhao, Zhuotao Tian, Jiaya Jia
    IEEE -Konferenz über Computer Vision und Mustererkennung ( CVPR ) 2024
    [Backbone] [OA -CNNs] - [Arxiv] [Bib] → Hier

  • In Richtung groß an
    Xiaoyang Wu, Zhuotao Tian, Xin Wen, Bohao Peng, Xihui Liu, Kaicheng Yu, Hengshuang Zhaoo
    IEEE -Konferenz über Computer Vision und Mustererkennung ( CVPR ) 2024
    [Pretrain] [PPT] - [Arxiv] [Bib] → Hier

  • Maskierte Szenenkontrast: Ein skalierbares Rahmen für unbeaufsichtigtes Lernen von 3D -Repräsentationen
    Xiaoyang Wu, Xin Wen, Xihui Liu, Hengshuang Zhao
    IEEE -Konferenz über Computer Vision und Mustererkennung ( CVPR ) 2023
    [Pretrain] [MSC] - [Arxiv] [Bib] → Hier

  • Lernkontext-bewusstes Klassifikator für die semantische Segmentierung (3D-Teil)
    Zhuotao Tian, Jiequan Cui, Li Jiang, Xiaojuan Qi, Xin Lai, Yixin Chen, Shu Liu, Jiaya Jia
    AAAI -Konferenz über künstliche Intelligenz ( AAAI ) 2023 - Orales
    [Semseg] [CAC] - [Arxiv] [BIB] [2D -Teil] → Hier

  • Punkttransformator V2: Gruppierte Aufmerksamkeit des Vektors und partitionsbasierte Pooling
    Xiaoyang Wu, Yixing Lao, Li Jiang, Xihui Liu, Hengshuang Zhao
    Konferenz über neuronale Informationsverarbeitungssysteme ( Neurips ) 2022
    [Backbone] [Ptv2] - [Arxiv] [Bib] → Hier

  • Punkttransformator
    Hengshuang Zhao, Li Jiang, Jiaya Jia, Philip Torr, Vladlen Koltun
    IEEE International Conference on Computer Vision ( ICCV ) 2021 - Orales
    [Backbone] [Ptv1] - [Arxiv] [Bib] → Hier

Darüber hinaus integriert Aspektce die folgenden hervorragenden Arbeiten (oben):
Backbone: Minkunet (hier), Spunet (hier), spvcnn (hier), oacnns (hier), ptv1 (hier), ptv2 (hier), ptv3 (hier), stratifyfformer (hier), Oktformer (hier), Swin3d (hier);
Semantische Segmentierung: Mix3d (hier), CAC (hier);
Instanzsegmentierung: Pointgroup (hier);
Pre-Training: PointContrast (hier), kontrastive Szenenkontexte (hier), maskierter Szenenkontrast (hier), Point Prompt-Training (hier);
Datensätze: Scannet (hier), scannet200 (hier), scannet ++ (hier), s3dis (hier), matterport3d (hier), Arkitscene, structured3d (hier), semantickitti (hier), nuscene (hier), modellnet40 (hier), Waymo (hier).

Highlights

  • Mai 2024 : In v1.5.2 haben wir die Standardstruktur für jeden Datensatz für eine bessere Leistung neu gestaltet. Bitte bearbeiten Sie Datensätze erneut oder laden Sie unsere vorverarbeiteten Datensätze von hier herunter.
  • April 2024 : PTV3 wird von CVPR'24 als einer der 90 Oralpapiere (3,3% akzeptierte Papiere, 0,78% Einreichungen) ausgewählt!
  • März 2024 : Wir veröffentlichen Code für OA-CNNs , akzeptiert von CVPR'24. Problem im Zusammenhang mit OA-CNNS CAN @PBIHAO.
  • Februar 2024 : PTV3 und PPT werden von CVPR'24 akzeptiert. Weitere zwei Papiere von unserem Opferteam wurden auch von CVPR'24 akzeptiert ???. Wir werden sie bald öffentlich verfügbar machen!
  • Dezember 2023 : PTV3 wird auf ARXIV veröffentlicht und der Code ist in Abruftlauf verfügbar. PTV3 ist ein effizientes Rückgrat -Modell, das SOTA -Auftritte in den Szenarien in Innen- und Außenbereichen erzielt.
  • August 2023 : PPT wird auf Arxiv veröffentlicht. PPT präsentiert ein Multi-Dataset-Vorbildungsgerüst, das sowohl in Szenarien im Innen- als auch in der Außenseite die SOTA-Leistung erzielt. Es ist mit verschiedenen vorhandenen Frameworks und Backbones vor dem Training kompatibel. Eine Pre- Veröffentlichungsversion des Codes ist zugänglich. Für Interessierte können Sie mich gerne direkt zum Zugang kontaktieren.
  • März 2023 : Wir haben unsere Codebasis, Opfer , ein hochpotiertes Tool für das Lernen und die Wahrnehmung von Point Cloud Repräsentation veröffentlicht. Wir begrüßen neue Arbeiten, um sich der Opfer -Familie anzuschließen, und empfehlen sehr, den schnellen Start zu lesen, bevor Sie Ihren Weg starten.
  • Februar 2023 : MSC und CECO, der von CVPR 2023 akzeptiert wird. Beide Ansätze sind mit allen vorhandenen Backbone -Modellen in unserer Codebasis kompatibel und wir werden den Code bald für die öffentliche Verwendung zur Verfügung stellen.
  • Jan. 2023 : CAC , mündliche Arbeit von AAAI 2023, hat sein 3D -Ergebnis mit der Einbeziehung des Sinns erweitert. Mit diesem Zusatz dienen CAC als Steckbetriebssegmentor in unserer Codebasis.
  • Sep, 2022 : PTV2 von Neurips 2022 akzeptiert. Es ist eine Fortsetzung des Punkttransformators. Die vorgeschlagene GVA -Theorie kann für die meisten bestehenden Aufmerksamkeitsmechanismen gelten, während das Pooling von Grid auch eine praktische Ergänzung für bestehende Pooling -Methoden ist.

Zitat

Wenn Sie sich für Ihre Forschung nützlich finden, geben Sie unsere Arbeit als Ermutigung an. (੭ˊ꒳ˋ) ੭✧ 

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

Überblick

  • Installation
  • Datenvorbereitung
  • Schneller Start
  • Modellzoo
  • Zitat
  • Anerkennung

Installation

Anforderungen

  • Ubuntu: 18.04 und höher.
  • CUDA: 11,3 und höher.
  • Pytorch: 1.10.0 und höher.

Conda -Umgebung 

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

Datenvorbereitung

Scannet v2

Die Vorverarbeitung unterstützt die Semantik- und Instanzsegmentierung sowohl für ScanNet20 , ScanNet200 und ScanNet Data Efficient .

  • Laden Sie den Scannet V2 -Datensatz herunter.

  • Führen Sie den Vorverarbeitungscode für RAW Scannet wie folgt aus: 

     # 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}

  • (Optional) Download Scannet Data Eeffiziente Dateien: 

     # 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) Unsere Vorverarbeitungsdaten können direkt [hier] heruntergeladen werden, bitte stimmen Sie der offiziellen Lizenz zu, bevor Sie sie herunterladen.

  • Link verarbeiteten Datensatz mit Codebasis: 

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

Scannet ++

  • Laden Sie den Scannet ++ Dataset herunter.
  • Führen Sie den Vorverarbeitungscode für RAW Scannet ++ wie folgt aus: 
     # 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}
  • Probenahme und Chunking große Punktwolkendaten in Zug/VAL -Split wie folgt (nur zum Training verwendet): 
     # 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) Unsere Vorverarbeitungsdaten können direkt [hier] heruntergeladen werden, bitte stimmen Sie der offiziellen Lizenz zu, bevor Sie sie herunterladen.
  • Link verarbeiteten Datensatz mit Codebasis: 
     # PROCESSED_SCANNETPP_DIR: the directory of the processed ScanNet dataset.
mkdir data
ln -s ${PROCESSED_SCANNETPP_DIR} ${CODEBASE_DIR} /data/scannetpp

S3dis

  • Laden Sie S3DIS -Daten herunter, indem Sie dieses Google -Formular ausfüllen. Laden Sie die Stanford3dDataset_v1.2.zip -Datei herunter und entpacken Sie sie.

  • Fehler in Area_5/office_19/Annotations/ceiling 323474 (103,0 0000 => 103.000000).

  • (Optional) Download Full 2D-3D S3DIS-Datensatz (NO XYZ) von hier zum Parsen normal.

  • Führen Sie den Vorverarbeitungscode für S3DIS wie folgt aus: 

     # 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) Unsere Vorverarbeitungsdaten können auch [hier] heruntergeladen werden (mit normalem Vektor und ausgerichtetem Winkel), bitte stimmen Sie der offiziellen Lizenz zu, bevor Sie sie herunterladen.

  • Verknüpfen Sie den verarbeiteten Datensatz mit Codebase. 

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

Strukturiert3d

  • Laden Sie Structured3D Panorama im Zusammenhang mit und perspektivischen (vollständigen) ZIP -Dateien herunter, indem Sie dieses Google -Formular ausfüllen (nicht erforderlich, um sie zu entpacken).
  • Organisieren Sie alle heruntergeladenen ZIP -Datei in einem Ordner ( ${STRUCT3D_DIR} ).
  • Führen Sie den Vorverarbeitungscode für structured3D wie folgt aus: 
     # 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

Nach der Anweisung von SWIN3D führen wir 25 Kategorien mit Frequenzen von mehr als 0,001 aus den ursprünglichen 40 Kategorien.

  • (Alternative) Unsere Vorverarbeitungsdaten können auch [hier] heruntergeladen werden (mit perspektivischen Ansichten und Panorama -Ansicht, 471,7 g nach der Entpackung), stimmen Sie bitte der offiziellen Lizenz zu, bevor Sie sie herunterladen.

  • Verknüpfen Sie den verarbeiteten Datensatz mit Codebase. 

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

Matterport3d

  • Folgen Sie dieser Seite, um den Zugriff auf den Datensatz anzufordern.
  • Laden Sie den Typ "Region_segmentation" herunter, der die Aufteilung einer Szene in einzelne Räume darstellt. 
     # 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
  • Entpacken Sie die Daten der Region_Segmentations -Daten 
     # MATTERPORT3D_DIR: the directory of downloaded Matterport3D dataset.
python pointcept/datasets/preprocessing/matterport3d/unzip_matterport3d_region_segmentation.py --dataset_root {MATTERPORT3D_DIR}
  • Führen Sie den Vorverarbeitungscode für matterport3d wie folgt aus: 
     # 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}
  • Verknüpfen Sie den verarbeiteten Datensatz mit Codebase. 
     # PROCESSED_MATTERPORT3D_DIR: the directory of processed Matterport3D dataset (output dir).
mkdir data
ln -s ${PROCESSED_MATTERPORT3D_DIR} ${CODEBASE_DIR} /data/matterport3d

Nach der Anweisung der offenen Räume haben wir die Kategorien von MatterPort3D mit der Hinzufügung einer Deckenkategorie in die Kategorie 20 semantische Kategorien umgestellt.

  • (Alternative) Unsere Vorverarbeitungsdaten können auch hier heruntergeladen werden. Bitte stimmen Sie der offiziellen Lizenz zu, bevor Sie sie herunterladen.

Semantickitti

  • Laden Sie den Semantickitti -Datensatz herunter.
  • Link Dataset mit Codebasis verlinken. 
     # 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

Nuscene

  • Laden Sie den offiziellen Nuscene -Datensatz (mit LIDAR -Segmentierung) herunter und organisieren Sie die heruntergeladenen Dateien wie folgt: 

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

  • Führen Sie den Informationsvorverarbeitungscode (von OpenPCDET geändert) für NuScene wie folgt aus: 

     # 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) Unsere Informationsdaten für den Vorprozess NuScenes können ebenfalls [hier] heruntergeladen werden (nur verarbeitete Informationen, müssen weiterhin den RAW -Datensatz herunterladen und zum Ordner verlinken). Bitte stimmen Sie der offiziellen Lizenz zu, bevor Sie sie herunterladen.

  • Link RAW -Datensatz mit dem verarbeiteten Nuscen -Datensatzordner: 

     # 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

    Dann ist der verarbeitete Nuscenes -Ordner wie folgt organisiert: 

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

  • Verknüpfen Sie den verarbeiteten Datensatz mit Codebase. 

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

Waymo

  • Laden Sie den offiziellen Waymo -Datensatz (v1.4.3) herunter und organisieren Sie die heruntergeladenen Dateien wie folgt: 

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

  • Installieren Sie die folgende Abhängigkeit: 

     # 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

  • Führen Sie den Vorverarbeitungscode wie folgt aus: 

     # 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}

  • Verknüpfen Sie den verarbeiteten Datensatz mit der Codebasis. 

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

Modellnet

  • Download modelNet40_normal_ressampled.zip und Unzip
  • Verknüpfen Sie den Datensatz mit der Codebasis. 
    mkdir -p data
ln -s ${MODELNET_DIR} ${CODEBASE_DIR} /data/modelnet40_normal_resampled

Schneller Start

Ausbildung

Zug von Grund auf. Die Trainingsverarbeitung basiert auf Konfigurationen im configs . Das Trainingsskript generiert einen Experiment -Ordner im exp -Ordner und im experimentellen Ordner. Trainingskonfiguration, Protokoll, Tensorboard und Kontrollpunkte werden während des Trainingsprozesses auch in den Experiment -Ordner gespeichert. 

 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}

Zum Beispiel: 

 # 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

Schulung vom Checkpoint wieder aufnehmen. Wenn der Schulungsprozess durch Zufall unterbrochen wird, kann das folgende Skript das Training von einem bestimmten Kontrollpunkt aus fortsetzen. 

 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}

Testen

Während des Trainings wird die Modellbewertung nach der Gitterprobenahme (Voxelisierung) in Punktwolken durchgeführt, wodurch eine anfängliche Bewertung der Modellleistung erfolgt. Um genaue Bewertungsergebnisse zu erzielen, ist die Prüfung jedoch unerlässlich . Der Testprozess beinhaltet die Unterabtastung einer dichten Punktwolke in eine Sequenz voxelisierter Punktwolken, um eine umfassende Abdeckung aller Punkte zu gewährleisten. Diese Unterregelte werden dann vorhergesagt und gesammelt, um eine vollständige Vorhersage der gesamten Punktwolke zu bilden. Dieser Ansatz liefert eine höhere Bewertungsergebnisse im Vergleich zur einfachen Kartierung/Interpolation der Vorhersage. Darüber hinaus unterstützt unser Testcode TTA -Tests (Testzeit Augmentation), was die Stabilität der Bewertungsleistung weiter verbessert. 

 # 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}

Zum Beispiel: 

 # 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

Der TTA kann durch Ersetzen von data.test.test_cfg.aug_transform = [...] mit: 

 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 )]
            ]
        )
    )
)

Offset

Offset ist das Trennzeichen von Punktwolken in Stapeldaten und ähnelt dem Konzept der Batch in Pyg. Eine visuelle Illustration von Charge und Offset ist wie folgt:


Modellzoo

1. Rückgrat und semantische Segmentierung

Spärlich

AUFTECEPTE liefert SparseUNet das von SpConv und MinkowskiEngine implementiert wird. Die SPCONV -Version wird empfohlen, da SPCONV einfach zu installieren und schneller als Minkowskiengine ist. In der Zwischenzeit ist SPCONV auch in der Wahrnehmung im Freien weit verbreitet.

  • SPCONV (empfehlen)

Das SparseUNet der SPCONV -Version in der Codebase wurde vollständig von MinkowskiEngine -Version neu geschrieben. 

 # 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
  • Minkowskiengine

Das SparseUNet der Minkowskiengine -Version in der Codebasis wurde aus dem ursprünglichen Minkowskiengine -Repo geändert, und Beispiele laufen wie folgt:

  1. Installieren Sie Minkowskiengine, siehe https://github.com/nvidia/Minkowskiengine
  2. Training mit den folgenden Beispielskripten: 
 # 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

Einführung von Omni-adaptive 3D-CNNs ( OA-CNNs ), einer Familie von Netzwerken, die ein leichtes Modul integriert, um die Anpassung von spärlichen CNNs bei minimalen Rechenkosten erheblich zu verbessern. Ohne Selbstbekämpfungsmodule übertreffen OA-CNNs den Punkttransformatoren in Bezug auf die Genauigkeit sowohl in Innen- als auch in Außenszenen mit viel weniger Latenz- und Speicherkosten. Problem im Zusammenhang mit OA-CNNS CAN @PBIHAO. 

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

Punkttransformatoren

  • PTV3

PTV3 ist ein effizientes Rückgrat -Modell, das SOTA -Auftritte in den Szenarien in Innen- und Außenbereichen erzielt. Der vollständige PTV3 basiert auf Flashattention, während Flashattention auf CUDA 11.6 und höher beruht. Stellen Sie sicher, dass Ihre lokale Gesichtsumgebung die Anforderungen erfüllt.

Wenn Sie Ihre lokale Umgebung nicht aktualisieren können, um die Anforderungen zu erfüllen (CUDA> = 11.6), können Sie Flashattention deaktivieren, indem Sie den Modellparameter enable_flash auf false und die Verringerung der enc_patch_size und dec_patch_size auf eine Ebene (z. B. 128) einstellen.

Flashattention Force deaktiviert RPE und zwingt die auf FP16 reduzierte Genauigkeit. Wenn Sie diese Funktionen benötigen, deaktivieren Sie enable_flash und adören Sie enable_rpe , upcast_attention und upcast_softmax .

In dem Projektrepository finden Sie detaillierte Anweisungen und Experimentdatensätze (enthaltende Gewichte). Beispiel, das Skripte läuft, lauten wie folgt: 

 # 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.

Semantische Innen- und Segmentierung

Modell Benchmark Zusätzliche Daten Num gpus Val Miou Konfiguration Tensorboard Exp -Rekord
PTV3 Scannet ✗ 4 77,6% Link Link Link
Ptv3 + ppt Scannet ✓ 8 78,5% Link Link Link
PTV3 Scannet200 ✗ 4 35,3% Link Link Link
Ptv3 + ppt Scannet200 ✓ (ft) 4
PTV3 S3DIS (Bereich5) ✗ 4 73,6% Link Link Link
Ptv3 + ppt S3DIS (Bereich5) ✓ 8 75,4% Link Link Link

Semantische Segmentierung im Freien

Modell Benchmark Zusätzliche Daten Num gpus Val Miou Konfiguration Tensorboard Exp -Rekord
PTV3 Nuscene ✗ 4 80.3 Link Link Link
Ptv3 + ppt Nuscene ✓ 8
PTV3 Semantickitti ✗ 4
Ptv3 + ppt Semantickitti ✓ 8
PTV3 Waymo ✗ 4 71.2 Link Link Link (nur Protokoll)
Ptv3 + ppt Waymo ✓ 8

*Freigegebene Modellgewichte werden für v1.5.1 trainiert, Gewichte für v1.5.2 und später noch nicht abgeschlossen.

  • PTV2 -Modus2

Der ursprüngliche PTV2 wurde auf 4 * RTX A6000 (48 g Speicher) trainiert. Sogar die Verstärkung aktiviert, sind die Speicherkosten des ursprünglichen PTV2 etwas größer als 24 g. Wenn man bedenkt, dass GPUs mit 24G -Speicher viel zugänglicher sind, habe ich den PTV2 auf dem neuesten Sinn abgestimmt und es auf 4 * RTX 3090 -Maschinen läuft.

PTv2 Mode2 ermöglicht AMP und deaktiviert die Position Codierungsmultiplikatorin und gruppierte Linear . Während unserer weiteren Untersuchungen haben wir festgestellt, dass genaue Koordinaten für das Verständnis von Punktwolken nicht erforderlich sind (das Ersetzen präziser Koordinaten durch Gitterkoordinaten hat keinen Einfluss auf die Leistung. Außerdem ist Sparseunet ein Beispiel). Bei gruppierter Linear scheint meine Implementierung von gruppierter Linear mehr Speicher zu kosten als die von Pytorch bereitgestellte lineare Schicht. Wir profitieren von der Codebasis und einer besseren Parameterabstimmung und lindern auch das Überanpassungsproblem. Die Reproduktionsleistung ist sogar noch besser als die in unserem Artikel angegebenen Ergebnisse.

Beispiel, das Skripte läuft, lauten wie folgt: 

 # 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
  • PTV2 -Modus1

PTv2 mode1 ist das ursprüngliche PTV2, das wir in unserem Papier gemeldet haben. Beispielsweise lauten die Skripte wie folgt: 

 # 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

Der ursprüngliche PTV1 ist auch in unserer Opfer -Codebasis erhältlich. Ich habe PTV1 schon lange nicht mehr ausgeführt, aber ich habe sichergestellt, dass das Beispiel -Skript gut funktioniert. 

 # 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

Geschichteter Transformator

  1. Zusätzliche Anforderungen: 
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. Überzeugung # from .stratified_transformer import * in pointcept/models/__init__.py .
  2. Siehe optionale Installation, um die Abhängigkeit zu installieren.
  3. Training mit den folgenden Beispielskripten: 
 # 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 ist ein Basismodell von SPVNAs, es ist auch eine praktische Grundlinie für Außendatensätze.

  1. TRAINEN Sie 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. Training mit den folgenden Beispielskripten: 
 # SemanticKITTI
sh scripts/train.sh -g 2 -d semantic_kitti -c semseg-spvcnn-v1m1-0-base -n semseg-spvcnn-v1m1-0-base

Oktformer

Octformer von Octformer: Octree-basierte Transformatoren für 3D-Punktwolken .

  1. Zusätzliche Anforderungen: 
 cd libs
git clone https://github.com/octree-nn/dwconv.git
pip install ./dwconv
pip install ocnn
  1. KONTRIMENT # from .octformer import * in pointcept/models/__init__.py .
  2. Training mit den folgenden Beispielskripten: 
 # ScanNet
sh scripts/train.sh -g 4 -d scannet -c semseg-octformer-v1m1-0-base -n semseg-octformer-v1m1-0-base

Swin3d

SWIN3D von Swin3D: Ein vorbereiteter Transformator -Rückgrat für das Verständnis der 3D -Innenszene .

  1. Zusätzliche Anforderungen: 
 # 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. Überzeugung # from .swin3d import * in pointcept/models/__init__.py .
  2. Vorausbildung mit den folgenden Beispiel-Skripten (structured3D-Vorverarbeitung finden Sie hier): 
 # 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. Feinabstimmung mit den folgenden Beispielskripten: 
 # 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

Kontextbewusster Klassifikator

Context-Aware Classifier ist ein Segmentor, der die Leistung jedes Rückgrats als Ersatz für Default Segmentor weiter steigern kann. Training mit den folgenden Beispielskripten: 

 # 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. Instanzsegmentierung

Pointgroup

Pointgroup ist ein Basisrahmen für die Segmentierung der Punkt -Cloud -Instanz.

  1. Zusätzliche Anforderungen: 
conda install -c bioconda google-sparsehash 
cd libs/pointgroup_ops
python setup.py install --include_dirs= ${CONDA_PREFIX} /include
cd ../..
  1. Überzeugung # from .point_group import * in pointcept/models/__init__.py .
  2. Training mit den folgenden Beispielskripten: 
 # 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.. Vorausbildung

Maskierter Szenenkontrast (MSC)

  1. Vorausbildung mit den folgenden Beispielskripten: 
 # ScanNet
sh scripts/train.sh -g 8 -d scannet -c pretrain-msc-v1m1-0-spunet-base -n pretrain-msc-v1m1-0-spunet-base
  1. Feinabstimmung mit den folgenden Beispielskripten:
    Aktivieren Sie die Pointgroup (hier), bevor Sie die Instanzsegmentierungsaufgabe Feinabstimmung befinden. 
 # 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. Beispiellog und Gewicht: [Pretrain] [Semseg]

PUNKTUM -Eingabeaufforderung (PPT)

PPT präsentiert ein Multi-Dataset-Framework vor dem Training und ist mit verschiedenen vorhandenen vorhandenen Frameworks und Rückgratern kompatibel.

  1. PPT beaufsichtigte gemeinsames Training mit den folgenden Beispielskripten: 
 # 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

Pointcontrast

  1. Preprozess- und Link-Scannet-Pair-Datensatz (paarige Übereinstimmung mit dem scannet rohen RGB-D-Rahmen, ~ 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. Vorausbildung mit den folgenden Beispielskripten: 
 # ScanNet
sh scripts/train.sh -g 8 -d scannet -c pretrain-msc-v1m1-1-spunet-pointcontrast -n pretrain-msc-v1m1-1-spunet-pointcontrast
  1. Feinabstimmung beziehen sich auf msc.

Kontrastive Szenenkontexte

  1. Vorverarbeitungs- und Link-Scannet-Pair-Datensatz (siehe PointContrast):
  2. Vorausbildung mit den folgenden Beispielskripten: 
 # ScanNet
sh scripts/train.sh -g 8 -d scannet -c pretrain-msc-v1m2-0-spunet-csc -n pretrain-msc-v1m2-0-spunet-csc
  1. Feinabstimmung beziehen sich auf msc.

Anerkennung

Abrufen wird von Xiaoyang entworfen, das von Yixing benannt ist und das Logo von YuECHEN erstellt wird. Es stammt aus Hengshuangs Semseg und inspiriert von mehreren Repos, z.

Expandieren
Zusätzliche Informationen
Ähnliche Anwendungen
Empfohlen für Sie
Ähnliche Nachrichten Alle