ocnn 2.2.4__tar.gz → 2.2.6__tar.gz

{ocnn-2.2.4/ocnn.egg-info → ocnn-2.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ocnn
-Version: 2.2.4
+Version: 2.2.6
 Summary: Octree-based Sparse Convolutional Neural Networks
 Home-page: https://github.com/octree-nn/ocnn-pytorch
 Author: Peng-Shuai Wang
@@ -28,30 +28,41 @@ Requires-Dist: packaging
 
 This repository contains the **pure PyTorch**-based implementation of
 [O-CNN](https://wang-ps.github.io/O-CNN.html). The code has been tested with
-`Pytorch>=1.6.0`, and `Pytorch>=1.9.0` is preferred.
+`Pytorch>=1.6.0`, and `Pytorch>=1.9.0` is preferred. The *original*
+implementation of O-CNN is based on C++ and CUDA and can be found
+[here](https://github.com/Microsoft/O-CNN), which has received
+[![stars - O-CNN](https://img.shields.io/github/stars/microsoft/O-CNN?style=social)](https://github.com/microsoft/O-CNN) and
+[![forks - O-CNN](https://img.shields.io/github/forks/microsoft/O-CNN?style=social)](https://github.com/microsoft/O-CNN).
 
-O-CNN is an octree-based sparse convolutional neural network framework for 3D
-deep learning. O-CNN constrains the CNN storage and computation into non-empty
-sparse voxels for efficiency and uses the `octree` data structure to organize
-and index these sparse voxels.
 
-The concept of sparse convolution in O-CNN is the same with
-[H-CNN](https://ieeexplore.ieee.org/abstract/document/8580422),
+O-CNN is an octree-based 3D convolutional neural network framework for 3D data.
+O-CNN constrains the CNN storage and computation into non-empty sparse voxels
+for efficiency and uses the `octree` data structure to organize and index these
+sparse voxels. Currently, this type of 3D convolution is known as Sparse
+Convolution in the research community.
+
+
+The concept of Sparse Convolution in O-CNN is the same with
 [SparseConvNet](https://openaccess.thecvf.com/content_cvpr_2018/papers/Graham_3D_Semantic_Segmentation_CVPR_2018_paper.pdf),
-and
-[MinkowskiNet](https://openaccess.thecvf.com/content_CVPR_2019/papers/Choy_4D_Spatio-Temporal_ConvNets_Minkowski_Convolutional_Neural_Networks_CVPR_2019_paper.pdf).
-The key difference is that our O-CNN uses the `octree` to index the sparse
-voxels, while these 3 works use the `Hash Table`.
-
-Our O-CNN is published in SIGGRAPH 2017, H-CNN is published in TVCG 2018,
-SparseConvNet is published in CVPR 2018, and MinkowskiNet is published in
-CVPR 2019. Actually, our O-CNN was submitted to SIGGRAPH in the end of 2016 and
-was officially accepted in March, 2017. The camera-ready version of our O-CNN was
-submitted to SIGGRAPH in April, 2017. We just did not post our paper on Arxiv
-during the review process of SIGGRAPH. Therefore, **the idea of constraining CNN
-computation into sparse non-emtpry voxels is first proposed by our O-CNN**.
-Currently, this type of 3D convolution is known as Sparse Convolution in the
-research community.
+[MinkowskiNet](https://github.com/NVIDIA/MinkowskiEngine), and
+[SpConv](https://github.com/traveller59/spconv).
+The key difference is that our O-CNN uses `octrees` to index the sparse voxels,
+while these works use `Hash Tables`. However, I believe that `octrees` may be
+the right choice for Sparse Convolution. With `octrees`, I can implement the
+Sparse Convolution with pure PyTorch. More importantly, with `octrees`, I can
+also build efficient transformers for 3D data --
+[OctFormer](https://github.com/octree-nn/octformer), which is extremely hard
+with `Hash Tables`.
+
+
+Our O-CNN is published in SIGGRAPH 2017, SparseConvNet is published in CVPR
+2018, and MinkowskiNet is published in CVPR 2019. Actually, our O-CNN was
+submitted to SIGGRAPH in the end of 2016 and was officially accepted in March,
+2017. <!-- The camera-ready version of our O-CNN was submitted to SIGGRAPH in April, 2018. -->
+We just did not post our paper on Arxiv during the review process of SIGGRAPH.
+Therefore, **the idea of constraining CNN computation into sparse non-emtpry
+voxels, i.e. Sparse Convolution,  is first proposed by our O-CNN**.
+
 
 ## Key benefits of ocnn-pytorch
 

ocnn-2.2.6/README.md

@@ -0,0 +1,72 @@
+# O-CNN
+
+**[Documentation](https://ocnn-pytorch.readthedocs.io)**
+
+[![Documentation Status](https://readthedocs.org/projects/ocnn-pytorch/badge/?version=latest)](https://ocnn-pytorch.readthedocs.io/en/latest/?badge=latest)
+[![Downloads](https://static.pepy.tech/badge/ocnn)](https://pepy.tech/project/ocnn)
+[![Downloads](https://static.pepy.tech/badge/ocnn/month)](https://pepy.tech/project/ocnn)
+[![PyPI](https://img.shields.io/pypi/v/ocnn)](https://pypi.org/project/ocnn/)
+
+This repository contains the **pure PyTorch**-based implementation of
+[O-CNN](https://wang-ps.github.io/O-CNN.html). The code has been tested with
+`Pytorch>=1.6.0`, and `Pytorch>=1.9.0` is preferred. The *original*
+implementation of O-CNN is based on C++ and CUDA and can be found
+[here](https://github.com/Microsoft/O-CNN), which has received
+[![stars - O-CNN](https://img.shields.io/github/stars/microsoft/O-CNN?style=social)](https://github.com/microsoft/O-CNN) and
+[![forks - O-CNN](https://img.shields.io/github/forks/microsoft/O-CNN?style=social)](https://github.com/microsoft/O-CNN).
+
+
+O-CNN is an octree-based 3D convolutional neural network framework for 3D data.
+O-CNN constrains the CNN storage and computation into non-empty sparse voxels
+for efficiency and uses the `octree` data structure to organize and index these
+sparse voxels. Currently, this type of 3D convolution is known as Sparse
+Convolution in the research community.
+
+
+The concept of Sparse Convolution in O-CNN is the same with
+[SparseConvNet](https://openaccess.thecvf.com/content_cvpr_2018/papers/Graham_3D_Semantic_Segmentation_CVPR_2018_paper.pdf),
+[MinkowskiNet](https://github.com/NVIDIA/MinkowskiEngine), and
+[SpConv](https://github.com/traveller59/spconv).
+The key difference is that our O-CNN uses `octrees` to index the sparse voxels,
+while these works use `Hash Tables`. However, I believe that `octrees` may be
+the right choice for Sparse Convolution. With `octrees`, I can implement the
+Sparse Convolution with pure PyTorch. More importantly, with `octrees`, I can
+also build efficient transformers for 3D data --
+[OctFormer](https://github.com/octree-nn/octformer), which is extremely hard
+with `Hash Tables`.
+
+
+Our O-CNN is published in SIGGRAPH 2017, SparseConvNet is published in CVPR
+2018, and MinkowskiNet is published in CVPR 2019. Actually, our O-CNN was
+submitted to SIGGRAPH in the end of 2016 and was officially accepted in March,
+2017. <!-- The camera-ready version of our O-CNN was submitted to SIGGRAPH in April, 2018. -->
+We just did not post our paper on Arxiv during the review process of SIGGRAPH.
+Therefore, **the idea of constraining CNN computation into sparse non-emtpry
+voxels, i.e. Sparse Convolution,  is first proposed by our O-CNN**.
+
+
+## Key benefits of ocnn-pytorch
+
+- **Simplicity**. The ocnn-pytorch is based on pure PyTorch, it is portable and
+  can be installed with a simple command:`pip install ocnn`. Other sparse
+  convolution frameworks heavily rely on C++ and CUDA, and it is complicated to
+  configure the compiling environment.
+
+- **Efficiency**. The ocnn-pytorch is very efficient compared with other sparse
+  convolution frameworks.  It only takes 18 hours to train the network on
+  ScanNet for 600 epochs with 4 V100 GPUs. For reference, under the same
+  training settings, MinkowskiNet 0.4.3 takes 60 hours and MinkowskiNet 0.5.4
+  takes 30 hours.
+
+## Citation
+
+  ```bibtex
+  @article {Wang-2017-ocnn,
+    title    = {{O-CNN}: Octree-based Convolutional Neural Networksfor {3D} Shape Analysis},
+    author   = {Wang, Peng-Shuai and Liu, Yang and Guo, Yu-Xiao and Sun, Chun-Yu and Tong, Xin},
+    journal  = {ACM Transactions on Graphics (SIGGRAPH)},
+    volume   = {36},
+    number   = {4},
+    year     = {2017},
+  }
+  ```

{ocnn-2.2.4 → ocnn-2.2.6}/ocnn/__init__.py

@@ -12,7 +12,7 @@ from . import models
 from . import dataset
 from . import utils
 
-__version__ = '2.2.4'
+__version__ = '2.2.6'
 
 __all__ = [
     'octree',

{ocnn-2.2.4 → ocnn-2.2.6}/ocnn/models/autoencoder.py

@@ -33,8 +33,9 @@ class AutoEncoder(torch.nn.Module):
     self.full_depth = full_depth
     self.feature = feature
     self.resblk_num = 2
-    self.code_channel = 64  # dim-of-code = code_channel * 2**(3*full_depth)
     self.channels = [512, 512, 256, 256, 128, 128, 32, 32, 16, 16]
+    # dim-of-code = code_channel * 2**(3*full_depth)
+    self.code_channel = self.channels[full_depth]
 
     # encoder
     self.conv1 = ocnn.modules.OctreeConvBnRelu(

{ocnn-2.2.4 → ocnn-2.2.6}/ocnn/models/ounet.py

@@ -18,8 +18,7 @@ class OUNet(AutoEncoder):
 
   def __init__(self, channel_in: int, channel_out: int, depth: int,
                full_depth: int = 2, feature: str = 'ND'):
-    super().__init__(channel_in, channel_out, depth, full_depth, feature,
-                     code_channel=-1)  # !set code_channe=-1
+    super().__init__(channel_in, channel_out, depth, full_depth, feature)
     self.proj = None  # remove this module used in AutoEncoder
 
   def encoder(self, octree):

{ocnn-2.2.4 → ocnn-2.2.6}/ocnn/octree/octree.py

@@ -35,7 +35,9 @@ class Octree:
     and :obj:`points`, contain only non-empty nodes.
 
   .. note::
-    The point cloud must be in range :obj:`[-1, 1]`.
+    The point cloud must be strictly in range :obj:`[-1, 1]`. A good practice
+    is to normalize it into :obj:`[-0.99, 0.99]` or :obj:`[0.9, 0.9]` to retain
+    some margin.
   '''
 
   def __init__(self, depth: int, full_depth: int = 2, batch_size: int = 1,
@@ -151,7 +153,9 @@ class Octree:
       point_cloud (Points): The input point cloud.
 
     .. note::
-      Currently, the batch size of the point cloud must be 1.
+      The point cloud must be strictly in range :obj:`[-1, 1]`. A good practice
+      is to normalize it into :obj:`[-0.99, 0.99]` or :obj:`[0.9, 0.9]` to retain
+      some margin.
     '''
 
     self.device = point_cloud.device
@@ -176,7 +180,7 @@ class Octree:
     for d in range(self.depth, self.full_depth, -1):
       # compute parent key, i.e. keys of layer (d -1)
       pkey = node_key >> 3
-      pkey, pidx, pcounts = torch.unique_consecutive(
+      pkey, pidx, _ = torch.unique_consecutive(
           pkey, return_inverse=True, return_counts=True)
 
       # augmented key
@@ -287,6 +291,23 @@ class Octree:
       update_neigh (bool): If True, construct the neighborhood indices.
     '''
 
+    # increase the octree depth if required
+    if depth > self.depth:
+      assert depth == self.depth + 1
+      self.depth = depth
+      self.keys.append(None)
+      self.children.append(None)
+      self.neighs.append(None)
+      self.features.append(None)
+      self.normals.append(None)
+      self.points.append(None)
+      zero = torch.zeros(1, dtype=torch.long)
+      self.nnum = torch.cat([self.nnum, zero])
+      self.nnum_nempty = torch.cat([self.nnum_nempty, zero])
+      zero = zero.view(1, 1)
+      self.batch_nnum = torch.cat([self.batch_nnum, zero], dim=0)
+      self.batch_nnum_nempty = torch.cat([self.batch_nnum_nempty, zero], dim=0)
+
     # node number
     nnum = self.nnum_nempty[depth-1] * 8
     self.nnum[depth] = nnum

{ocnn-2.2.4 → ocnn-2.2.6}/ocnn/octree/points.py

@@ -63,9 +63,9 @@ class Points:
     if self.batch_id is not None:
       assert self.batch_id.dim() == 2 or self.batch_id.dim() == 1
       assert self.batch_id.size(0) == self.points.size(0)
-      assert self.batch_id.size(1) == 1
       if self.batch_id.dim() == 1:
         self.batch_id = self.batch_id.unsqueeze(1)
+      assert self.batch_id.size(1) == 1
 
   @property
   def npt(self):

{ocnn-2.2.4 → ocnn-2.2.6/ocnn.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ocnn
-Version: 2.2.4
+Version: 2.2.6
 Summary: Octree-based Sparse Convolutional Neural Networks
 Home-page: https://github.com/octree-nn/ocnn-pytorch
 Author: Peng-Shuai Wang
@@ -28,30 +28,41 @@ Requires-Dist: packaging
 
 This repository contains the **pure PyTorch**-based implementation of
 [O-CNN](https://wang-ps.github.io/O-CNN.html). The code has been tested with
-`Pytorch>=1.6.0`, and `Pytorch>=1.9.0` is preferred.
+`Pytorch>=1.6.0`, and `Pytorch>=1.9.0` is preferred. The *original*
+implementation of O-CNN is based on C++ and CUDA and can be found
+[here](https://github.com/Microsoft/O-CNN), which has received
+[![stars - O-CNN](https://img.shields.io/github/stars/microsoft/O-CNN?style=social)](https://github.com/microsoft/O-CNN) and
+[![forks - O-CNN](https://img.shields.io/github/forks/microsoft/O-CNN?style=social)](https://github.com/microsoft/O-CNN).
 
-O-CNN is an octree-based sparse convolutional neural network framework for 3D
-deep learning. O-CNN constrains the CNN storage and computation into non-empty
-sparse voxels for efficiency and uses the `octree` data structure to organize
-and index these sparse voxels.
 
-The concept of sparse convolution in O-CNN is the same with
-[H-CNN](https://ieeexplore.ieee.org/abstract/document/8580422),
+O-CNN is an octree-based 3D convolutional neural network framework for 3D data.
+O-CNN constrains the CNN storage and computation into non-empty sparse voxels
+for efficiency and uses the `octree` data structure to organize and index these
+sparse voxels. Currently, this type of 3D convolution is known as Sparse
+Convolution in the research community.
+
+
+The concept of Sparse Convolution in O-CNN is the same with
 [SparseConvNet](https://openaccess.thecvf.com/content_cvpr_2018/papers/Graham_3D_Semantic_Segmentation_CVPR_2018_paper.pdf),
-and
-[MinkowskiNet](https://openaccess.thecvf.com/content_CVPR_2019/papers/Choy_4D_Spatio-Temporal_ConvNets_Minkowski_Convolutional_Neural_Networks_CVPR_2019_paper.pdf).
-The key difference is that our O-CNN uses the `octree` to index the sparse
-voxels, while these 3 works use the `Hash Table`.
-
-Our O-CNN is published in SIGGRAPH 2017, H-CNN is published in TVCG 2018,
-SparseConvNet is published in CVPR 2018, and MinkowskiNet is published in
-CVPR 2019. Actually, our O-CNN was submitted to SIGGRAPH in the end of 2016 and
-was officially accepted in March, 2017. The camera-ready version of our O-CNN was
-submitted to SIGGRAPH in April, 2017. We just did not post our paper on Arxiv
-during the review process of SIGGRAPH. Therefore, **the idea of constraining CNN
-computation into sparse non-emtpry voxels is first proposed by our O-CNN**.
-Currently, this type of 3D convolution is known as Sparse Convolution in the
-research community.
+[MinkowskiNet](https://github.com/NVIDIA/MinkowskiEngine), and
+[SpConv](https://github.com/traveller59/spconv).
+The key difference is that our O-CNN uses `octrees` to index the sparse voxels,
+while these works use `Hash Tables`. However, I believe that `octrees` may be
+the right choice for Sparse Convolution. With `octrees`, I can implement the
+Sparse Convolution with pure PyTorch. More importantly, with `octrees`, I can
+also build efficient transformers for 3D data --
+[OctFormer](https://github.com/octree-nn/octformer), which is extremely hard
+with `Hash Tables`.
+
+
+Our O-CNN is published in SIGGRAPH 2017, SparseConvNet is published in CVPR
+2018, and MinkowskiNet is published in CVPR 2019. Actually, our O-CNN was
+submitted to SIGGRAPH in the end of 2016 and was officially accepted in March,
+2017. <!-- The camera-ready version of our O-CNN was submitted to SIGGRAPH in April, 2018. -->
+We just did not post our paper on Arxiv during the review process of SIGGRAPH.
+Therefore, **the idea of constraining CNN computation into sparse non-emtpry
+voxels, i.e. Sparse Convolution,  is first proposed by our O-CNN**.
+
 
 ## Key benefits of ocnn-pytorch
 

{ocnn-2.2.4 → ocnn-2.2.6}/setup.py

@@ -7,7 +7,7 @@
 
 from setuptools import setup, find_packages
 
-__version__ = '2.2.4'
+__version__ = '2.2.6'
 
 with open("README.md", "r", encoding="utf-8") as fid:
   long_description = fid.read()

ocnn-2.2.4/README.md

@@ -1,61 +0,0 @@
-# O-CNN
-
-**[Documentation](https://ocnn-pytorch.readthedocs.io)**
-
-[![Documentation Status](https://readthedocs.org/projects/ocnn-pytorch/badge/?version=latest)](https://ocnn-pytorch.readthedocs.io/en/latest/?badge=latest)
-[![Downloads](https://static.pepy.tech/badge/ocnn)](https://pepy.tech/project/ocnn)
-[![Downloads](https://static.pepy.tech/badge/ocnn/month)](https://pepy.tech/project/ocnn)
-[![PyPI](https://img.shields.io/pypi/v/ocnn)](https://pypi.org/project/ocnn/)
-
-This repository contains the **pure PyTorch**-based implementation of
-[O-CNN](https://wang-ps.github.io/O-CNN.html). The code has been tested with
-`Pytorch>=1.6.0`, and `Pytorch>=1.9.0` is preferred.
-
-O-CNN is an octree-based sparse convolutional neural network framework for 3D
-deep learning. O-CNN constrains the CNN storage and computation into non-empty
-sparse voxels for efficiency and uses the `octree` data structure to organize
-and index these sparse voxels.
-
-The concept of sparse convolution in O-CNN is the same with
-[H-CNN](https://ieeexplore.ieee.org/abstract/document/8580422),
-[SparseConvNet](https://openaccess.thecvf.com/content_cvpr_2018/papers/Graham_3D_Semantic_Segmentation_CVPR_2018_paper.pdf),
-and
-[MinkowskiNet](https://openaccess.thecvf.com/content_CVPR_2019/papers/Choy_4D_Spatio-Temporal_ConvNets_Minkowski_Convolutional_Neural_Networks_CVPR_2019_paper.pdf).
-The key difference is that our O-CNN uses the `octree` to index the sparse
-voxels, while these 3 works use the `Hash Table`.
-
-Our O-CNN is published in SIGGRAPH 2017, H-CNN is published in TVCG 2018,
-SparseConvNet is published in CVPR 2018, and MinkowskiNet is published in
-CVPR 2019. Actually, our O-CNN was submitted to SIGGRAPH in the end of 2016 and
-was officially accepted in March, 2017. The camera-ready version of our O-CNN was
-submitted to SIGGRAPH in April, 2017. We just did not post our paper on Arxiv
-during the review process of SIGGRAPH. Therefore, **the idea of constraining CNN
-computation into sparse non-emtpry voxels is first proposed by our O-CNN**.
-Currently, this type of 3D convolution is known as Sparse Convolution in the
-research community.
-
-## Key benefits of ocnn-pytorch
-
-- **Simplicity**. The ocnn-pytorch is based on pure PyTorch, it is portable and
-  can be installed with a simple command:`pip install ocnn`. Other sparse
-  convolution frameworks heavily rely on C++ and CUDA, and it is complicated to
-  configure the compiling environment.
-
-- **Efficiency**. The ocnn-pytorch is very efficient compared with other sparse
-  convolution frameworks.  It only takes 18 hours to train the network on
-  ScanNet for 600 epochs with 4 V100 GPUs. For reference, under the same
-  training settings, MinkowskiNet 0.4.3 takes 60 hours and MinkowskiNet 0.5.4
-  takes 30 hours.
-
-## Citation
-
-  ```bibtex
-  @article {Wang-2017-ocnn,
-    title    = {{O-CNN}: Octree-based Convolutional Neural Networksfor {3D} Shape Analysis},
-    author   = {Wang, Peng-Shuai and Liu, Yang and Guo, Yu-Xiao and Sun, Chun-Yu and Tong, Xin},
-    journal  = {ACM Transactions on Graphics (SIGGRAPH)},
-    volume   = {36},
-    number   = {4},
-    year     = {2017},
-  }
-  ```