def v(depth, nPlanes): m = scn.Sequential() if depth == 1: for _ in range(reps): res(m, nPlanes, nPlanes, dropout_p) else: m = scn.Sequential() for _ in range(reps): res(m, nPlanes, nPlanes, dropout_p) if dropout_width: m.add(scn.ConcatTable().add(scn.Identity()).add( scn.Sequential().add(scn.BatchNormReLU(nPlanes)).add( #In place of Maxpooling scn.Convolution( dimension, nPlanes, nPlanes, 2, 2, False)).add(scn.Dropout(dropout_p)).add( v(depth - 1, nPlanes)).add( scn.BatchNormReLU(nPlanes)).add( scn.Deconvolution( dimension, nPlanes, nPlanes, 2, 2, False)))) else: m.add(scn.ConcatTable().add(scn.Identity()).add( scn.Sequential().add(scn.BatchNormReLU(nPlanes)).add( scn.Convolution(dimension, nPlanes, nPlanes, 2, 2, False)).add(v(depth - 1, nPlanes)).add( scn.BatchNormReLU(nPlanes)).add( scn.Deconvolution( dimension, nPlanes, nPlanes, 2, 2, False)))) m.add(scn.JoinTable()) for i in range(reps): res(m, 2 * nPlanes if i == 0 else nPlanes, nPlanes, dropout_p) return m
def __init__(self, inplanes, outplanes, bias, batch_norm): nn.Module.__init__(self) self.conv1 = scn.SubmanifoldConvolution(dimension=3, nIn=inplanes, nOut=outplanes, filter_size=3, bias=bias) if batch_norm: self.activation1 = scn.BatchNormReLU(outplanes, momentum=0.5) else: self.activation1 = scn.ReLU() self.conv2 = scn.SubmanifoldConvolution(dimension=3, nIn=outplanes, nOut=outplanes, filter_size=3, bias=bias) if batch_norm: self.activation2 = scn.BatchNormReLU(outplanes, momentum=0.5) else: self.activation2 = scn.ReLU() self.residual = scn.Identity() self.add = scn.AddTable()
def block(self, nPlanes, n, reps, stride): m = scn.Sequential() for rep in range(reps): if rep == 0: m.add(scn.BatchNormReLU(nPlanes)) m.add(scn.ConcatTable().add(self.residual( nPlanes, n, stride)).add(scn.Sequential().add( scn.SubmanifoldConvolution(self.dimension, nPlanes, n, 3, False) if stride == 1 else scn.Convolution( self.dimension, nPlanes, n, 2, stride, False)).add( scn.BatchNormReLU(n)).add( scn.SubmanifoldConvolution( self.dimension, n, n, 3, False)))) else: m.add(scn.ConcatTable().add(scn.Sequential().add( scn.BatchNormReLU(nPlanes)).add( scn.SubmanifoldConvolution( self.dimension, nPlanes, n, 3, False)).add(scn.BatchNormReLU(n)).add( scn.SubmanifoldConvolution( self.dimension, n, n, 3, False))).add(scn.Identity())) m.add(scn.AddTable()) nPlanes = n return m
def __init__(self, nf_in, nf, input_sparsetensor, return_sparsetensor, max_data_size): nn.Module.__init__(self) data_dim = 3 self.nf_in = nf_in self.nf = nf self.input_sparsetensor = input_sparsetensor self.return_sparsetensor = return_sparsetensor self.max_data_size = max_data_size if not self.input_sparsetensor: self.p0 = scn.InputLayer(data_dim, self.max_data_size, mode=0) self.p1 = scn.SubmanifoldConvolution(data_dim, nf_in, nf, filter_size=FSIZE0, bias=False) self.p2 = scn.Sequential() self.p2.add(scn.ConcatTable().add(scn.Identity()).add( scn.Sequential().add(scn.BatchNormReLU(nf)).add( scn.SubmanifoldConvolution( data_dim, nf, nf, FSIZE0, False)).add(scn.BatchNormReLU(nf)).add( scn.SubmanifoldConvolution(data_dim, nf, nf, FSIZE0, False)))).add( scn.AddTable()) self.p2.add(scn.BatchNormReLU(nf)) # downsample space by factor of 2 self.p3 = scn.Sequential().add( scn.Convolution(data_dim, nf, nf, FSIZE1, 2, False)) self.p3.add(scn.BatchNormReLU(nf)) if not self.return_sparsetensor: self.p4 = scn.SparseToDense(data_dim, nf)
def __init__(self, output_shape, use_norm=True, num_input_features=128, num_filters_down1=[64], num_filters_down2=[64, 64], name='SparseMiddleExtractor'): super(SparseMiddleExtractor, self).__init__() self.name = name if use_norm: BatchNorm1d = change_default_args( eps=1e-3, momentum=0.01)(nn.BatchNorm1d) Linear = change_default_args(bias=False)(nn.Linear) else: BatchNorm1d = Empty Linear = change_default_args(bias=True)(nn.Linear) sparse_shape = np.array(output_shape[1:4]) + [1, 0, 0] # sparse_shape[0] = 11 print(sparse_shape) self.scn_input = scn.InputLayer(3, sparse_shape.tolist()) self.voxel_output_shape = output_shape middle_layers = [] num_filters = [num_input_features] + num_filters_down1 # num_filters = [64] + num_filters_down1 filters_pairs_d1 = [[num_filters[i], num_filters[i + 1]] for i in range(len(num_filters) - 1)] for i, o in filters_pairs_d1: middle_layers.append(scn.SubmanifoldConvolution(3, i, o, 3, False)) middle_layers.append(scn.BatchNormReLU(o, eps=1e-3, momentum=0.99)) middle_layers.append( scn.Convolution( 3, num_filters[-1], num_filters[-1], (3, 1, 1), (2, 1, 1), bias=False)) middle_layers.append( scn.BatchNormReLU(num_filters[-1], eps=1e-3, momentum=0.99)) # assert len(num_filters_down2) > 0 if len(num_filters_down1) == 0: num_filters = [num_filters[-1]] + num_filters_down2 else: num_filters = [num_filters_down1[-1]] + num_filters_down2 filters_pairs_d2 = [[num_filters[i], num_filters[i + 1]] for i in range(len(num_filters) - 1)] for i, o in filters_pairs_d2: middle_layers.append(scn.SubmanifoldConvolution(3, i, o, 3, False)) middle_layers.append(scn.BatchNormReLU(o, eps=1e-3, momentum=0.99)) middle_layers.append( scn.Convolution( 3, num_filters[-1], num_filters[-1], (3, 1, 1), (2, 1, 1), bias=False)) middle_layers.append( scn.BatchNormReLU(num_filters[-1], eps=1e-3, momentum=0.99)) middle_layers.append(scn.SparseToDense(3, num_filters[-1])) self.middle_conv = Sequential(*middle_layers)
def __init__(self, inputshape, reps, nin_features, nout_features, nplanes, show_sizes): nn.Module.__init__(self) """ inputs ------ inputshape [list of int]: dimensions of the matrix or image reps [int]: number of residual modules per layer (for both encoder and decoder) nin_features [int]: number of features in the first convolutional layer nout_features [int]: number of features that feed into the regression layer nPlanes [int]: the depth of the U-Net show_sizes [bool]: if True, print sizes while running forward """ self._mode = 0 self._dimension = 2 self._inputshape = inputshape if len(self._inputshape) != self._dimension: raise ValueError( "expected inputshape to contain size of 2 dimensions only." + "given %d values" % (len(self._inputshape))) self._reps = reps self._nin_features = nin_features self._nout_features = nout_features self._nplanes = [ nin_features, 2 * nin_features, 3 * nin_features, 4 * nin_features, 5 * nin_features ] self._show_sizes = show_sizes self.sparseModel = scn.Sequential().add( scn.InputLayer( self._dimension, self._inputshape, mode=self._mode)).add( scn.SubmanifoldConvolution( self._dimension, 1, self._nin_features, 3, False)).add( scn.UNet( self._dimension, self._reps, self._nplanes, residual_blocks=True, downsample=[2, 2])).add( scn.BatchNormReLU(self._nin_features)).add( scn.OutputLayer(self._dimension)) self.input = scn.InputLayer(self._dimension, self._inputshape, mode=self._mode) self.conv1 = scn.SubmanifoldConvolution(self._dimension, 1, self._nin_features, 3, False) self.unet = scn.UNet(self._dimension, self._reps, self._nplanes, residual_blocks=True, downsample=[2, 2]) self.batchnorm = scn.BatchNormReLU(self._nin_features) self.output = scn.OutputLayer(self._dimension) self.conv2 = scn.SubmanifoldConvolution(self._dimension, self._nin_features, 1, 3, False)
def __init__(self, inplanes, kernel, dim=3): torch.nn.Module.__init__(self) self.bnr1 = scn.BatchNormReLU(inplanes) self.subconv1 = scn.SubmanifoldConvolution(dim, inplanes, inplanes, kernel, 0) self.bnr2 = scn.BatchNormReLU(inplanes) self.subconv2 = scn.SubmanifoldConvolution(dim, inplanes, inplanes, kernel, 0) self.add = scn.AddTable()
def res(m, dimension, a, b): m.add(scn.ConcatTable() .add(scn.Identity() if a == b else scn.NetworkInNetwork(a, b, False)) .add(scn.Sequential() .add(scn.BatchNormReLU(a)) .add(scn.SubmanifoldConvolution(dimension, a, b, 3, False)) .add(scn.BatchNormReLU(b)) .add(scn.SubmanifoldConvolution(dimension, b, b, 3, False))))\ .add(scn.AddTable())
def SparseResNet(dimension, nInputPlanes, layers): import sparseconvnet as scn """ pre-activated ResNet e.g. layers = {{'basic',16,2,1},{'basic',32,2}} """ nPlanes = nInputPlanes m = scn.Sequential() def residual(nIn, nOut, stride): if stride > 1: return scn.Convolution(dimension, nIn, nOut, 2, stride, False) elif nIn != nOut: return scn.NetworkInNetwork(nIn, nOut, False) else: return scn.Identity() for n, reps, stride in layers: for rep in range(reps): if rep == 0: m.add(scn.BatchNormReLU(nPlanes)) tab = scn.ConcatTable() tab_seq = scn.Sequential() if stride == 1: tab_seq.add( scn.SubmanifoldConvolution(dimension, nPlanes, n, 3, False)) else: tab_seq.add( scn.Convolution(dimension, nPlanes, n, 2, stride, False)) tab_seq.add(scn.BatchNormReLU(n)) tab_seq.add( scn.SubmanifoldConvolution(dimension, n, n, 3, False)) tab.add(tab_seq) tab.add(residual(nPlanes, n, stride)) m.add(tab) else: tab = scn.ConcatTable() tab_seq = scn.Sequential() tab_seq.add(scn.BatchNormReLU(nPlanes)) tab_seq.add( scn.SubmanifoldConvolution(dimension, nPlanes, n, 3, False)) tab_seq.add(scn.BatchNormReLU(n)) tab_seq.add( scn.SubmanifoldConvolution(dimension, n, n, 3, False)) tab.add(tab_seq) tab.add(scn.Identity()) m.add(tab) nPlanes = n m.add(scn.AddTable()) m.add(scn.BatchNormReLU(nPlanes)) return m
def block(m, a, b): if residual_blocks: #ResNet style blocks m.add(scn.ConcatTable().add(scn.Identity( ) if a == b else scn.NetworkInNetwork(a, b, False)).add( scn.Sequential().add(scn.BatchNormReLU(a)).add( scn.SubmanifoldConvolution(dimension, a, b, 3, False)).add( scn.BatchNormReLU(b)).add( scn.SubmanifoldConvolution(dimension, b, b, 3, False)))).add( scn.AddTable()) else: #VGG style blocks m.add(scn.Sequential().add(scn.BatchNormReLU(a)).add( scn.SubmanifoldConvolution(dimension, a, b, 3, False)))
def conv_op3d(kernel, n_filters, sparse=False): if sparse: m = torch.nn.ModuleList() m.append( scn.SubmanifoldConvolution(dimension=3, nIn=n_filters, nOut=n_filters, filter_size=kernel, bias=True)) m.append(scn.BatchNormReLU(n_filters)) return m else: m = torch.nn.ModuleList() m.append( torch.nn.Conv3d(in_channels=n_filters, out_channels=n_filters, kernel_size=kernel, bias=True)) m.append(torch.nn.BatchNorm3d(n_filters)) m.append(torch.nn.ReLU()) return m
def __init__(self, flags): import sparseconvnet as scn super(UResNet, self).__init__() self._flags = flags dimension = flags.DATA_DIM reps = 2 # Conv block repetition factor kernel_size = 2 # Use input_spatial_size method for other values? m = flags.URESNET_FILTERS # Unet number of features nPlanes = [i * m for i in range(1, flags.URESNET_NUM_STRIDES + 1) ] # UNet number of features per level # nPlanes = [(2**i) * m for i in range(1, num_strides+1)] # UNet number of features per level nInputFeatures = 1 self.sparseModel = scn.Sequential().add( scn.InputLayer(dimension, flags.SPATIAL_SIZE, mode=3)).add( scn.SubmanifoldConvolution( dimension, nInputFeatures, m, 3, False)).add( # Kernel size 3, no bias scn.UNet(dimension, reps, nPlanes, residual_blocks=True, downsample=[kernel_size, 2]) ).add( # downsample = [filter size, filter stride] scn.BatchNormReLU(m)).add(scn.OutputLayer(dimension)) self.linear = torch.nn.Linear(m, flags.NUM_CLASS)
def _make_skip_layer(self, inplanes, planes): layers = scn.Sequential( scn.NetworkInNetwork(inplanes, planes, False), scn.BatchNormReLU(planes) ) return layers
def __init__(self, n_classes): nn.Module.__init__(self) self.n_classes = n_classes self.sparseModel = scn.Sequential( # 255x255 scn.SubmanifoldConvolution( 2, 2, 16, 3, False), # dimension, nIn, nOut, filter_size, bias scn.MaxPooling(2, 3, 2), # dimension, pool_size, pool_stride # 127x127 scn.SparseResNet( 2, 16, [ # dimension, nInputPlanes, layers ['b', 16, 2, 1], # 63x63 # blockType, n, reps, stride ['b', 32, 2, 2], # 63x63 ['b', 48, 2, 2], # 31x31 ['b', 96, 2, 2], # 15x15 ['b', 144, 2, 2], # 7x7 ['b', 192, 2, 2] ]), # 3x3 scn.Convolution( 2, 192, 256, 3, 1, False ), # 1x1 # dimension, nIn, nOut, filter_size, filter_stride, bias scn.BatchNormReLU(256)) # dimension, nPlanes self.sparse_to_dense = scn.SparseToDense(2, 256) #self.spatial_size= self.sc.input_spatial_size(torch.LongTensor([1, 1])) self.spatial_size = self.sparseModel.input_spatial_size( torch.LongTensor([1, 1])) self.inputLayer = scn.InputLayer(2, self.spatial_size, 2) # dimension, spatial_size, mode self.linear = nn.Linear(256, self.n_classes) print(self.spatial_size)
def __init__(self, nr_classes): super(FBSparseVGGTest, self).__init__() self.sparseModel = scn.SparseVggNet( 2, nInputPlanes=2, layers=[['C', 16], ['C', 16], 'MP', ['C', 32], ['C', 32], 'MP', ['C', 64], ['C', 64], 'MP', ['C', 128], ['C', 128], 'MP', ['C', 256], ['C', 256], 'MP', ['C', 512]]).add( scn.Convolution(2, 512, 256, 3, filter_stride=2, bias=False)).add( scn.BatchNormReLU(256)).add( scn.SparseToDense(2, 256)) cnn_spatial_output_size = [2, 3] self.spatial_size = self.sparseModel.input_spatial_size( torch.LongTensor(cnn_spatial_output_size)) self.inputLayer = scn.InputLayer(dimension=2, spatial_size=self.spatial_size, mode=2) self.linear_input_features = cnn_spatial_output_size[ 0] * cnn_spatial_output_size[1] * 256 self.linear = nn.Linear(self.linear_input_features, nr_classes)
def __init__(self, inplanes, outplanes, batch_norm, leaky_relu): nn.Module.__init__(self) self.batch_norm = batch_norm self.leaky_relu = leaky_relu self.conv1 = scn.SubmanifoldConvolution(dimension=3, nIn = inplanes, nOut = outplanes, filter_size = 3, bias=False) if self.batch_norm: if self.leaky_relu: self.bn1 = scn.BatchNormLeakyReLU(outplanes) else: self.bn1 = scn.BatchNormReLU(outplanes) self.conv2 = scn.SubmanifoldConvolution(dimension=3, nIn = outplanes, nOut = outplanes, filter_size = 3, bias = False) if self.batch_norm: self.bn2 = scn.BatchNormalization(outplanes) self.residual = scn.Identity() if self.leaky_relu: self.relu = scn.LeakyReLU() else: self.relu = scn.ReLU() self.add = scn.AddTable()
def __init__(self, is_3d, num_strides=3, base_num_outputs=16, num_classes=3, spatialSize=192): nn.Module.__init__(self) dimension = 3 if is_3d else 2 reps = 2 # Conv block repetition factor kernel_size = 2 # Use input_spatial_size method for other values? m = base_num_outputs # Unet number of features nPlanes = [i * m for i in range(1, num_strides + 1) ] # UNet number of features per level # nPlanes = [(2**i) * m for i in range(1, num_strides+1)] # UNet number of features per level nInputFeatures = 1 self.sparseModel = scn.Sequential().add( scn.InputLayer(dimension, spatialSize, mode=3)).add( scn.SubmanifoldConvolution( dimension, nInputFeatures, m, 3, False)).add( # Kernel size 3, no bias UNet(dimension, reps, nPlanes, residual_blocks=True, downsample=[kernel_size, 2]) ).add( # downsample = [filter size, filter stride] scn.BatchNormReLU(m)).add(scn.OutputLayer(dimension)) self.linear = nn.Linear(m, num_classes)
def __init__(self): super(get_model, self).__init__() self.part_num = 3 self.resolution = 150 self.dimension = 3 self.reps = 2 #Conv block repetition factor self.m = 32 #Unet number of features self.nPlanes = [ self.m, 2 * self.m, 3 * self.m, 4 * self.m, 5 * self.m ] #UNet number of features per level self.sparseModel = scn.Sequential().add( scn.InputLayer( self.dimension, torch.LongTensor([self.resolution * 8 + 15] * 3), mode=3)).add( scn.SubmanifoldConvolution( self.dimension, 1, self.m, 3, False)).add( scn.FullyConvolutionalNet( self.dimension, self.reps, self.nPlanes, residual_blocks=False, downsample=[3, 2])).add( scn.BatchNormReLU(sum(self.nPlanes))).add( scn.OutputLayer(self.dimension)) self.nc = 64 self.linear = nn.Linear(sum(self.nPlanes), self.nc) self.convs1 = torch.nn.Conv1d(self.nc * 3, 128, 1) self.convs2 = torch.nn.Conv1d(128, 64, 1) self.convs3 = torch.nn.Conv1d(64, self.part_num, 1) self.bns1 = nn.BatchNorm1d(128) self.bns2 = nn.BatchNorm1d(64)
def __init__(self): nn.Module.__init__(self) self.sparseModel = scn.Sequential( scn.SubmanifoldConvolution( 3, 1, 64, 7, False), # sscn(dimension, nIn, nOut, filter_size, bias) scn.BatchNormReLU(64), scn.MaxPooling(3, 3, 2), # MaxPooling(dimension, pool_size, pool_stride) scn.SparseResNet( 3, 64, [ # SpraseResNet(dimension, nInputPlanes, layers=[]) ['b', 64, 2, 1], # [block_type, nOut, rep, stride] ['b', 64, 2, 1], ['b', 128, 2, 2], ['b', 128, 2, 2], ['b', 256, 2, 2], ['b', 256, 2, 2], ['b', 512, 2, 2], ['b', 512, 2, 2] ]), scn.SparseToDense(3, 256)) self.avgpool = nn.AdaptiveAvgPool3d((1, 1, 1)) # self.spatial_size= self.sparseModel.input_spatial_size(torch.LongTensor([1, 1])) self.spatial_size = torch.LongTensor([101, 101, 101]) self.inputLayer = scn.InputLayer(3, self.spatial_size, mode=3)
def __init__(self, flags): torch.nn.Module.__init__(self) import sparseconvnet as scn self._flags = flags dimension = self._flags.DATA_DIM num_class = self._flags.NUM_CLASS image_size = self._flags.SPATIAL_SIZE num_filter = self._flags.BASE_NUM_FILTERS assert image_size == 128 net = scn.Sequential() net.add(scn.InputLayer(dimension, image_size, mode=3)) net.add(scn.SubmanifoldConvolution(dimension, 1, num_filter, 3, False)) net.add(scn.MaxPooling(dimension, 2, 2)) net.add( SparseResNet(dimension, num_filter, [[num_filter * 1, 2, 1], [num_filter * 2, 2, 2], [num_filter * 4, 2, 2], [num_filter * 8, 2, 2]])) net.add( scn.Convolution(dimension, num_filter * 8, num_filter * 16, 3, 1, False)) net.add(scn.BatchNormReLU(num_filter * 16)) net.add(scn.SparseToDense(dimension, num_filter * 16)) net.add(torch.nn.AvgPool3d(6)) self._net = net self.linear = torch.nn.Linear(num_filter * 16, num_class)
def __init__(self, dimension=3, size=1536, nFeatures=16, depth=5, nClasses=1): super(UResNet, self).__init__() self.dimension = dimension self.size = size self.nFeatures = nFeatures self.depth = depth self.nClasses = nClasses reps = 2 # Conv block repetition factor kernel_size = 2 # Use input_spatial_size method for other values? m = nFeatures # Unet number of features nPlanes = [i * m for i in range(1, depth + 1) ] # UNet number of features per level # nPlanes = [(2**i) * m for i in range(1, num_strides+1)] # UNet number of features per level nInputFeatures = 6 self.sparseModel = scn.Sequential().add( scn.InputLayer(dimension, size, mode=3)).add( scn.SubmanifoldConvolution( dimension, nInputFeatures, m, 3, False)).add( # Kernel size 3, no bias scn.UNet(dimension, reps, nPlanes, residual_blocks=True, downsample=[kernel_size, 2]) ).add( # downsample = [filter size, filter stride] scn.BatchNormReLU(m)).add(scn.OutputLayer(dimension)) # self.linear = torch.nn.Linear(m, nClasses) self.linear = torch.nn.Sequential(torch.nn.Linear(m, m // 2), torch.nn.ReLU(0.1), torch.nn.Linear(m // 2, nClasses))
def __init__(self, inplanes, outplanes, nplanes=1): nn.Module.__init__(self) self.conv1 = scn.SubmanifoldConvolution(dimension=3, nIn = inplanes, nOut = outplanes, filter_size = [nplanes,3,3], bias=False) # if FLAGS.BATCH_NORM: self.bn1 = scn.BatchNormReLU(outplanes) self.conv2 = scn.SubmanifoldConvolution(dimension=3, nIn = outplanes, nOut = outplanes, filter_size = [nplanes,3,3], bias = False) # if FLAGS.BATCH_NORM: self.bn2 = scn.BatchNormalization(outplanes) self.residual = scn.Identity() self.relu = scn.ReLU() self.add = scn.AddTable()
def __init__(self, *, inplanes, outplanes, nplanes=1, params): nn.Module.__init__(self) self.conv1 = scn.SubmanifoldConvolution(dimension=3, nIn=inplanes, nOut=outplanes, filter_size=[nplanes, 3, 3], bias=params.use_bias) self.do_batch_norm = False if params.batch_norm: self.do_batch_norm = True self.bn1 = scn.BatchNormReLU(outplanes) self.conv2 = scn.SubmanifoldConvolution(dimension=3, nIn=outplanes, nOut=outplanes, filter_size=[nplanes, 3, 3], bias=False) if params.batch_norm: self.bn2 = scn.BatchNormalization(outplanes) self.residual = scn.Identity() self.relu = scn.ReLU() self.add = scn.AddTable()
def __init__(self, cfg): import sparseconvnet as scn super(UResNet, self).__init__() self._model_config = cfg['modules']['uresnet'] self._dimension = self._model_config.get('data_dim', 3) num_strides = self._model_config.get('num_strides', 5) spatial_size = self._model_config.get('spatial_size', 512) num_classes = self._model_config.get('num_classes', 5) m = self._model_config.get('filters', 16) # Unet number of features nInputFeatures = self._model_config.get('features', 1) reps = 2 # Conv block repetition factor kernel_size = 2 # Use input_spatial_size method for other values? nPlanes = [i * m for i in range(1, num_strides + 1) ] # UNet number of features per level # nPlanes = [(2**i) * m for i in range(1, num_strides+1)] # UNet number of features per level self.sparseModel = scn.Sequential().add( scn.InputLayer(self._dimension, spatial_size, mode=3)).add( scn.SubmanifoldConvolution( self._dimension, nInputFeatures, m, 3, False)).add( # Kernel size 3, no bias scn.UNet(self._dimension, reps, nPlanes, residual_blocks=True, downsample=[kernel_size, 2]) ).add( # downsample = [filter size, filter stride] scn.BatchNormReLU(m)).add( scn.OutputLayer(self._dimension)) self.linear = torch.nn.Linear(m, num_classes)
def bar(nPlanes, bias): m = scn.Sequential() m.add(scn.BatchNormReLU(nPlanes)) m.add(scn.NetworkInNetwork( nPlanes, nClasses, bias)) #accumulte softmax input, only one set of biases return m
def __init__(self, full_scale=127, use_normal=False): nn.Module.__init__(self) dimension = 3 m = 32 # 16 or 32 residual_blocks = True #True or False block_reps = 2 #Conv block repetition factor: 1 or 2 blocks = [['b', m * k, 2, 2] for k in [1, 2, 3, 4, 5]] self.num_final_channels = m * len(blocks) self.sparseModel = scn.Sequential().add( scn.InputLayer(dimension, full_scale, mode=4)).add( scn.SubmanifoldConvolution( dimension, 3 + 3 * int(use_normal), m, 3, False)).add(scn.MaxPooling(dimension, 3, 2)).add( scn.SparseResNet(dimension, m, blocks)).add( scn.BatchNormReLU(self.num_final_channels)).add( scn.SparseToDense(dimension, self.num_final_channels)) self.num_labels = 20 self.label_encoder = nn.Sequential(nn.Linear(self.num_labels, 64), nn.ReLU()) #self.pred = nn.Linear(m * len(blocks), 1) self.pred = nn.Sequential(nn.Linear(self.num_final_channels + 64, 64), nn.ReLU(), nn.Linear(64, 1)) return
def SparseResNet(dimension, nInputPlanes, layers, mom=0.99): """ pre-activated ResNet e.g. layers = {{'basic',16,2,1},{'basic',32,2}} """ nPlanes = nInputPlanes m = scn.Sequential() def residual(nIn, nOut, stride): if stride > 1: return scn.Convolution(dimension, nIn, nOut, 3, stride, False) elif nIn != nOut: return scn.NetworkInNetwork(nIn, nOut, False) else: return scn.Identity() for blockType, n, reps, stride in layers: for rep in range(reps): if blockType[0] == 'b': # basic block if rep == 0: m.add(scn.BatchNormReLU(nPlanes, momentum=mom, eps=1e-5)) m.add(scn.ConcatTable().add(scn.Sequential().add( scn.SubmanifoldConvolution(dimension, nPlanes, n, 3, False) if stride == 1 else scn.Convolution( dimension, nPlanes, n, 3, stride, False)).add( scn.BatchNormReLU( n, momentum=mom, eps=1e-5)).add( scn.SubmanifoldConvolution( dimension, n, n, 3, False))).add( residual(nPlanes, n, stride))) else: m.add(scn.ConcatTable().add(scn.Sequential().add( scn.BatchNormReLU( nPlanes, momentum=mom, eps=1e-5)).add( scn.SubmanifoldConvolution( dimension, nPlanes, n, 3, False)).add( scn.BatchNormReLU( n, momentum=mom, eps=1e-5)).add( scn.SubmanifoldConvolution( dimension, n, n, 3, False))).add( scn.Identity())) nPlanes = n m.add(scn.AddTable()) m.add(scn.BatchNormReLU(nPlanes, momentum=mom, eps=1e-5)) return m
def foo(nPlanes): m = scn.Sequential() for _ in range(reps): m.add(scn.BatchNormReLU(nPlanes)) m.add( scn.SubmanifoldConvolution(dimension, nPlanes, nPlanes, 3, False)) return m
def __init__(self, dimension, nPlanes_down, nPlanes_up, reps, type, predict=False, nClasses=None, extract=False, kernel_size=None): super(up, self).__init__() self.dimension = dimension self.type = type self.predict = predict self.extract = extract self.kernel_size = kernel_size if type == 'c': self.upsample = scn.Sequential().add(scn.BatchNormReLU(nPlanes_down)).add(scn.DenseDeconvolution(dimension, nPlanes_down, nPlanes_up, 2, 2, False)) elif type == 'v': self.upsample = scn.Sequential().add(scn.BatchNormReLU(nPlanes_down)).add(scn.Deconvolution(dimension, nPlanes_down, nPlanes_up, 2, 2, False)) self.conv = scn.Sequential() for i in range(reps): res(self.conv, dimension, nPlanes_up, nPlanes_up) if predict: self.Linear = scn.Sequential().add(scn.BatchNormReLU(nPlanes_up)).add(scn.Linear(dimension, nPlanes_up, nClasses))
def __init__(self): nn.Module.__init__(self) self.sparseModel = scn.SparseVggNet( 2, 3, [['C', 16], ['C', 16], 'MP', ['C', 32], ['C', 32], 'MP', ['C', 48], ['C', 48], 'MP', ['C', 64], ['C', 64], 'MP', ['C', 96], ['C', 96] ]).add(scn.Convolution(2, 96, 128, 3, 2, False)).add( scn.BatchNormReLU(128)).add(scn.SparseToDense(2, 128)) self.linear = nn.Linear(128, 3755)