Merge pull request #125 from Benzlxs/master

adding ConcaTable, JoinTable, Identity functions

README.md

@@ -4,15 +4,9 @@
 
 This is a spatially sparse convolution library like [SparseConvNet](https://github.com/facebookresearch/SparseConvNet) but faster and easy to read. This library provide sparse convolution/transposed, submanifold convolution, inverse convolution and sparse maxpool.
 
-The GPU Indice Generation algorithm is a unofficial implementation of paper [SECOND](http://www.mdpi.com/1424-8220/18/10/3337). That algorithm (don't include GPU SubM indice generation algorithm) may be protected by patent.
 
-This project only support CUDA 9.0+ or CPU only. If you are using cuda 8.0, please update it to 9.0.
+2020-5-2, we add ConcatTable, JoinTable, AddTable, and Identity function to build ResNet and Unet in this version of spconv.
 
-This project only support tensors with spatial volume less than ```std::numeric_limits<int>::max()``` (~2e9). if someone really need very large space, open an issue.
-
-## News:
-
-2019-5-24: spconv v1.1 released, now indice generation will use hash table as default (CPU code only support hash table). you can use ```use_hash=False``` to use dense table when using CUDA. In addition, add CPU only build support.
 
 ## Docker:
 

spconv/__init__.py

@@ -23,6 +23,8 @@ from spconv.conv import SparseConvTranspose2d, SparseConvTranspose3d
 from spconv.conv import SparseInverseConv2d, SparseInverseConv3d
 from spconv.modules import SparseModule, SparseSequential
 from spconv.pool import SparseMaxPool2d, SparseMaxPool3d
+from spconv.tables import ConcatTable, JoinTable, AddTable
+from spconv.identity import Identity
 
 from spconv import ops
 

spconv/identity.py

+# Copyright 2016-present, Facebook, Inc.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+from torch.nn import Module
+
+
+class Identity(Module):
+    def forward(self, input):
+        return input
+
+    def input_spatial_size(self, out_size):
+        return out_size

spconv/modules.py

@@ -125,6 +125,9 @@ class SparseSequential(SparseModule):
     def forward(self, input):
         for k, module in self._modules.items():
             if is_spconv_module(module):  # use SpConvTensor as input
+                if isinstance(input, list):
+                    input = module(input)
+                else:
                     assert isinstance(input, spconv.SparseConvTensor)
                     self._sparity_dict[k] = input.sparity
                     input = module(input)

spconv/tables.py

+
+from torch.autograd import Function
+#from torch.nn import Module
+from spconv.modules import SparseModule
+import spconv
+import torch
+
+class JoinTable(SparseModule):# Module):
+    def forward(self, input):
+        output = spconv.SparseConvTensor(
+                torch.cat([i.features for i in input],1), input[1].indices,
+                input[1].spatial_shape, input[0].batch_size )
+        output.indice_dict = input[1].indice_dict
+        output.grid = input[1].grid
+        return output
+
+    def input_spatial_size(self, out_size):
+        return out_size
+
+
+class AddTable(SparseModule): # Module):
+    def forward(self, input):
+        output = spconv.SparseConvTensor(
+                sum([i.features for i in input]), input[1].indices,
+                input[1].spatial_shape, input[1].batch_size )
+        output.indice_dict = input[1].indice_dict
+        output.grid = input[1].grid
+
+        return output
+
+    def input_spatial_size(self, out_size):
+        return out_size
+
+
+class ConcatTable(SparseModule): # Module):
+    def forward(self, input):
+        return [module(input) for module in self._modules.values()]
+
+    def add(self, module):
+        self._modules[str(len(self._modules))] = module
+        return self
+
+    def input_spatial_size(self, out_size):
+        return self._modules['0'].input_spatial_size(out_size)