def __init__(self, cfg): super(PPN, self).__init__() import sparseconvnet as scn model_config = cfg['modules']['ppn'] self._model_config = model_config dimension = model_config['data_dim'] kernel_size = 2 # Use input_spatial_size method for other values? m = model_config['filters'] # Unet number of features nPlanes = [i * m for i in range(1, model_config['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 downsample = [kernel_size, 2] # downsample = [filter size, filter stride] # PPN stuff self.half_stride = int(model_config['num_strides'] / 2.0) self.ppn1_conv = scn.SubmanifoldConvolution(dimension, nPlanes[-1], nPlanes[-1], 3, False) self.ppn1_scores = scn.SubmanifoldConvolution(dimension, nPlanes[-1], 2, 3, False) self.selection1 = Selection() self.selection2 = Selection() self.unpool1 = scn.Sequential() for i in range(model_config['num_strides'] - self.half_stride - 1): self.unpool1.add( scn.UnPooling(dimension, downsample[0], downsample[1])) self.unpool2 = scn.Sequential() for i in range(self.half_stride): self.unpool2.add( scn.UnPooling(dimension, downsample[0], downsample[1])) middle_filters = int(m * self.half_stride * (self.half_stride + 1) / 2.0) self.ppn2_conv = scn.SubmanifoldConvolution(dimension, middle_filters, middle_filters, 3, False) self.ppn2_scores = scn.SubmanifoldConvolution(dimension, middle_filters, 2, 3, False) self.multiply1 = Multiply() self.multiply2 = Multiply() self.ppn3_conv = scn.SubmanifoldConvolution(dimension, nPlanes[0], nPlanes[0], 3, False) self.ppn3_pixel_pred = scn.SubmanifoldConvolution( dimension, nPlanes[0], dimension, 3, False) self.ppn3_scores = scn.SubmanifoldConvolution(dimension, nPlanes[0], 2, 3, False) self.ppn3_type = scn.SubmanifoldConvolution( dimension, nPlanes[0], model_config['num_classes'], 3, False) self.add_labels1 = AddLabels() self.add_labels2 = AddLabels()
def MultiscaleShapeContext(dimension, n_features=1, n_layers=3, shape_context_size=3, downsample_size=2, downsample_stride=2, bn=True): m = sparseconvnet.Sequential() if n_layers == 1: m.add( sparseconvnet.ShapeContext(dimension, n_features, shape_context_size)) else: m.add(sparseconvnet.ConcatTable().add( sparseconvnet.ShapeContext( dimension, n_features, shape_context_size)).add( sparseconvnet.Sequential( sparseconvnet.AveragePooling(dimension, downsample_size, downsample_stride), MultiscaleShapeContext(dimension, n_features, n_layers - 1, shape_context_size, downsample_size, downsample_stride, False), sparseconvnet.UnPooling(dimension, downsample_size, downsample_stride)))).add( sparseconvnet.JoinTable()) if bn: m.add( sparseconvnet.BatchNormalization(shape_context_size**dimension * n_features * n_layers)) return m
def baz(depth, nPlanes): if depth == 1: return scn.Sequential().add(foo(nPlanes)).add(bar(nPlanes, True)) else: return scn.Sequential().add(foo(nPlanes)).add(scn.ConcatTable().add(bar(nPlanes,False)).add( scn.Sequential()\ .add(scn.BatchNormReLU(nPlanes))\ .add(scn.Convolution(dimension, nPlanes, l(nPlanes), 2, 2, False))\ .add(baz(depth-1,l(nPlanes)))\ .add(scn.UnPooling(dimension, 2, 2)) )).add(scn.AddTable())
def __init__(self, options): nn.Module.__init__(self) self.options = options dimension = 3 self.input_layer = scn.InputLayer(dimension, options.inputScale, mode=4) self.conv = scn.SubmanifoldConvolution(dimension, 1, options.numNeighbors, 3, bias=False) self.pool_1 = scn.AveragePooling(dimension, 2, 2) self.pool_2 = scn.AveragePooling(dimension, 4, 4) self.pool_3 = scn.AveragePooling(dimension, 8, 8) self.pool_4 = scn.AveragePooling(dimension, 16, 16) self.pool_5 = scn.AveragePooling(dimension, 32, 32) self.unpool_1 = scn.UnPooling(dimension, 2, 2) self.unpool_2 = scn.UnPooling(dimension, 4, 4) self.unpool_3 = scn.UnPooling(dimension, 8, 8) self.unpool_4 = scn.UnPooling(dimension, 16, 16) self.unpool_5 = scn.UnPooling(dimension, 32, 32) with torch.no_grad(): weight = torch.zeros(27, 1, options.numNeighbors).cuda() if options.numNeighbors == 6: offsets = [4, 22, 10, 16, 12, 14] pass for index, offset in enumerate(offsets): weight[offset, 0, index] = 1 continue self.conv.weight = nn.Parameter(weight) pass self.output_layer = scn.OutputLayer(dimension) return
def baz(nPlanes): m=scn.Sequential() foo(m,nPlanes[0]) if len(nPlanes)==1: bar(m,nPlanes[0],True) else: a=scn.Sequential() bar(a,nPlanes,False) b=scn.Sequential( scn.BatchNormLeakyReLU(nPlanes,leakiness=leakiness), scn.Convolution(dimension, nPlanes[0], nPlanes[1], downsample[0], downsample[1], False), baz(nPlanes[1:]), scn.UnPooling(dimension, downsample[0], downsample[1])) m.add(ConcatTable(a,b)) m.add(scn.AddTable())
def U(nPlanes): #Recursive function m = scn.Sequential() if len(nPlanes) == 1: for _ in range(reps): block(m, nPlanes[0], nPlanes[0]) else: m = scn.Sequential() for _ in range(reps): block(m, nPlanes[0], nPlanes[0]) m.add(scn.ConcatTable().add(scn.Identity()).add( scn.Sequential().add(scn.BatchNormReLU(nPlanes[0])).add( scn.Convolution(dimension, nPlanes[0], nPlanes[1], downsample[0], downsample[1], False)).add(U(nPlanes[1:])).add( scn.UnPooling(dimension, downsample[0], downsample[1])))) m.add(scn.JoinTable()) return m
def __init__(self, cfg): super(PPN, self).__init__() import sparseconvnet as scn self._model_config = cfg['ppn'] self._dimension = self._model_config.get('data_dim', 3) self._num_strides = self._model_config.get('num_strides', 5) m = self._model_config.get('filters', 16) # Unet number of features num_classes = self._model_config.get('num_classes', 5) self._downsample_ghost = self._model_config.get( 'downsample_ghost', False) self._use_encoding = self._model_config.get('use_encoding', False) self._use_true_ghost_mask = self._model_config.get( 'use_true_ghost_mask', False) self._ppn_num_conv = self._model_config.get('ppn_num_conv', 1) self._ppn1_size = self._model_config.get('ppn1_size', -1) self._ppn2_size = self._model_config.get('ppn2_size', -1) self._spatial_size = self._model_config.get('spatial_size', 512) self.ppn1_stride, self.ppn2_stride = define_ppn12( self._ppn1_size, self._ppn2_size, self._spatial_size, self._num_strides) kernel_size = 2 # Use input_spatial_size method for other values? nPlanes = [i * m for i in range(1, self._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 downsample = [kernel_size, 2] # downsample = [filter size, filter stride] # PPN stuff #self.half_stride = int((self._num_strides-1)/2.0) #self.half_stride2 = int(self._num_strides/2.0) self.ppn1_conv = scn.Sequential() for i in range(self._ppn_num_conv): self.ppn1_conv.add( scn.SubmanifoldConvolution( self._dimension, nPlanes[self.ppn1_stride - self._num_strides], nPlanes[self.ppn1_stride - self._num_strides], 3, False)) self.ppn1_scores = scn.SubmanifoldConvolution( self._dimension, nPlanes[self.ppn1_stride - self._num_strides], 2, 3, False) self.selection1 = Selection() self.selection2 = Selection() self.unpool1 = scn.Sequential() for i in range(self.ppn1_stride - self.ppn2_stride): self.unpool1.add( scn.UnPooling(self._dimension, downsample[0], downsample[1])) self.unpool2 = scn.Sequential() for i in range(self.ppn2_stride): self.unpool2.add( scn.UnPooling(self._dimension, downsample[0], downsample[1])) #middle_filters = int(m * self.half_stride * (self.half_stride + 1) / 2.0) #print(middle_filters, (self.ppn2_stride+1)*m) middle_filters = (self.ppn2_stride + 1) * m self.ppn2_conv = scn.Sequential() for i in range(self._ppn_num_conv): self.ppn2_conv.add( scn.SubmanifoldConvolution(self._dimension, middle_filters, middle_filters, 3, False)) self.ppn2_scores = scn.SubmanifoldConvolution(self._dimension, middle_filters, 2, 3, False) self.multiply1 = Multiply() self.multiply2 = Multiply() self.ppn3_conv = scn.Sequential() for i in range(self._ppn_num_conv): self.ppn3_conv.add( scn.SubmanifoldConvolution(self._dimension, nPlanes[0], nPlanes[0], 3, False)) self.ppn3_pixel_pred = scn.SubmanifoldConvolution( self._dimension, nPlanes[0], self._dimension, 3, False) self.ppn3_scores = scn.SubmanifoldConvolution(self._dimension, nPlanes[0], 2, 3, False) self.ppn3_type = scn.SubmanifoldConvolution(self._dimension, nPlanes[0], num_classes, 3, False) self.add_labels1 = AddLabels() self.add_labels2 = AddLabels() self.ghost_mask = GhostMask(self._dimension)
def __init__(self, cfg): super(PPNUResNet, self).__init__() import sparseconvnet as scn self._model_config = cfg['modules']['uresnet_ppn_type'] self._dimension = self._model_config.get('data_dim', 3) nInputFeatures = self._model_config.get('features', 1) 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 num_strides = self._model_config.get('num_strides', 5) 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 downsample = [kernel_size, 2] # downsample = [filter size, filter stride] self.last = None leakiness = 0 def block(m, a, b): # ResNet style blocks m.add(scn.ConcatTable().add(scn.Identity( ) if a == b else scn.NetworkInNetwork(a, b, False)).add( scn.Sequential().add( scn.BatchNormLeakyReLU(a, leakiness=leakiness)).add( scn.SubmanifoldConvolution( self._dimension, a, b, 3, False)).add( scn.BatchNormLeakyReLU( b, leakiness=leakiness)).add( scn.SubmanifoldConvolution( self._dimension, b, b, 3, False)))).add(scn.AddTable()) self.input = scn.Sequential().add( scn.InputLayer(self._dimension, spatial_size, mode=3)).add( scn.SubmanifoldConvolution(self._dimension, nInputFeatures, m, 3, False)) # Kernel size 3, no bias self.concat = scn.JoinTable() # Encoding self.bn = scn.BatchNormLeakyReLU(nPlanes[0], leakiness=leakiness) # self.encoding = [] self.encoding_block = scn.Sequential() self.encoding_conv = scn.Sequential() module = scn.Sequential() for i in range(num_strides): module = scn.Sequential() for _ in range(reps): block(module, nPlanes[i], nPlanes[i]) self.encoding_block.add(module) module2 = scn.Sequential() if i < num_strides - 1: module2.add( scn.BatchNormLeakyReLU( nPlanes[i], leakiness=leakiness)).add( scn.Convolution(self._dimension, nPlanes[i], nPlanes[i + 1], downsample[0], downsample[1], False)) # self.encoding.append(module) self.encoding_conv.add(module2) self.encoding = module # Decoding self.decoding_conv, self.decoding_blocks = scn.Sequential( ), scn.Sequential() for i in range(num_strides - 2, -1, -1): module1 = scn.Sequential().add( scn.BatchNormLeakyReLU(nPlanes[i + 1], leakiness=leakiness)).add( scn.Deconvolution( self._dimension, nPlanes[i + 1], nPlanes[i], downsample[0], downsample[1], False)) self.decoding_conv.add(module1) module2 = scn.Sequential() for j in range(reps): block(module2, nPlanes[i] * (2 if j == 0 else 1), nPlanes[i]) self.decoding_blocks.add(module2) self.output = scn.Sequential().add(scn.BatchNormReLU(m)).add( scn.OutputLayer(self._dimension)) self.linear = torch.nn.Linear(m, num_classes) # PPN stuff self.half_stride = int(num_strides / 2.0) self.ppn1_conv = scn.SubmanifoldConvolution(self._dimension, nPlanes[-1], nPlanes[-1], 3, False) self.ppn1_scores = scn.SubmanifoldConvolution(self._dimension, nPlanes[-1], 2, 3, False) self.selection1 = Selection() self.selection2 = Selection() self.unpool1 = scn.Sequential() for i in range(num_strides - self.half_stride - 1): self.unpool1.add( scn.UnPooling(self._dimension, downsample[0], downsample[1])) self.unpool2 = scn.Sequential() for i in range(self.half_stride): self.unpool2.add( scn.UnPooling(self._dimension, downsample[0], downsample[1])) middle_filters = int(m * self.half_stride * (self.half_stride + 1) / 2.0) self.ppn2_conv = scn.SubmanifoldConvolution(self._dimension, middle_filters, middle_filters, 3, False) self.ppn2_scores = scn.SubmanifoldConvolution(self._dimension, middle_filters, 2, 3, False) self.multiply1 = Multiply() self.multiply2 = Multiply() self.ppn3_conv = scn.SubmanifoldConvolution(self._dimension, nPlanes[0], nPlanes[0], 3, False) self.ppn3_pixel_pred = scn.SubmanifoldConvolution( self._dimension, nPlanes[0], self._dimension, 3, False) self.ppn3_scores = scn.SubmanifoldConvolution(self._dimension, nPlanes[0], 2, 3, False) self.ppn3_type = scn.SubmanifoldConvolution(self._dimension, nPlanes[0], num_classes, 3, False) self.add_labels1 = AddLabels() self.add_labels2 = AddLabels()
def __init__(self, options): nn.Module.__init__(self) self.options = options dimension = 3 m = 32 # 16 or 32 residual_blocks = True #True or False block_reps = 2 #Conv block repetition factor: 1 or 2 self.outputs = [] def hook(module, input, output): self.outputs.append(output) return self.sparseModel = scn.Sequential().add( scn.InputLayer(dimension, options.inputScale, mode=4)).add( scn.SubmanifoldConvolution( dimension, 3 + 3 * int('normal' in self.options.suffix), m, 3, False)).add( scn.UNet(dimension, block_reps, [m, 2 * m, 3 * m, 4 * m, 5 * m, 6 * m, 7 * m], residual_blocks)).add(scn.BatchNormReLU(m)) #print(self.sparseModel[2]) #exit(1) if options.numScales >= 2: #list(self.sparseModel[2][1].children())[1][2][3].register_forward_hook(hook) list(self.sparseModel[2] [4].children())[1][3].register_forward_hook(hook) pass if options.numScales >= 3: list(list(self.sparseModel[2][4].children())[1][2] [4].children())[1][3].register_forward_hook(hook) pass if options.numScales >= 4: list( list( list( self.sparseModel[2][4].children())[1][2][4].children()) [1][2][4].children())[1][3].register_forward_hook(hook) pass if options.numScales >= 5: list( list( list( list(self.sparseModel[2][4].children())[1][2] [4].children())[1][2][4].children())[1][2] [4].children())[1][3].register_forward_hook(hook) pass if options.numScales >= 6: list( list( list( list( list(self.sparseModel[2][4].children())[1][2] [4].children())[1][2][4].children())[1][2] [4].children())[1][2] [4].children())[1][3].register_forward_hook(hook) pass # list(list(list(list(list(self.sparseModel[2][1].children())[1][2][1].children())[1][2][1].children())[1][2][1].children())[1][2][1].children())[1][2][3].register_forward_hook(hook) # list(list(list(list(self.sparseModel[2][1].children())[1][2][1].children())[1][2][1].children())[1][2][1].children())[1][2][3].register_forward_hook(hook) # list(list(list(self.sparseModel[2][1].children())[1][2][1].children())[1][2][1].children())[1][2][3].register_forward_hook(hook) # list(list(self.sparseModel[2][1].children())[1][2][1].children())[1][2][3].register_forward_hook(hook) # list(self.sparseModel[2][1].children())[1][2][3].register_forward_hook(hook) self.sparsify = scn.Sparsify(dimension) self.output_layer = scn.OutputLayer(dimension) self.linear = nn.Linear(m, 20) self.neighbor_linear_0 = nn.Linear( m, 6 + 7 * min(self.options.numCrossScales, max(self.options.numScales - 1, 0))) self.neighbor_linear_1 = nn.Linear( m * 2, 6 + 7 * min(self.options.numCrossScales, max(self.options.numScales - 2, 0))) self.neighbor_linear_2 = nn.Linear( m * 3, 6 + 7 * min(self.options.numCrossScales, max(self.options.numScales - 3, 0))) self.neighbor_linear_3 = nn.Linear( m * 4, 6 + 7 * min(self.options.numCrossScales, max(self.options.numScales - 4, 0))) self.neighbor_linear_4 = nn.Linear( m * 5, 6 + 7 * min(self.options.numCrossScales, max(self.options.numScales - 5, 0))) self.neighbor_linear_5 = nn.Linear( m * 6, 6 + 7 * min(self.options.numCrossScales, max(self.options.numScales - 6, 0))) # self.neighbor_linear_0 = nn.Linear(m, 6 + 7 * 5) # self.neighbor_linear_1 = nn.Linear(m * 2, 6 + 7 * 4) # self.neighbor_linear_2 = nn.Linear(m * 3, 6 + 7 * 3) # self.neighbor_linear_3 = nn.Linear(m * 4, 6 + 7 * 2) # self.neighbor_linear_4 = nn.Linear(m * 5, 6 + 7 * 1) # self.neighbor_linear_5 = nn.Linear(m * 6, 6 + 7 * 0) self.unpool_1 = scn.UnPooling(dimension, 2, 2) self.unpool_2 = scn.UnPooling(dimension, 4, 4) self.unpool_3 = scn.UnPooling(dimension, 8, 8) self.unpool_4 = scn.UnPooling(dimension, 16, 16) self.unpool_5 = scn.UnPooling(dimension, 32, 32) return
def __init__(self, dimension=3, pool_size=2, pool_stride=2): super().__init__() self.pooling = scn.MaxPooling(dimension, pool_size, pool_stride) self.unpooling = scn.UnPooling(dimension, pool_size, pool_stride)