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)
