MinkowskiEngine
v0.5.4
Le moteur Minkowski est une bibliothèque de différenciation automatique pour les tenseurs clairsemés. Il prend en charge toutes les couches de réseau neuronal standard telles que les opérations de convolution, de mise en commun, de non-coffrage et de diffusion pour les tenseurs clairsemés. Pour plus d'informations, veuillez visiter la page de documentation.
Le moteur Minkowski prend en charge diverses fonctions qui peuvent être construites sur un tenseur clairsemé. Nous énumérons quelques architectures et applications de réseau populaires ici. Pour exécuter les exemples, veuillez installer le package et exécuter la commande dans le répertoire racine du package.
| Exemples | Réseaux et commandes |
|---|---|
| Segmentation sémantique | python -m examples.indoor |
| Classification | python -m examples.classification_modelnet40 |
| Reconstruction | python -m examples.reconstruction |
| Achèvement | python -m examples.completion |
| Détection |
La compression d'un réseau neuronal pour accélérer l'inférence et minimiser l'empreinte de la mémoire a été largement étudiée. L'une des techniques populaires pour la compression de modèle consiste à élaguer les poids dans les convaintes, est également connue sous le nom de réseaux convolutionnels clairsemés . Ces réseaux de compresses de compression de compression de compression de compression de paramètres qui fonctionnent sur des tenseurs denses et toutes les activations intermédiaires de ces réseaux sont également des tenseurs denses.
Cependant, dans ce travail, nous nous concentrons sur les données spatialement clairsemées, en particulier, des entrées de haute dimension spatialement clairsemées et des données 3D et une convolution à la surface des objets 3D, d'abord proposés dans Siggraph'17. Nous pouvons également représenter ces données comme des tenseurs clairsemés, et ces tenseurs clairsemés sont monnaie courante dans des problèmes de grande dimension tels que la perception 3D, l'enregistrement et les données statistiques. Nous définissons les réseaux de neurones spécialisés pour ces entrées comme des réseaux de tenseurs clairsemés et ces réseaux de tenseurs clairsemés et générons des tenseurs clairsemés comme sorties. Pour construire un réseau de tenseur clairsemé, nous construisons toutes les couches de réseau neuronal standard telles que les MLP, les non-linéarités, la convolution, les normalisations, les opérations de mise en commun de la même manière que nous les définissons sur un tenseur dense et mis en œuvre dans le moteur Minkowski.
Nous avons visualisé une opération de réseau de tenseur clairsemé sur un tenseur clairsemé, Convolution, ci-dessous. La couche de convolution sur un tenseur clairsemé fonctionne de manière similaire à celle sur un tenseur dense. Cependant, sur un tenseur clairsemé, nous calculons les sorties de convolution sur quelques points spécifiés que nous pouvons contrôler dans la convolution généralisée. Pour plus d'informations, veuillez visiter la page de documentation sur les réseaux de tenseur clairsemées et la page de terminologie.
| Tenseur dense | Tenseur clairsemé |
|---|---|
conda install -y -c nvidia -c pytorch pytorch=1.8.1 cudatoolkit=10.2 ) Vous pouvez installer le moteur Minkowski avec pip , avec Anaconda ou sur le système directement. Si vous rencontrez des problèmes d'installation du package, veuillez vérifier la page Wiki d'installation. Si vous ne trouvez pas de problème pertinent, veuillez signaler le problème sur la page du problème GitHub.
Le Minkowskienne est distribué via PYPI Minkowskienne qui peut être installé simplement avec pip . Tout d'abord, installez Pytorch après l'instruction. Ensuite, installez 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
Si vous souhaitez spécifier des arguments pour le script de configuration, veuillez vous référer à la commande suivante.
# 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"
Minkowskienne soutient à la fois Cuda 10.2 et Cuda 11.1, qui fonctionnent pour la plupart des dernières versions Pytorch.
Nous recommandons python>=3.6 pour l'installation. Tout d'abord, suivez la documentation Anaconda pour installer Anaconda sur votre ordinateur.
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
Nous recommandons python>=3.6 pour l'installation. Tout d'abord, suivez la documentation Anaconda pour installer Anaconda sur votre ordinateur.
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
Comme l'installation d'Anaconda, assurez-vous d'installer Pytorch avec la même version CUDA que nvcc utilise.
# 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
Une fois le docker construit, vérifiez qu'il charge correctement Minkowskienne.
docker run MinkowskiEngine python3 -c "import MinkowskiEngine; print(MinkowskiEngine.__version__)"
Le moteur Minkowski prend en charge le CPU uniquement sur d'autres plates-formes qui n'ont pas de GPU NVIDIA. Veuillez vous référer au démarrage rapide pour plus de détails.
Pour utiliser le moteur Minkowski, vous devrez d'abord importer le moteur. Ensuite, vous devrez définir le réseau. Si les données dont vous disposez ne sont pas quantifiées, vous devrez voxéliser ou quantifier les données (spatiales) dans un tenseur clairsemé. Heureusement, le moteur Minkowski fournit la fonction de quantification ( 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 ) Pour la discussion et les questions, veuillez utiliser [email protected] . Pour l'API et l'utilisation générale, veuillez vous référer à la page de documentation Minkowskienne pour plus de détails.
Pour les problèmes non répertoriés sur l'API et les demandes de fonctionnalités, n'hésitez pas à soumettre un problème sur la page GitHub Issue.
Dans certains cas, vous devez spécifier explicitement la capacité de calcul que votre GPU utilise. La liste par défaut peut ne pas contenir votre architecture.
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_cudaIl y a un problème connu dans la poussée avec Cuda 10 qui mène à une exception de poussée non perdue. Veuillez vous référer au problème pour plus de détails.
Il y a quelques causes pour cette erreur.
Minkowskienne est une bibliothèque spécialisée qui peut gérer différents points ou un nombre différent d'éléments non nuls à chaque itération pendant la formation, ce qui est courant dans les données de cloud de points. Cependant, Pytorch est implémenté en supposant que le nombre de points ou de taille des activations ne change pas à chaque itération. Ainsi, la mise en cache de mémoire GPU utilisée par Pytorch peut entraîner une consommation de mémoire inutilement importante.
Plus précisément, Pytorch cache des morceaux d'espaces de mémoire pour accélérer l'allocation utilisée dans chaque création du tenseur. S'il ne trouve pas l'espace mémoire, il divise une mémoire en cache existante ou alloue un nouvel espace s'il n'y a pas de mémoire en cache suffisamment grande pour la taille demandée. Ainsi, chaque fois que nous utilisons un nombre différent de points (nombre d'éléments non nuls) avec Pytorch, il divise le cache existant ou réserve une nouvelle mémoire. Si le cache est trop fragmenté et alloué tout l'espace GPU, il relèvera de l'erreur de mémoire.
Pour éviter cela, vous devez effacer le cache à intervalle régulier avec torch.cuda.empty_cache() .
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
Le Minkowskienne utilise OpenMP pour paralléliser la génération de carte du noyau. Cependant, lorsque le nombre de threads utilisés pour la parallélisation est trop grand (par exemple OMP_NUM_THERDS = 80), l'efficacité tombe rapidement car tous les threads attendent simplement que les verrous de multithread soient libérés. Dans de tels cas, définissez le nombre de threads utilisés pour OpenMP. Habituellement, n'importe quel nombre inférieur à 24 serait bien, mais la recherche de la configuration optimale de votre système.
export OMP_NUM_THREADS=<number of threads to use>; python <your_program.py>
Si vous utilisez le moteur Minkowski, veuillez citer:
@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}
}
Pour la génération de cartes du noyau multi-thread, veuillez citer:
@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}
}
Pour les couches de mise en commun des étapes pour les convolutions de haute dimension, veuillez citer:
@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}
}
Pour une convolution transposée générative, veuillez citer:
@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}
}
Pour les unittests et gradcheck, utilisez la torche> = 1,7
N'hésitez pas à mettre à jour la page Wiki pour ajouter vos projets!
Projets utilisant Minkowskienne
Segmentation: Segmentation sémantique spatio-temporelle 3D et 4D, CVPR'19
Apprentissage de la représentation: caractéristiques géométriques entièrement convolutionnelles, ICCV'19
Enregistrement 3D: Enregistrement de cloud 3D d'apprentissage multi-commentaires, CVPR'20
Enregistrement 3D: Enregistrement mondial profond, CVPR'20
Reconnaissance des modèles: réseaux convolutionnels à haute dimension pour la reconnaissance géométrique des modèles, CVPR'20
Détection: réseaux de détection rares génératifs pour détection d'objets à un seul coup, ECCV'20
Correspondance d'image: réseaux consensus de quartier clairsemés, ECCV'20
