MinkowskiEngine
v0.5.4
Der Minkowski-Motor ist eine Auto-Differenzierungsbibliothek für spärliche Tensoren. Es unterstützt alle Standardschichten für neuronale Netzwerke wie Faltung, Pooling, Unpooling und Rundfunkbetrieb für spärliche Tensoren. Weitere Informationen finden Sie auf der Dokumentationsseite.
Der Minkowski -Motor unterstützt verschiedene Funktionen, die auf einem spärlichen Tensor aufgebaut werden können. Wir listen hier einige beliebte Netzwerkarchitekturen und -anwendungen auf. Um die Beispiele auszuführen, installieren Sie das Paket und führen Sie den Befehl im Paket -Root -Verzeichnis aus.
| Beispiele | Netzwerke und Befehle |
|---|---|
| Semantische Segmentierung | python -m examples.indoor |
| Einstufung | python -m examples.classification_modelnet40 |
| Wiederaufbau | python -m examples.reconstruction |
| Fertigstellung | python -m examples.completion |
| Erkennung |
Die Komprimierung eines neuronalen Netzwerks zur Beschleunigung der Inferenz und zur Minimierung des Speicherpflichtzustels wurde weitgehend untersucht. Eine der beliebten Techniken für die Modellkomprimierung ist die Beschneidung der Gewichte in Überzeugung und ist auch als spärliche Faltungsnetzwerke bekannt. Eine solche für Modellkomprimierungskomprimierungen verwendete Parameter-Raum-Sparsität, die auf dichten Tensoren und allen Zwischenaktivierungen dieser Netzwerke arbeiten, sind ebenfalls dichte Tensoren.
In dieser Arbeit konzentrieren wir uns jedoch auf räumlich spärliche Daten, insbesondere auf räumlich spärliche hochdimensionale Eingänge und 3D-Daten und Faltung auf der Oberfläche von 3D-Objekten, die zunächst in Siggraph'17 vorgeschlagen wurden. Wir können diese Daten auch als spärliche Tensoren darstellen, und diese spärlichen Tensoren sind in hochdimensionalen Problemen wie 3D-Wahrnehmung, Registrierung und statistischen Daten alltäglich. Wir definieren neuronale Netze, die auf diese Eingaben als spärliche Tensor -Netzwerke spezialisiert sind und diese spärlichen Tensor -Netzwerke verarbeiten und spärlich Tensoren als Ausgaben erzeugen. Um ein spärliches Tensor-Netzwerk zu errichten, bauen wir alle Standard-Netzwerkschichten wie MLPs, Nichtlinearitäten, Faltung, Normalisierungen, den Pooling-Vorgänge auf, wie wir sie auf einem dichten Tensor definieren und in der Minkowski-Engine implementiert werden.
Wir haben einen spärlichen Tensor -Netzwerkbetrieb auf einem spärlichen Tensor, Faltungsverhältnis, dargestellt. Die Faltungsschicht eines spärlichen Tensors funktioniert ähnlich wie bei einem dichten Tensor. Bei einem spärlichen Tensor berechnen wir jedoch die Faltungsausgaben an einigen bestimmten Punkten, die wir in der verallgemeinerten Faltung kontrollieren können. Weitere Informationen finden Sie auf der Seite "Dokumentation" zu spärlichen Tensor -Netzwerken und der Terminologieseite.
| Dichter Tensor | Spärlicher Tensor |
|---|---|
conda install -y -c nvidia -c pytorch pytorch=1.8.1 cudatoolkit=10.2 ) Sie können den Minkowski -Motor mit pip , Anaconda oder direkt auf dem System installieren. Wenn Sie Probleme beim Installieren des Pakets haben, lesen Sie bitte die Seite der Installation Wiki. Wenn Sie kein relevantes Problem finden, melden Sie das Problem auf der GitHub -Ausgabeseite.
Die Minkowskiengine wird über pypi minkowskiengine verteilt, die einfach mit pip installiert werden können. Installieren Sie zuerst Pytorch nach der Anweisung. Installieren Sie als Nächstes openblas .
sudo apt install build-essential python3-dev libopenblas-dev
pip install torch ninja
pip install -U MinkowskiEngine --install-option="--blas=openblas" -v --no-deps
# For pip installation from the latest source
# pip install -U git+https://github.com/NVIDIA/MinkowskiEngine --no-deps
Wenn Sie Argumente für das Setup -Skript angeben möchten, lesen Sie bitte den folgenden Befehl.
# Uncomment some options if things don't work
# export CXX=c++; # set this if you want to use a different C++ compiler
# export CUDA_HOME=/usr/local/cuda-11.1; # or select the correct cuda version on your system.
pip install -U git+https://github.com/NVIDIA/MinkowskiEngine -v --no-deps
# # uncomment the following line if you want to force cuda installation
# --install-option="--force_cuda"
# # uncomment the following line if you want to force no cuda installation. force_cuda supercedes cpu_only
# --install-option="--cpu_only"
# # uncomment the following line to override to openblas, atlas, mkl, blas
# --install-option="--blas=openblas"
Minkowskiengine unterstützt sowohl CUDA 10.2 als auch CUDA 11.1, die für die meisten neuesten Pytorch -Versionen funktionieren.
Wir empfehlen python>=3.6 für die Installation. Folgen Sie zunächst der Anaconda -Dokumentation, um Anaconda auf Ihrem Computer zu installieren.
sudo apt install g++-7 # For CUDA 10.2, must use GCC < 8
# Make sure `g++-7 --version` is at least 7.4.0
conda create -n py3-mink python=3.8
conda activate py3-mink
conda install openblas-devel -c anaconda
conda install pytorch=1.9.0 torchvision cudatoolkit=10.2 -c pytorch -c nvidia
# Install MinkowskiEngine
export CXX=g++-7
# Uncomment the following line to specify the cuda home. Make sure `$CUDA_HOME/nvcc --version` is 10.2
# export CUDA_HOME=/usr/local/cuda-10.2
pip install -U git+https://github.com/NVIDIA/MinkowskiEngine -v --no-deps --install-option="--blas_include_dirs=${CONDA_PREFIX}/include" --install-option="--blas=openblas"
# Or if you want local MinkowskiEngine
git clone https://github.com/NVIDIA/MinkowskiEngine.git
cd MinkowskiEngine
export CXX=g++-7
python setup.py install --blas_include_dirs=${CONDA_PREFIX}/include --blas=openblas
Wir empfehlen python>=3.6 für die Installation. Folgen Sie zunächst der Anaconda -Dokumentation, um Anaconda auf Ihrem Computer zu installieren.
conda create -n py3-mink python=3.8
conda activate py3-mink
conda install openblas-devel -c anaconda
conda install pytorch=1.9.0 torchvision cudatoolkit=11.1 -c pytorch -c nvidia
# Install MinkowskiEngine
# Uncomment the following line to specify the cuda home. Make sure `$CUDA_HOME/nvcc --version` is 11.X
# export CUDA_HOME=/usr/local/cuda-11.1
pip install -U git+https://github.com/NVIDIA/MinkowskiEngine -v --no-deps --install-option="--blas_include_dirs=${CONDA_PREFIX}/include" --install-option="--blas=openblas"
# Or if you want local MinkowskiEngine
git clone https://github.com/NVIDIA/MinkowskiEngine.git
cd MinkowskiEngine
python setup.py install --blas_include_dirs=${CONDA_PREFIX}/include --blas=openblas
Stellen Sie wie die Anaconda -Installation sicher, dass Sie Pytorch mit derselben CUDA -Version installieren, die nvcc verwendet.
# install system requirements
sudo apt install build-essential python3-dev libopenblas-dev
# Skip if you already have pip installed on your python3
curl https://bootstrap.pypa.io/get-pip.py | python3
# Get pip and install python requirements
python3 -m pip install torch numpy ninja
git clone https://github.com/NVIDIA/MinkowskiEngine.git
cd MinkowskiEngine
python setup.py install
# To specify blas, CXX, CUDA_HOME and force CUDA installation, use the following command
# export CXX=c++; export CUDA_HOME=/usr/local/cuda-11.1; python setup.py install --blas=openblas --force_cuda
git clone https://github.com/NVIDIA/MinkowskiEngine
cd MinkowskiEngine
docker build -t minkowski_engine docker
Sobald der Docker erstellt wurde, überprüfen Sie die minkowskiengine korrekt.
docker run MinkowskiEngine python3 -c "import MinkowskiEngine; print(MinkowskiEngine.__version__)"
Die Minkowski -Engine unterstützt CPU nur auf anderen Plattformen mit Nvidia -GPUs. Weitere Informationen finden Sie im Quick Start.
Um den Minkowski -Motor zu verwenden, müssten Sie zuerst den Motor importieren. Dann müssten Sie das Netzwerk definieren. Wenn die Daten, die Sie haben, nicht quantisiert werden, müssen Sie die (räumlichen) Daten in einen spärlichen Tensor voxelisieren oder quantisieren. Glücklicherweise liefert die Minkowski -Engine die Quantisierungsfunktion ( MinkowskiEngine.utils.sparse_quantize ).
import torch . nn as nn
import MinkowskiEngine as ME
class ExampleNetwork ( ME . MinkowskiNetwork ):
def __init__ ( self , in_feat , out_feat , D ):
super ( ExampleNetwork , self ). __init__ ( D )
self . conv1 = nn . Sequential (
ME . MinkowskiConvolution (
in_channels = in_feat ,
out_channels = 64 ,
kernel_size = 3 ,
stride = 2 ,
dilation = 1 ,
bias = False ,
dimension = D ),
ME . MinkowskiBatchNorm ( 64 ),
ME . MinkowskiReLU ())
self . conv2 = nn . Sequential (
ME . MinkowskiConvolution (
in_channels = 64 ,
out_channels = 128 ,
kernel_size = 3 ,
stride = 2 ,
dimension = D ),
ME . MinkowskiBatchNorm ( 128 ),
ME . MinkowskiReLU ())
self . pooling = ME . MinkowskiGlobalPooling ()
self . linear = ME . MinkowskiLinear ( 128 , out_feat )
def forward ( self , x ):
out = self . conv1 ( x )
out = self . conv2 ( out )
out = self . pooling ( out )
return self . linear ( out ) # loss and network
criterion = nn . CrossEntropyLoss ()
net = ExampleNetwork ( in_feat = 3 , out_feat = 5 , D = 2 )
print ( net )
# a data loader must return a tuple of coords, features, and labels.
coords , feat , label = data_loader ()
input = ME . SparseTensor ( feat , coordinates = coords )
# Forward
output = net ( input )
# Loss
loss = criterion ( output . F , label ) Für Diskussion und Fragen verwenden Sie bitte [email protected] . Für die API und allgemeine Verwendung finden Sie auf der Minkowskiengine -Dokumentationsseite weitere Details.
Für Probleme, die nicht in den API- und Feature -Anfragen aufgeführt sind, können Sie ein Problem auf der GitHub -Problemseite einreichen.
In einigen Fällen müssen Sie explizit angeben, welche Berechnung Ihrer GPU verwendet werden. Die Standardliste enthält möglicherweise nicht Ihre Architektur.
export TORCH_CUDA_ARCH_LIST= " 5.2 6.0 6.1 7.0 7.5 8.0 8.6+PTX " ; python setup.py install --force_cudaEs gibt ein bekanntes Problem im Schub mit CUDA 10, das zu einer ungehandelten Schubausnahme führt. Weitere Details finden Sie in der Ausgabe.
Es gibt einige Ursachen für diesen Fehler.
Minkowskiengine ist eine spezielle Bibliothek, die bei jeder Iteration während des Trainings eine unterschiedliche Anzahl von Punkten oder eine unterschiedliche Anzahl von Elementen ungleich Null verarbeiten kann. Pytorch wird jedoch implementiert, sofern sich die Anzahl der Punkte oder die Größe der Aktivierungen bei jeder Iteration nicht ändert. Daher kann das von Pytorch verwendete GPU -Speicher -Caching zu unnötig großen Speicherverbrauch führen.
Insbesondere schneidet Pytorch Stücke von Speicherräumen aus, um die Zuordnung zu beschleunigen, die bei jeder Tensorerstellung verwendet wird. Wenn es den Speicherraum nicht findet, teilt es einen vorhandenen Speicher vorhandenen Speicher oder einen neuen Speicherplatz auf, wenn kein Zwischenspeicher für die angeforderte Größe groß genug ist. Jedes Mal, wenn wir eine unterschiedliche Anzahl von Punkten (Anzahl der Elemente ungleich Null) mit Pytorch verwenden, trennte es entweder vorhandenen Cache oder reserviert einen neuen Speicher. Wenn der Cache zu fragmentiert ist und den gesamten GPU -Speicherplatz zugewiesen hat, erhöht er den Speicherfehler.
Um dies zu verhindern, müssen Sie den Cache in regelmäßiger Abstimmung mit torch.cuda.empty_cache() löschen.
wget https://developer.download.nvidia.com/compute/cuda/11.1.1/local_installers/cuda_11.1.1_455.32.00_linux.run
sudo sh cuda_11.1.1_455.32.00_linux.run --toolkit --silent --override
# Install MinkowskiEngine with CUDA 11.1
export CUDA_HOME=/usr/local/cuda-11.1; pip install MinkowskiEngine -v --no-deps
Die Minkowskiengine verwendet OpenMP, um die Kernel -Map -Generierung parallel zu verändern. Wenn jedoch die Anzahl der für die Parallelisierung verwendeten Threads zu groß ist (z. B. omp_num_threads = 80), fällt die Effizienz schnell ab, da alle Threads einfach darauf warten, dass Multithread -Sperren freigegeben werden. Setzen Sie in solchen Fällen die Anzahl der für OpenMP verwendeten Threads. Normalerweise wäre eine beliebige Zahl unter 24 in Ordnung, aber die Suche nach dem optimalen Setup in Ihrem System.
export OMP_NUM_THREADS=<number of threads to use>; python <your_program.py>
Wenn Sie den Minkowski -Motor verwenden, zitieren Sie bitte:
@inproceedings{choy20194d,
title={4D Spatio-Temporal ConvNets: Minkowski Convolutional Neural Networks},
author={Choy, Christopher and Gwak, JunYoung and Savarese, Silvio},
booktitle={Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition},
pages={3075--3084},
year={2019}
}
Für die Erzeugung von Kernel-Kern-Kern-Kern-Kernkarten zitieren Sie bitte:
@inproceedings{choy2019fully,
title={Fully Convolutional Geometric Features},
author={Choy, Christopher and Park, Jaesik and Koltun, Vladlen},
booktitle={Proceedings of the IEEE International Conference on Computer Vision},
pages={8958--8966},
year={2019}
}
Für überstiegende Beschäftigungsschichten für hochdimensionale Konvolutionen zitieren Sie bitte:
@inproceedings{choy2020high,
title={High-dimensional Convolutional Networks for Geometric Pattern Recognition},
author={Choy, Christopher and Lee, Junha and Ranftl, Rene and Park, Jaesik and Koltun, Vladlen},
booktitle={Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition},
year={2020}
}
Für generative transponierte Faltung zitieren Sie bitte:
@inproceedings{gwak2020gsdn,
title={Generative Sparse Detection Networks for 3D Single-shot Object Detection},
author={Gwak, JunYoung and Choy, Christopher B and Savarese, Silvio},
booktitle={European conference on computer vision},
year={2020}
}
Verwenden Sie für Unittests und GradCheck Torch> = 1,7
Bitte zögern Sie nicht, die Wiki -Seite zu aktualisieren, um Ihre Projekte hinzuzufügen!
Projekte mit Minkowskiengine
Segmentierung: 3D- und 4D-räumlich-zeitliche semantische Segmentierung, CVPR'19
Repräsentationslernen: Vollgeschneidende geometrische Merkmale, ICCV'19
3D -Registrierung: Lernen von Multiview 3D Point Cloud Registrierung, CVPR'20
3D -Registrierung: Deep Global Registration, CVPR'20
Mustererkennung: Hochdimensionale Faltungsnetzwerke für die geometrische Mustererkennung, CVPR'20
Erkennung: Generative Sparse Detection Networks für die Erkennung von Single-Shot-Objekten für 3D
Bildanpassung: spärliche Konsensnetzwerke in der Nachbarschaft, ECCV'20
