MinkowskiEngine
v0.5.4
El motor Minkowski es una biblioteca de diferenciación automática para tensores dispersos. Admite todas las capas de redes neuronales estándar, como las operaciones de convolución, agrupación, impotación y transmisión para tensores dispersos. Para obtener más información, visite la página de documentación.
El motor Minkowski admite varias funciones que se pueden construir en un tensor escaso. Enumeramos algunas arquitecturas y aplicaciones de red populares aquí. Para ejecutar los ejemplos, instale el paquete y ejecute el comando en el directorio raíz del paquete.
| Ejemplos | Redes y comandos |
|---|---|
| Segmentación semántica | python -m examples.indoor |
| Clasificación | python -m examples.classification_modelnet40 |
| Reconstrucción | python -m examples.reconstruction |
| Terminación | python -m examples.completion |
| Detección |
La comprimir una red neuronal para acelerar la inferencia y minimizar la huella de la memoria se ha estudiado ampliamente. Una de las técnicas populares para la compresión del modelo es la poda de los pesos en los convnets, también se conoce como redes convolucionales dispersas . Dicha dispersión del espacio de parámetros utilizados para compresión modelo comprime redes que operan con tensores densos y todas las activaciones intermedias de estas redes también son tensores densos.
Sin embargo, en este trabajo, nos centramos en datos espacialmente escasos, en particular, entradas de alta dimensión espacialmente escasas y datos 3D y convolución en la superficie de los objetos 3D, propuestos por primera vez en Siggraph'17. También podemos representar estos datos como tensores dispersos, y estos tensores dispersos son comunes en problemas de alta dimensión, como la percepción 3D, el registro y los datos estadísticos. Definimos redes neuronales especializadas para estas entradas como redes tensoras dispersas y estas redes tensoras escasas procesan y generan tensores dispersos como salidas. Para construir una red tensora escasa, construimos todas las capas de red neuronales estándar, como MLP, no linealidades, convolución, normalizaciones, operaciones de agrupación de la misma manera que las definimos en un tensor denso e implementamos en el motor Minkowski.
Visualizamos una operación de red de tensor escaso en un tensor escaso, convolución, a continuación. La capa de convolución en un tensor escaso funciona de manera similar a la de un tensor denso. Sin embargo, en un tensor escaso, calculamos las salidas de convolución en algunos puntos especificados que podemos controlar en la convolución generalizada. Para obtener más información, visite la página de documentación en redes de tensor dispersas y la página de terminología.
| Tensor denso | Tensor escaso |
|---|---|
conda install -y -c nvidia -c pytorch pytorch=1.8.1 cudatoolkit=10.2 ) Puede instalar el motor Minkowski con pip , con Anaconda o en el sistema directamente. Si experimenta problemas para instalar el paquete, consulte la página Wiki de instalación. Si no puede encontrar un problema relevante, informe el problema en la página de problemas de GitHub.
El MinkowskIengine se distribuye a través de Pypi MinkowskiEngine que se puede instalar simplemente con pip . Primero, instale Pytorch siguiendo la instrucción. A continuación, instale 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 desea especificar argumentos para el script de configuración, consulte el siguiente comando.
# 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 admite CUDA 10.2 y CUDA 11.1, que funcionan para la mayoría de las últimas versiones de Pytorch.
Recomendamos python>=3.6 para la instalación. Primero, siga la documentación de Anaconda para instalar Anaconda en su computadora.
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
Recomendamos python>=3.6 para la instalación. Primero, siga la documentación de Anaconda para instalar Anaconda en su computadora.
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
Al igual que la instalación de Anaconda, asegúrese de instalar Pytorch con la misma versión CUDA que usa nvcc .
# 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
Una vez que se construye el Docker, verifique que carga correctamente MinkowskiEngine.
docker run MinkowskiEngine python3 -c "import MinkowskiEngine; print(MinkowskiEngine.__version__)"
El motor Minkowski admite CPU solo construido en otras plataformas que no tienen GPU NVIDIA. Consulte el inicio rápido para obtener más detalles.
Para usar el motor Minkowski, primero necesitaría importar el motor. Luego, necesitaría definir la red. Si los datos que tiene no se cuantifican, deberá voxelizar o cuantificar los datos (espaciales) en un tensor escaso. Afortunadamente, el motor Minkowski proporciona la función de cuantización ( 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 ) Para discusión y preguntas, use [email protected] . Para el uso de API y general, consulte la página de documentación de MinkowskiEngine para obtener más detalles.
Para los problemas que no figuran en la API y las solicitudes de funciones, no dude en enviar un problema en la página de problemas de GitHub.
En algunos casos, debe especificar explícitamente qué capacidad de cálculo utiliza su GPU. Es posible que la lista predeterminada no contenga su arquitectura.
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_cudaHay un problema conocido en el empuje con Cuda 10 que conduce a una excepción de empuje no controlada. Consulte el problema para obtener detalles.
Hay algunas causas de este error.
MinkowskIengine es una biblioteca especializada que puede manejar un número diferente de puntos o un número diferente de elementos distintos de cero en cada iteración durante el entrenamiento, lo cual es común en los datos de puntos de la nube. Sin embargo, se implementa Pytorch suponiendo que el número de puntos o el tamaño de las activaciones no cambia en cada iteración. Por lo tanto, el almacenamiento en caché de la memoria GPU utilizado por Pytorch puede dar lugar a un consumo de memoria innecesariamente grande.
Específicamente, Pytorch almacena trozos de espacios de memoria para acelerar la asignación utilizada en cada creación de tensor. Si no encuentra el espacio de memoria, divide una memoria almacenada en caché existente o asigna un nuevo espacio si no hay memoria en caché lo suficientemente grande para el tamaño solicitado. Por lo tanto, cada vez que usamos diferentes números de puntos (número de elementos distintos de cero) con Pytorch, dividen el caché existente o reserva la nueva memoria. Si el caché está demasiado fragmentado y asigna todo el espacio de la GPU, elevará el error de memoria.
Para evitar esto, debe borrar el caché a intervalo regular con 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
El MinkowskIengine utiliza OpenMP para paralelizar la generación de mapas del núcleo. Sin embargo, cuando el número de subprocesos utilizados para la paralelización es demasiado grande (por ejemplo, omp_num_threads = 80), la eficiencia cae rápidamente ya que todos los hilos simplemente esperan a que se liberen bloqueos multiproceso. En tales casos, establezca el número de hilos utilizados para OpenMP. Por lo general, cualquier número inferior a 24 estaría bien, pero busque la configuración óptima en su sistema.
export OMP_NUM_THREADS=<number of threads to use>; python <your_program.py>
Si usa el motor Minkowski, cite:
@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}
}
Para la generación de mapas de kernel múltiples, por favor cita:
@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}
}
Para capas de agrupación de estrías para convoluciones de alta dimensión, cite:
@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}
}
Para una convolución transpositada generativa, por favor cita:
@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}
}
Para Unittests y GradCheck, use la antorcha> = 1.7
¡No dude en actualizar la página Wiki para agregar sus proyectos!
Proyectos que usan MinkowskiEngine
Segmentación: segmentación semántica espacio-temporal 3D y 4D, CVPR'19
Aprendizaje de representación: características geométricas totalmente convolucionales, ICCV'19
Registro 3D: Aprendizaje de registro de nube de puntos 3D de aprendizaje, CVPR'20
Registro 3D: Registro global profundo, CVPR'20
Reconocimiento de patrones: redes convolucionales de alta dimensión para el reconocimiento de patrones geométricos, CVPR'20
Detección: redes generativas de detección dispersa para detección de objetos de un solo disparo 3D, ECCV'20
Matriota de imagen: redes de consenso de vecindad escasos, ECCV'20
