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)