MinkowskiEngine
v0.5.4
O motor Minkowski é uma biblioteca de diferenciação automática para tensores esparsos. Ele suporta todas as camadas de rede neural padrão, como operações de convolução, agrupamento, desacordo e transmissão para tensores esparsos. Para mais informações, visite a página de documentação.
O motor Minkowski suporta várias funções que podem ser construídas em um tensor esparso. Listamos algumas arquiteturas e aplicativos de rede populares aqui. Para executar os exemplos, instale o pacote e execute o comando no diretório raiz do pacote.
| Exemplos | Redes e comandos |
|---|---|
| Segmentação semântica | python -m examples.indoor |
| Classificação | python -m examples.classification_modelnet40 |
| Reconstrução | python -m examples.reconstruction |
| Conclusão | python -m examples.completion |
| Detecção |
Compressa uma rede neural para acelerar a inferência e minimizar a pegada de memória foi amplamente estudada. Uma das técnicas populares para a compactação do modelo é a poda dos pesos em Convnets, também é conhecida como redes convolucionais escassas . Essa escassez de espaço de parâmetros usada para modelar compactação de compactação compressa redes que operam em tensores densos e todas as ativações intermediárias dessas redes também são tensores densos.
No entanto, neste trabalho, nos concentramos em dados espacialmente escassos, em particular, entradas de alta dimensão espacialmente esparsas e dados 3D e convolução na superfície dos objetos 3D, propostos pela primeira vez em Siggraph'17. Também podemos representar esses dados como tensores esparsos, e esses tensores esparsos são comuns em problemas de alta dimensão, como percepção 3D, registro e dados estatísticos. Definimos redes neurais especializadas para essas entradas como redes de tensores esparsas e essas redes de tensores esparsas processam e geram tensores esparsos como saídas. Para construir uma rede de tensores esparsos, construímos todas as camadas de rede neural padrão, como MLPs, não linearidades, convolução, normalizações, operações de agrupamento da mesma maneira que os definimos em um tensor denso e implementamos no motor Minkowski.
Visualizamos uma operação de rede de tensores esparsos em um tensor esparso, convolução, abaixo. A camada de convolução em um tensor esparso funciona de maneira semelhante à de um tensor denso. No entanto, em um tensor esparso, calculamos os resultados da convolução em alguns pontos especificados que podemos controlar na convolução generalizada. Para mais informações, visite a página de documentação sobre redes de tensores esparsos e a página de terminologia.
| Tensor denso | Tensor esparso |
|---|---|
conda install -y -c nvidia -c pytorch pytorch=1.8.1 cudatoolkit=10.2 ) Você pode instalar o motor Minkowski com pip , com Anaconda ou no sistema diretamente. Se você tiver problemas com a instalação do pacote, consulte a página do wiki de instalação. Se você não conseguir encontrar um problema relevante, relate o problema na página de problemas do GitHub.
O MinkowskiEngine é distribuído via Pypi Minkowskiengine, que pode ser instalado simplesmente com pip . Primeiro, instale o Pytorch seguindo a instrução. Em seguida, 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
Se você deseja especificar argumentos para o script de configuração, consulte o seguinte 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 suporta o CUDA 10.2 e o CUDA 11.1, que funcionam para a maioria das mais recentes versões de Pytorch.
Recomendamos python>=3.6 para instalação. Primeiro, siga a documentação da Anaconda para instalar o Anaconda no seu computador.
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 instalação. Primeiro, siga a documentação da Anaconda para instalar o Anaconda no seu computador.
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
Como a instalação da Anaconda, certifique -se de instalar o Pytorch com a mesma versão CUDA que nvcc usa.
# 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
Depois que o Docker for construído, verifique se ele carrega o Minkowskiengine corretamente.
docker run MinkowskiEngine python3 -c "import MinkowskiEngine; print(MinkowskiEngine.__version__)"
O mecanismo Minkowski suporta a CPU apenas em outras plataformas que não possuem GPUs NVIDIA. Por favor, consulte o Start Quick para obter mais detalhes.
Para usar o mecanismo Minkowski, você primeiro precisaria importar o mecanismo. Em seguida, você precisaria definir a rede. Se os dados que você tiver não forem quantizados, você precisará voxelizar ou quantizar os dados (espaciais) em um tensor esparso. Felizmente, o motor Minkowski fornece a função de quantização ( 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 discussão e perguntas, use [email protected] . Para uso da API e Geral, consulte a página de documentação Minkowskiengine para obter mais detalhes.
Para questões não listadas nas solicitações da API e dos recursos, sinta -se à vontade para enviar um problema na página de emissão do Github.
Em alguns casos, você precisa especificar explicitamente qual capacidade de computação que sua GPU usa. A lista padrão pode não conter sua arquitetura.
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_cudaHá uma questão conhecida em impulso com o CUDA 10 que leva a uma exceção de impulso não atendida. Consulte o problema para obter detalhes.
Existem algumas causas para esse erro.
Minkowskiengine é uma biblioteca especializada que pode lidar com um número diferente de pontos ou um número diferente de elementos diferentes de zero em todas as iterações durante o treinamento, o que é comum nos dados da nuvem de pontos. No entanto, o Pytorch é implementado, assumindo que o número de pontos ou tamanho das ativações não muda em todas as iterações. Assim, o cache de memória da GPU usado por Pytorch pode resultar em consumo desnecessariamente de memória.
Especificamente, os caches pytorch cache de espaços de memória para acelerar a alocação usada em todas as criações de tensores. Se não encontrar o espaço de memória, divide uma memória em cache existente ou aloce novo espaço se não houver memória em cache grande o suficiente para o tamanho solicitado. Assim, toda vez que usamos um número diferente de ponto (número de elementos diferentes de zero) com o Pytorch, ele dividiu o cache existente ou reserva uma nova memória. Se o cache for muito fragmentado e alocado em todo o espaço da GPU, ele aumentará o erro de memória.
Para evitar isso, você deve limpar o cache em intervalo regular com 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
O Minkowskiengine usa o OpenMP para paralelizar a geração do mapa do kernel. No entanto, quando o número de threads usados para paralelização é muito grande (por exemplo, omp_num_threads = 80), a eficiência cai rapidamente, pois todos os threads simplesmente aguardam que os bloqueios multithread sejam lançados. Nesses casos, defina o número de threads usados para o OpenMP. Geralmente, qualquer número abaixo de 24 seria bom, mas procure a configuração ideal no seu sistema.
export OMP_NUM_THREADS=<number of threads to use>; python <your_program.py>
Se você usar o mecanismo 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 geração de mapa do kernel multithread, cite:
@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 camadas de agrupamento para convoluções de alta dimensão, 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 uma convolução generativa transposta, cite:
@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 e gradcheck, use tocha> = 1.7
Sinta -se à vontade para atualizar a página do Wiki para adicionar seus projetos!
Projetos usando Minkowskiengine
Segmentação: segmentação semântica espaço-temporal 3D e 4D, CVPR'19
Aprendizagem de representação: Recursos geométricos totalmente convolucionais, ICCV'19
Registro 3D: Aprendendo Registro de Cloud de Ponto Multiview Point, CVPR'20
Registro 3D: Registro global profundo, CVPR'20
Reconhecimento de padrões: redes convolucionais de alta dimensão para reconhecimento de padrões geométricos, CVPR'20
Detecção: redes de detecção esparsa generativa para detecção de objetos de tiro único 3D, ECCV'20
MAIS DE IMAGEM: Redes de consenso de bairro esparsas, ECCV'20
