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 __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, cfg): super(PPN, self).__init__() import sparseconvnet as scn self._model_config = cfg['modules']['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._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)