def residual_block(m, a, b, leakiness=0.01, dimensions=2):
"""
append to a sequence module:
produce output of [identity,3x3+3x3] then add together
inputs
------
m [scn.Sequential module] network to add layers to
a [int]: number of input channels
b [int]: number of output channels
leakiness [float]: leakiness of ReLU activations
dimensions [int]: dimensions of input sparse tensor
modifies
--------
m: adds layers
"""
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(dimensions, a, b, 3, False)).add(
scn.BatchNormLeakyReLU(b, leakiness=leakiness)).add(
scn.SubmanifoldConvolution(
dimensions, b, b, 3, False)))).add(scn.AddTable())
def block(self, n_in, n_out):
m = scn.Sequential()
if self.residual_blocks: # ResNet style blocks
m.add(scn.ConcatTable().add(
scn.Identity() if n_in ==
n_out else scn.NetworkInNetwork(n_in, n_out, False)).add(
scn.Sequential().add(
scn.BatchNormLeakyReLU(
n_in, leakiness=self.leakiness)).add(
scn.SubmanifoldConvolution(
self.dimension, n_in, n_out, 3,
False)).add(
scn.BatchNormLeakyReLU(
n_out,
leakiness=self.leakiness)).add(
scn.SubmanifoldConvolution(
self.dimension, n_out,
n_out, 3, False))))
m.add(scn.AddTable())
else: # VGG style blocks
m.add(scn.BatchNormLeakyReLU(n_in, leakiness=self.leakiness))
m.add(
scn.SubmanifoldConvolution(self.dimension, n_in, n_out, 3,
False))
return m
def __init__(self, inplanes, outplanes, batch_norm, leaky_relu):
nn.Module.__init__(self)
self.batch_norm = batch_norm
self.leaky_relu = leaky_relu
self.conv1 = scn.SubmanifoldConvolution(dimension=3,
nIn = inplanes,
nOut = outplanes,
filter_size = 3,
bias=False)
if self.batch_norm:
if self.leaky_relu: self.bn1 = scn.BatchNormLeakyReLU(outplanes)
else: self.bn1 = scn.BatchNormReLU(outplanes)
self.conv2 = scn.SubmanifoldConvolution(dimension=3,
nIn = outplanes,
nOut = outplanes,
filter_size = 3,
bias = False)
if self.batch_norm:
self.bn2 = scn.BatchNormalization(outplanes)
self.residual = scn.Identity()
if self.leaky_relu: self.relu = scn.LeakyReLU()
else: self.relu = scn.ReLU()
self.add = scn.AddTable()
def __init__(self, inplanes, outplanes, nplanes=1):
nn.Module.__init__(self)
self.conv1 = scn.SubmanifoldConvolution(dimension=3,
nIn = inplanes,
nOut = outplanes,
filter_size = [nplanes,3,3],
bias=False)
# if FLAGS.BATCH_NORM:
self.bn1 = scn.BatchNormReLU(outplanes)
self.conv2 = scn.SubmanifoldConvolution(dimension=3,
nIn = outplanes,
nOut = outplanes,
filter_size = [nplanes,3,3],
bias = False)
# if FLAGS.BATCH_NORM:
self.bn2 = scn.BatchNormalization(outplanes)
self.residual = scn.Identity()
self.relu = scn.ReLU()
self.add = scn.AddTable()
def __init__(self, nf_in, nf, input_sparsetensor, return_sparsetensor,
max_data_size):
nn.Module.__init__(self)
data_dim = 3
self.nf_in = nf_in
self.nf = nf
self.input_sparsetensor = input_sparsetensor
self.return_sparsetensor = return_sparsetensor
self.max_data_size = max_data_size
if not self.input_sparsetensor:
self.p0 = scn.InputLayer(data_dim, self.max_data_size, mode=0)
self.p1 = scn.SubmanifoldConvolution(data_dim,
nf_in,
nf,
filter_size=FSIZE0,
bias=False)
self.p2 = scn.Sequential()
self.p2.add(scn.ConcatTable().add(scn.Identity()).add(
scn.Sequential().add(scn.BatchNormReLU(nf)).add(
scn.SubmanifoldConvolution(
data_dim, nf, nf, FSIZE0,
False)).add(scn.BatchNormReLU(nf)).add(
scn.SubmanifoldConvolution(data_dim, nf, nf, FSIZE0,
False)))).add(
scn.AddTable())
self.p2.add(scn.BatchNormReLU(nf))
# downsample space by factor of 2
self.p3 = scn.Sequential().add(
scn.Convolution(data_dim, nf, nf, FSIZE1, 2, False))
self.p3.add(scn.BatchNormReLU(nf))
if not self.return_sparsetensor:
self.p4 = scn.SparseToDense(data_dim, nf)
def __init__(self, *, inplanes, outplanes, nplanes=1, params):
nn.Module.__init__(self)
self.conv1 = scn.SubmanifoldConvolution(dimension=3,
nIn=inplanes,
nOut=outplanes,
filter_size=[nplanes, 3, 3],
bias=params.use_bias)
self.do_batch_norm = False
if params.batch_norm:
self.do_batch_norm = True
self.bn1 = scn.BatchNormReLU(outplanes)
self.conv2 = scn.SubmanifoldConvolution(dimension=3,
nIn=outplanes,
nOut=outplanes,
filter_size=[nplanes, 3, 3],
bias=False)
if params.batch_norm:
self.bn2 = scn.BatchNormalization(outplanes)
self.residual = scn.Identity()
self.relu = scn.ReLU()
self.add = scn.AddTable()
def block(self,
m,
a,
b,
dimension=3,
residual_blocks=False,
leakiness=0,
kernel_size=3,
use_batch_norm=True): # default using residual_block
if use_batch_norm:
Activation = lambda channels: scn.BatchNormLeakyReLU(
channels, leakiness=leakiness)
else:
Activation = lambda channels: scn.LeakyReLU(leakiness)
if residual_blocks: #ResNet style blocks
m.add(scn.ConcatTable().add(scn.Identity(
) if a == b else scn.NetworkInNetwork(a, b, False)).add(
scn.Sequential().add(Activation(a)).add(
scn.SubmanifoldConvolution(dimension, a, b, kernel_size,
False)).add(Activation(b)).add(
scn.SubmanifoldConvolution(
dimension, b, b,
kernel_size,
False)))).add(
scn.AddTable())
else: #VGG style blocks
m.add(scn.Sequential().add(Activation(a)).add(
scn.SubmanifoldConvolution(dimension, a, b, kernel_size,
False)))
def block(m, a, b):
if residual_blocks: #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,
momentum=bn_momentum,
leakiness=leakiness,
track_running_stats=track_running_stats)
).add(scn.SubmanifoldConvolution(
dimension, a, b, 3, False)).add(
scn.BatchNormLeakyReLU(
b,
momentum=bn_momentum,
leakiness=leakiness,
track_running_stats=track_running_stats)).add(
scn.SubmanifoldConvolution(
dimension, b, b, 3,
False)))).add(scn.AddTable())
else: #VGG style blocks
m.add(scn.Sequential().add(
scn.BatchNormLeakyReLU(
a,
momentum=bn_momentum,
leakiness=leakiness,
track_running_stats=track_running_stats)).add(
scn.SubmanifoldConvolution(dimension, a, b, 3,
False)))
operation = {'kernel': [1, 1, 1], 'stride': [1, 1, 1]}
return operation
def __init__(self, inplanes, outplanes, bias, batch_norm):
nn.Module.__init__(self)
self.conv1 = scn.SubmanifoldConvolution(dimension=3,
nIn=inplanes,
nOut=outplanes,
filter_size=3,
bias=bias)
if batch_norm:
self.activation1 = scn.BatchNormReLU(outplanes, momentum=0.5)
else:
self.activation1 = scn.ReLU()
self.conv2 = scn.SubmanifoldConvolution(dimension=3,
nIn=outplanes,
nOut=outplanes,
filter_size=3,
bias=bias)
if batch_norm:
self.activation2 = scn.BatchNormReLU(outplanes, momentum=0.5)
else:
self.activation2 = scn.ReLU()
self.residual = scn.Identity()
self.add = scn.AddTable()
def residual_block(m, ninputchs, noutputchs, leakiness=0.01, dimensions=2):
"""
Residual Modulae Block
intention is to append to a sequence module (m)
produce output of [identity,3x3+3x3] then add together
inputs
------
m [scn.Sequential module] network to add layers to
ninputchs [int]: number of input channels
noutputchs [int]: number of output channels
leakiness [float]: leakiness of ReLU activations
dimensions [int]: dimensions of input sparse tensor
modifies
--------
m: adds layers
"""
inoutsame = ninputchs == noutputchs
m.add(scn.ConcatTable().add(
scn.Identity() if inoutsame else scn.
NetworkInNetwork(ninputchs, noutputchs, False)).add(
scn.Sequential().add(
scn.BatchNormLeakyReLU(ninputchs, leakiness=leakiness)).add(
scn.SubmanifoldConvolution(
dimensions, ninputchs, noutputchs, 3, False)).add(
scn.BatchNormLeakyReLU(
noutputchs, leakiness=leakiness)).add(
scn.SubmanifoldConvolution(
dimensions, noutputchs, noutputchs, 3,
False)))).add(scn.AddTable())
def block(self, nPlanes, n, reps, stride):
m = scn.Sequential()
for rep in range(reps):
if rep == 0:
m.add(scn.BatchNormReLU(nPlanes))
m.add(scn.ConcatTable().add(self.residual(
nPlanes, n, stride)).add(scn.Sequential().add(
scn.SubmanifoldConvolution(self.dimension, nPlanes, n,
3, False) if stride ==
1 else scn.Convolution(
self.dimension, nPlanes, n, 2, stride, False)).add(
scn.BatchNormReLU(n)).add(
scn.SubmanifoldConvolution(
self.dimension, n, n, 3, False))))
else:
m.add(scn.ConcatTable().add(scn.Sequential().add(
scn.BatchNormReLU(nPlanes)).add(
scn.SubmanifoldConvolution(
self.dimension, nPlanes, n, 3,
False)).add(scn.BatchNormReLU(n)).add(
scn.SubmanifoldConvolution(
self.dimension, n, n, 3,
False))).add(scn.Identity()))
m.add(scn.AddTable())
nPlanes = n
return m
def __init__(self):
import sparseconvnet as scn
super(SCNet, self).__init__()
self.input_tensor = scn.InputLayer(dimension=2,
spatial_size=(3600, 3600))
self.elu = scn.ELU()
self.conv1 = scn.SubmanifoldConvolution(dimension=2,
nIn=1,
nOut=10,
filter_size=5,
bias=False)
self.conv2 = scn.SubmanifoldConvolution(dimension=2,
nIn=10,
nOut=64,
filter_size=5,
bias=False)
self.conv3 = scn.SubmanifoldConvolution(dimension=2,
nIn=64,
nOut=128,
filter_size=5,
bias=False)
self.conv4 = scn.SubmanifoldConvolution(dimension=2,
nIn=128,
nOut=256,
filter_size=5,
bias=False)
self.maxp = scn.MaxPooling(dimension=2, pool_size=5, pool_stride=5)
self.maxp2 = scn.MaxPooling(dimension=2, pool_size=4, pool_stride=4)
N = 256
self.sparse_to_dense = scn.SparseToDense(dimension=2, nPlanes=N)
self.fc1 = nn.Linear(N * 9 * 9, 32)
self.fc2 = nn.Linear(32, 5)
def __init__(self, args):
torch.nn.Module.__init__(self)
# All of the parameters are controlled via the flags module
# Create the sparse input tensor:
self.input_tensor = scn.InputLayer(dimension=3, spatial_size=(512))
# Here, define the layers we will need in the forward path:
# The convolutional layers, which can be shared or not across planes,
# are defined below
# We apply an initial convolution, to each plane, to get n_inital_filters
self.initial_convolution = scn.SubmanifoldConvolution(
dimension=3,
nIn=1,
nOut=args.n_initial_filters,
filter_size=5,
bias=args.use_bias)
n_filters = args.n_initial_filters
# Next, build out the convolution steps
self.convolutional_layers = torch.nn.ModuleList()
for layer in range(args.network_depth):
self.convolutional_layers.append(
SparseBlockSeries(inplanes=n_filters,
n_blocks=args.res_blocks_per_layer,
bias=args.use_bias,
batch_norm=args.batch_norm,
residual=True))
out_filters = 2 * n_filters
self.convolutional_layers.append(
SparseConvolutionDownsample(inplanes=n_filters,
outplanes=out_filters,
bias=args.use_bias,
batch_norm=args.batch_norm))
# outplanes = n_filters + args.n_initial_filters))
n_filters = out_filters
# Here, take the final output and convert to a dense tensor:
self.final_layer = SparseBlockSeries(
inplanes=n_filters,
n_blocks=args.res_blocks_per_layer,
bias=args.use_bias,
batch_norm=args.batch_norm,
residual=True)
self.bottleneck = scn.SubmanifoldConvolution(dimension=3,
nIn=n_filters,
nOut=2,
filter_size=3,
bias=args.use_bias)
self.sparse_to_dense = scn.SparseToDense(dimension=3, nPlanes=2)
def __init__(self,
output_shape,
use_norm=True,
num_input_features=128,
num_filters_down1=[64],
num_filters_down2=[64, 64],
name='SparseMiddleExtractor'):
super(SparseMiddleExtractor, self).__init__()
self.name = name
if use_norm:
BatchNorm1d = change_default_args(
eps=1e-3, momentum=0.01)(nn.BatchNorm1d)
Linear = change_default_args(bias=False)(nn.Linear)
else:
BatchNorm1d = Empty
Linear = change_default_args(bias=True)(nn.Linear)
sparse_shape = np.array(output_shape[1:4]) + [1, 0, 0]
# sparse_shape[0] = 11
print(sparse_shape)
self.scn_input = scn.InputLayer(3, sparse_shape.tolist())
self.voxel_output_shape = output_shape
middle_layers = []
num_filters = [num_input_features] + num_filters_down1
# num_filters = [64] + num_filters_down1
filters_pairs_d1 = [[num_filters[i], num_filters[i + 1]]
for i in range(len(num_filters) - 1)]
for i, o in filters_pairs_d1:
middle_layers.append(scn.SubmanifoldConvolution(3, i, o, 3, False))
middle_layers.append(scn.BatchNormReLU(o, eps=1e-3, momentum=0.99))
middle_layers.append(
scn.Convolution(
3,
num_filters[-1],
num_filters[-1], (3, 1, 1), (2, 1, 1),
bias=False))
middle_layers.append(
scn.BatchNormReLU(num_filters[-1], eps=1e-3, momentum=0.99))
# assert len(num_filters_down2) > 0
if len(num_filters_down1) == 0:
num_filters = [num_filters[-1]] + num_filters_down2
else:
num_filters = [num_filters_down1[-1]] + num_filters_down2
filters_pairs_d2 = [[num_filters[i], num_filters[i + 1]]
for i in range(len(num_filters) - 1)]
for i, o in filters_pairs_d2:
middle_layers.append(scn.SubmanifoldConvolution(3, i, o, 3, False))
middle_layers.append(scn.BatchNormReLU(o, eps=1e-3, momentum=0.99))
middle_layers.append(
scn.Convolution(
3,
num_filters[-1],
num_filters[-1], (3, 1, 1), (2, 1, 1),
bias=False))
middle_layers.append(
scn.BatchNormReLU(num_filters[-1], eps=1e-3, momentum=0.99))
middle_layers.append(scn.SparseToDense(3, num_filters[-1]))
self.middle_conv = Sequential(*middle_layers)
def __init__(self, output_shape):
torch.nn.Module.__init__(self)
# All of the parameters are controlled via the flags module
# Create the sparse input tensor:
self.input_tensor = scn.InputLayer(dimension=3, spatial_size=(512))
# Here, define the layers we will need in the forward path:
# The convolutional layers, which can be shared or not across planes,
# are defined below
# We apply an initial convolution, to each plane, to get n_inital_filters
self.initial_convolution = scn.SubmanifoldConvolution(
dimension=3,
nIn=1,
nOut=FLAGS.N_INITIAL_FILTERS,
filter_size=5,
bias=FLAGS.USE_BIAS)
n_filters = FLAGS.N_INITIAL_FILTERS
# Next, build out the convolution steps
self.convolutional_layers = []
for layer in range(FLAGS.NETWORK_DEPTH):
self.convolutional_layers.append(
SparseBlockSeries(n_filters,
FLAGS.RES_BLOCKS_PER_LAYER,
residual=True))
out_filters = filter_increase(n_filters)
self.convolutional_layers.append(
SparseConvolutionDownsample(inplanes=n_filters,
outplanes=out_filters))
# outplanes = n_filters + FLAGS.N_INITIAL_FILTERS))
n_filters = out_filters
self.add_module("conv_{}".format(layer),
self.convolutional_layers[-2])
self.add_module("down_{}".format(layer),
self.convolutional_layers[-1])
# Here, take the final output and convert to a dense tensor:
self.final_layer = SparseBlockSeries(
inplanes=n_filters,
n_blocks=FLAGS.RES_BLOCKS_PER_LAYER,
residual=True)
self.bottleneck = scn.SubmanifoldConvolution(dimension=3,
nIn=n_filters,
nOut=2,
filter_size=3,
bias=FLAGS.USE_BIAS)
self.sparse_to_dense = scn.SparseToDense(dimension=3, nPlanes=2)
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 res(m, dimension, a, b):
m.add(scn.ConcatTable()
.add(scn.Identity() if a == b else scn.NetworkInNetwork(a, b, False))
.add(scn.Sequential()
.add(scn.BatchNormReLU(a))
.add(scn.SubmanifoldConvolution(dimension, a, b, 3, False))
.add(scn.BatchNormReLU(b))
.add(scn.SubmanifoldConvolution(dimension, b, b, 3, False))))\
.add(scn.AddTable())
def __init__(self, inplanes, kernel, dim=3):
torch.nn.Module.__init__(self)
self.bnr1 = scn.BatchNormReLU(inplanes)
self.subconv1 = scn.SubmanifoldConvolution(dim, inplanes, inplanes,
kernel, 0)
self.bnr2 = scn.BatchNormReLU(inplanes)
self.subconv2 = scn.SubmanifoldConvolution(dim, inplanes, inplanes,
kernel, 0)
self.add = scn.AddTable()
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())
def __init__(self, class_num, full_scale, m=16, dimension=3):
nn.Module.__init__(self)
self.dimension = dimension
self.input = scn.InputLayer(dimension, full_scale, mode=4)
self.input_s = scn.InputLayer(dimension, full_scale, mode=4)
self.down_in = scn.SubmanifoldConvolution(dimension, 1, m, 3, False)
self.down_in_s = scn.SubmanifoldConvolution(dimension, 1, m, 3, False)
self.main_block1 = self.block(m, m, 2, 1)
self.main_block2 = self.block(m, 2 * m, 1, 2)
self.main_block3 = self.block(2 * m, 3 * m, 1, 2)
self.main_block4 = self.block(3 * m, 4 * m, 1, 2)
self.main_block5 = self.block(4 * m, 5 * m, 1, 2)
self.main_block6 = self.block(5 * m, 6 * m, 1, 2)
self.main_block7 = self.block(6 * m, 7 * m, 2, 2)
self.main_block8 = self.block(7 * m, 7 * m, 2, 1)
self.support_block1 = self.block(m, m, 2, 1)
self.support_block2 = self.block(m, 2 * m, 1, 2)
self.support_block3 = self.block(2 * m, 3 * m, 1, 2)
self.support_block4 = self.block(3 * m, 4 * m, 1, 2)
self.support_block5 = self.block(4 * m, 5 * m, 1, 2)
self.support_block6 = self.block(5 * m, 6 * m, 1, 2)
self.support_block7 = self.block(6 * m, 7 * m, 1, 2)
self.support_block8 = self.block(7 * m, 7 * m, 1, 1)
self.support_block2_tune = self.guide_tune(dimension, 2 * m, 2 * m, 1,
False)
self.support_block2_out = GlobalMeanAttentionPooling(dimension)
self.support_block3_tune = self.guide_tune(dimension, 4 * m, 4 * m, 1,
False)
self.support_block3_out = GlobalMeanAttentionPooling(dimension)
self.support_block4_tune = self.guide_tune(dimension, 7 * m, 7 * m, 1,
False)
self.support_block4_out = GlobalMeanAttentionPooling(dimension)
self.global_add2 = GlobalMaskLayer(dimension)
self.global_add3 = GlobalMaskLayer(dimension)
self.global_add4 = GlobalMaskLayer(dimension)
self.spatial_pick = DistMatchLayer_v4(dimension, 7 * m, topk=3)
# self.join_sub = scn.JoinTable()
self.tune_sub = self.guide_tune(dimension, 14 * m, 7 * m, 1, False)
self.deconv7 = self.decoder(7 * m, 6 * m)
self.join6 = scn.JoinTable()
self.deconv6 = self.decoder(12 * m, 5 * m)
self.deconv5 = self.decoder(5 * m, 4 * m)
self.join4 = scn.JoinTable()
self.deconv4 = self.decoder(8 * m, 3 * m)
self.deconv3 = self.decoder(3 * m, 2 * m)
self.join2 = scn.JoinTable()
self.deconv2 = self.decoder(4 * m, 2 * m)
# self.deconv1 = self.decoder(2 * m, m)
self.output = scn.OutputLayer(dimension)
self.linear = nn.Linear(2 * m, class_num)
def SparseResNet(dimension, nInputPlanes, layers):
import sparseconvnet as scn
"""
pre-activated ResNet
e.g. layers = {{'basic',16,2,1},{'basic',32,2}}
"""
nPlanes = nInputPlanes
m = scn.Sequential()
def residual(nIn, nOut, stride):
if stride > 1:
return scn.Convolution(dimension, nIn, nOut, 2, stride, False)
elif nIn != nOut:
return scn.NetworkInNetwork(nIn, nOut, False)
else:
return scn.Identity()
for n, reps, stride in layers:
for rep in range(reps):
if rep == 0:
m.add(scn.BatchNormReLU(nPlanes))
tab = scn.ConcatTable()
tab_seq = scn.Sequential()
if stride == 1:
tab_seq.add(
scn.SubmanifoldConvolution(dimension, nPlanes, n, 3,
False))
else:
tab_seq.add(
scn.Convolution(dimension, nPlanes, n, 2, stride,
False))
tab_seq.add(scn.BatchNormReLU(n))
tab_seq.add(
scn.SubmanifoldConvolution(dimension, n, n, 3, False))
tab.add(tab_seq)
tab.add(residual(nPlanes, n, stride))
m.add(tab)
else:
tab = scn.ConcatTable()
tab_seq = scn.Sequential()
tab_seq.add(scn.BatchNormReLU(nPlanes))
tab_seq.add(
scn.SubmanifoldConvolution(dimension, nPlanes, n, 3,
False))
tab_seq.add(scn.BatchNormReLU(n))
tab_seq.add(
scn.SubmanifoldConvolution(dimension, n, n, 3, False))
tab.add(tab_seq)
tab.add(scn.Identity())
m.add(tab)
nPlanes = n
m.add(scn.AddTable())
m.add(scn.BatchNormReLU(nPlanes))
return m
def f(m, a, b):
m.add(scn.ConcatTable().add(scn.Identity(
) if a == b else scn.NetworkInNetwork(a, b, self.allow_bias)).add(
scn.Sequential().add(norm_layer(
a, leakiness=self.leakiness)).add(
scn.SubmanifoldConvolution(
self.dimension, a, b, 3, self.allow_bias)).add(
norm_layer(b, leakiness=self.leakiness)).add(
scn.SubmanifoldConvolution(
self.dimension, b, b, 3,
self.allow_bias)))).add(scn.AddTable())
return m
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 block(m, a, b):
if residual_blocks: #ResNet style blocks
m.add(scn.ConcatTable().add(scn.Identity(
) if a == b else scn.NetworkInNetwork(a, b, False)).add(
scn.Sequential().add(scn.BatchNormReLU(a)).add(
scn.SubmanifoldConvolution(dimension, a, b, 3, False)).add(
scn.BatchNormReLU(b)).add(
scn.SubmanifoldConvolution(dimension, b, b, 3,
False)))).add(
scn.AddTable())
else: #VGG style blocks
m.add(scn.Sequential().add(scn.BatchNormReLU(a)).add(
scn.SubmanifoldConvolution(dimension, a, b, 3, False)))
def foo(m,np):
for _ in range(reps):
if residual: #ResNet style blocks
m.add(scn.ConcatTable()
.add(scn.Identity())
.add(scn.Sequential()
.add(scn.BatchNormLeakyReLU(np,leakiness=leakiness))
.add(scn.SubmanifoldConvolution(dimension, np, np, 3, False))
.add(scn.BatchNormLeakyReLU(np,leakiness=leakiness))
.add(scn.SubmanifoldConvolution(dimension, np, np, 3, False)))
).add(scn.AddTable())
else: #VGG style blocks
m.add(scn.BatchNormLeakyReLU(np,leakiness=leakiness)
).add(scn.SubmanifoldConvolution(dimension, np, np, 3, False))
def block(self, m, a, b, dimension=3, residual_blocks=False, leakiness=0): # default using residual_block
if residual_blocks: #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(dimension, a, b, 3, False))
.add(scn.BatchNormLeakyReLU(b,leakiness=leakiness))
.add(scn.SubmanifoldConvolution(dimension, b, b, 3, False)))
).add(scn.AddTable())
else: #VGG style blocks
m.add(scn.Sequential()
.add(scn.BatchNormLeakyReLU(a,leakiness=leakiness))
.add(scn.SubmanifoldConvolution(dimension, a, b, 3, False)))
def __init__(self, full_scale=127, use_normal=False):
nn.Module.__init__(self)
dimension = 3
m = 32 # 16 or 32
residual_blocks = True #True or False
block_reps = 2 #Conv block repetition factor: 1 or 2
blocks = [['b', m * k, 2, 2] for k in [1, 2, 3, 4, 5]]
self.num_final_channels = m * len(blocks)
self.sparseModel = scn.Sequential().add(
scn.InputLayer(dimension, full_scale, mode=4)).add(
scn.SubmanifoldConvolution(
dimension, 3 + 3 * int(use_normal), m, 3,
False)).add(scn.MaxPooling(dimension, 3, 2)).add(
scn.SparseResNet(dimension, m, blocks)).add(
scn.BatchNormReLU(self.num_final_channels)).add(
scn.SparseToDense(dimension,
self.num_final_channels))
self.num_labels = 20
self.label_encoder = nn.Sequential(nn.Linear(self.num_labels, 64),
nn.ReLU())
#self.pred = nn.Linear(m * len(blocks), 1)
self.pred = nn.Sequential(nn.Linear(self.num_final_channels + 64, 64),
nn.ReLU(), nn.Linear(64, 1))
return
def __init__(self, flags):
torch.nn.Module.__init__(self)
import sparseconvnet as scn
self._flags = flags
dimension = self._flags.DATA_DIM
num_class = self._flags.NUM_CLASS
image_size = self._flags.SPATIAL_SIZE
num_filter = self._flags.BASE_NUM_FILTERS
assert image_size == 128
net = scn.Sequential()
net.add(scn.InputLayer(dimension, image_size, mode=3))
net.add(scn.SubmanifoldConvolution(dimension, 1, num_filter, 3, False))
net.add(scn.MaxPooling(dimension, 2, 2))
net.add(
SparseResNet(dimension, num_filter,
[[num_filter * 1, 2, 1], [num_filter * 2, 2, 2],
[num_filter * 4, 2, 2], [num_filter * 8, 2, 2]]))
net.add(
scn.Convolution(dimension, num_filter * 8, num_filter * 16, 3, 1,
False))
net.add(scn.BatchNormReLU(num_filter * 16))
net.add(scn.SparseToDense(dimension, num_filter * 16))
net.add(torch.nn.AvgPool3d(6))
self._net = net
self.linear = torch.nn.Linear(num_filter * 16, num_class)
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( # Kernel size 3, no bias
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 = nn.Linear(m, num_classes)
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)
