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, 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 __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, 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 __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( scn.UNet(dimension, reps, nPlanes, residual_blocks=False, 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): nn.Module.__init__(self) self.sparseModel = scn.Sequential().add( scn.InputLayer(dimension, spatialSize, mode=3)).add( scn.SubmanifoldConvolution(dimension, 1, m, 3, False)).add( scn.UNet(dimension, reps, nPlanes, residual_blocks=False, downsample=[2,2])).add( scn.BatchNormReLU(m)).add( scn.OutputLayer(dimension)) self.linear = nn.Linear(m, classes_total)
def __init__(self, dimension = 3, device = 'cuda', spatialSize = 4096, nIn = 3, nOut = 2, reps = REPS, nPlanes = NPLANES): nn.Module.__init__(self) self.sparseModel = scn.Sequential().add( scn.InputLayer(dimension, torch.LongTensor([spatialSize]*3), mode=3)).add( scn.SubmanifoldConvolution(dimension, nIn, m, 3, False)).add( scn.UNet(dimension, reps, nPlanes, residual_blocks=False, downsample=[2,2])).add( scn.BatchNormReLU(m)).add( scn.OutputLayer(dimension)).to(device) self.inputLayer = scn.InputLayer(dimension, torch.LongTensor([spatialSize]*3), mode=3) self.linear = nn.Linear(m, nOut).to(device)
def __init__(self): nn.Module.__init__(self) self.sparseModel = scn.Sequential().add( scn.InputLayer(data.dimension, data.full_scale, mode=4)).add( scn.SubmanifoldConvolution( data.dimension, 3, m, 3, False)).add( scn.UNet(data.dimension, block_reps, [m, 2 * m, 3 * m, 4 * m, 5 * m, 6 * m, 7 * m], residual_blocks)).add( scn.BatchNormReLU(m)).add( scn.OutputLayer(data.dimension)) self.linear = nn.Linear(m, 20)
def __init__(self, inputshape, reps, nfeatures, nplanes, noutput_classes): nn.Module.__init__(self) # set parameters self.dimensions = 2 # not playing with 3D for now # input shape: LongTensor, tuple, or list. Handled by InputLayer # size of each spatial dimesion self.inputshape = inputshape if len(self.inputshape) != self.dimensions: raise ValueError( "expected inputshape to contain size of 2 dimensions only. given %d values" % (len(self.inputshape))) # mode variable: how to deal with repeated data self.mode = 0 # nfeatures self.nfeatures = nfeatures # plane structure self.nPlanes = [self.nfeatures * (n + 1) for n in xrange(nplanes)] # repetitions (per plane) self.reps = reps # output classes self.noutput_classes = noutput_classes # model: # input # stem # unet # linear to nclasses self.sparseModel = scn.Sequential().add( scn.InputLayer( self.dimensions, self.inputshape, mode=self.mode)).add( scn.SubmanifoldConvolution( self.dimensions, 1, self.nfeatures, 3, False)).add( scn.UNet( self.dimensions, self.reps, self.nPlanes, residual_blocks=True, downsample=[ 2, 2 ])).add(scn.BatchNormReLU(self.nfeatures)).add( scn.SubmanifoldConvolution( self.dimensions, self.nfeatures, self.noutput_classes, 1, False)).add( scn.OutputLayer(self.dimensions)) self.softmax = torch.nn.Softmax(dim=1)
def __init__(self, Feature_channel, num_class): nn.Module.__init__(self) dimension = 3 self.compress_fn = nn.Linear(Feature_channel, dimension) self.bn = nn.BatchNorm1d(3) self.sparseModel = scn.Sequential().add( scn.InputLayer(dimension, full_scale, mode=4)).add( scn.SubmanifoldConvolution(dimension, 3, 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)).add( scn.OutputLayer(dimension)) self.linear = nn.Linear(m, num_class)
def __init__(self, config): super().__init__() self.config = config m = config['Segmentation']['m'] input_dim = 4 if config['Segmentation']['use_coords'] else 1 self.sparseModel = scn.Sequential().add( scn.InputLayer(3, config['Segmentation']['full_scale'][1], mode=4) ).add(scn.SubmanifoldConvolution(3, input_dim, m, 3, False)).add( scn.UNet(dimension=3, reps=config['Segmentation']['block_reps'], nPlanes=[m, 2 * m, 3 * m, 4 * m, 5 * m, 6 * m, 7 * m], residual_blocks=config['Segmentation']['block_residual'], groups=config['Segmentation']['seg_groups'])).add( scn.BatchNormReLU(m)).add(scn.OutputLayer(3)) self.linear = nn.Linear(m, self.config['DATA']['classes_seg']) if self.config['Completion']['interaction']: self.shape_embedding = conv_base.Conv1d( m, m, kernel_size=1, bn=True, activation=nn.LeakyReLU(0.2))
def __init__(self, in_channels, m=16, # number of unet features (multiplied in each layer) block_reps=1, # depth residual_blocks=False, # ResNet style basic blocks full_scale=4096, num_planes=7 ): super(UNetSCN, self).__init__() self.in_channels = in_channels self.out_channels = m n_planes = [(n + 1) * m for n in range(num_planes)] self.sparseModel = scn.Sequential().add( scn.InputLayer(DIMENSION, full_scale, mode=4)).add( scn.SubmanifoldConvolution(DIMENSION, in_channels, m, 3, False)).add( scn.UNet(DIMENSION, block_reps, n_planes, residual_blocks)).add( scn.BatchNormReLU(m)).add( scn.OutputLayer(DIMENSION))
def __init__(self, size): self.dimension = 3 self.reps = 1 #Conv block repetition factor self.m = 32 #Unet number of features self.nPlanes = [m, 2 * m, 3 * m, 4 * m, 5 * m] #UNet number of features per level nn.Module.__init__(self) self.sparseModel = scn.Sequential().add( scn.InputLayer( self.dimension, torch.LongTensor([size] * 3), mode=3)).add( scn.SubmanifoldConvolution( self.dimension, 1, self.m, 3, False)).add( scn.UNet(self.dimension, self.reps, self.nPlanes, residual_blocks=False, downsample=[2, 2])).add( scn.BatchNormReLU(self.m)).add( scn.OutputLayer(self.dimension)) self.linear = nn.Linear(m, 2)
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, ndimensions=2, inputshape=(1024, 3456), input_nfeatures=1, stem_nfeatures=16, features_per_layer=16, classifier_nfeatures=[32, 32], leakiness=0.01, ninput_planes=3, use_unet=False, nresnet_blocks=10): """ parameters ----------- ndimensions [int] number of spatial dimensions of input data, default=2 inputshape [tuple of int] size of input tensor/image in (num of tick pixels, num of wire pixels), default=(1024,3456) input_nfeatures [int] number of features in the input tensor, default=1 (the image charge) stem_nfeatures [int] number of features in the stem layers, also controls num of features in unet layers, default=16 features_per_layer [int] number of channels in the resnet layers that follow unet layers, default=16 classifier_nfeatures [tuple of int] number of channels per hidden layer of larmatch classification network, default=[32,32] leakiness [float] leakiness of LeakyRelu activiation layers, default=0.01 ninput_planes [int] number of input image planes, default=3 use_unet [bool] if true, use UNet layers, default=True nresnet_blocks [int] number of resnet blocks if not using unet, DEPRECATED, default=10 """ super(LArMatch, self).__init__() self.use_unet = use_unet # INPUT LAYERS: converts torch tensor into scn.SparseMatrix self.ninput_planes = ninput_planes self.source_inputlayer = scn.InputLayer(ndimensions, inputshape, mode=0) self.target1_inputlayer = scn.InputLayer(ndimensions, inputshape, mode=0) self.target2_inputlayer = scn.InputLayer(ndimensions, inputshape, mode=0) # STEM self.stem = scn.Sequential() self.stem.add( scn.SubmanifoldConvolution(ndimensions, input_nfeatures, stem_nfeatures, 3, False)) self.stem.add( scn.BatchNormLeakyReLU(stem_nfeatures, leakiness=leakiness)) if self.use_unet: self.stem.add( scn.SubmanifoldConvolution(ndimensions, stem_nfeatures, stem_nfeatures, 3, False)) self.stem.add( scn.BatchNormLeakyReLU(stem_nfeatures, leakiness=leakiness)) self.stem.add( scn.SubmanifoldConvolution(ndimensions, stem_nfeatures, stem_nfeatures, 3, False)) # UNET BLOCK if self.use_unet: self.unet_layers = scn.UNet( 2, 2, [ stem_nfeatures, stem_nfeatures * 2, stem_nfeatures * 3, stem_nfeatures * 4, stem_nfeatures * 5 ], residual_blocks=True, downsample=[2, 2]) # RESNET BLOCK if not self.use_unet: self.resnet_layers = create_resnet_layer(nresnet_blocks, stem_nfeatures, features_per_layer, leakiness=leakiness) else: self.resnet_layers = create_resnet_layer(1, stem_nfeatures, features_per_layer, leakiness=leakiness) self.resnet_layers.add( scn.BatchNormLeakyReLU(stem_nfeatures, leakiness=leakiness)) # OUTPUT FEATURES self.nfeatures = features_per_layer self.feature_layer = scn.SubmanifoldConvolution( ndimensions, features_per_layer, self.nfeatures, 1, True) # from there, we move back into a tensor self.source_outlayer = scn.OutputLayer(ndimensions) self.target1_outlayer = scn.OutputLayer(ndimensions) self.target2_outlayer = scn.OutputLayer(ndimensions) # CLASSIFER: MATCH/NO-MATCH classifier_layers = OrderedDict() classifier_layers["class0conv"] = torch.nn.Conv1d( self.ninput_planes * features_per_layer, classifier_nfeatures[0], 1) #classifier_layers["class0bn"] = torch.nn.BatchNorm1d classifier_layers["class0relu"] = torch.nn.ReLU() for ilayer, nfeats in enumerate(classifier_nfeatures[1:]): classifier_layers["class%dconv" % (ilayer + 1)] = torch.nn.Conv1d( nfeats, nfeats, 1) #classifier_layers["class0bn"] = torch.nn.BatchNorm1d classifier_layers["class%drelu" % (ilayer + 1)] = torch.nn.ReLU() classifier_layers["classout"] = torch.nn.Conv1d(nfeats, 1, 1) #classifier_layers["sigmoid"] = torch.nn.Sigmoid() self.classifier = torch.nn.Sequential(classifier_layers)