def build_convnet(path_to_vgg):
"""
Construct VGG-19 convnet
"""
net = {}
net['input'] = InputLayer((None, 3, 224, 224))
net['conv1_1'] = ConvLayer(net['input'], 64, 3, pad=1)
net['conv1_2'] = ConvLayer(net['conv1_1'], 64, 3, pad=1)
net['pool1'] = PoolLayer(net['conv1_2'], 2)
net['conv2_1'] = ConvLayer(net['pool1'], 128, 3, pad=1)
net['conv2_2'] = ConvLayer(net['conv2_1'], 128, 3, pad=1)
net['pool2'] = PoolLayer(net['conv2_2'], 2)
net['conv3_1'] = ConvLayer(net['pool2'], 256, 3, pad=1)
net['conv3_2'] = ConvLayer(net['conv3_1'], 256, 3, pad=1)
net['conv3_3'] = ConvLayer(net['conv3_2'], 256, 3, pad=1)
net['conv3_4'] = ConvLayer(net['conv3_3'], 256, 3, pad=1)
net['pool3'] = PoolLayer(net['conv3_4'], 2)
net['conv4_1'] = ConvLayer(net['pool3'], 512, 3, pad=1)
net['conv4_2'] = ConvLayer(net['conv4_1'], 512, 3, pad=1)
net['conv4_3'] = ConvLayer(net['conv4_2'], 512, 3, pad=1)
net['conv4_4'] = ConvLayer(net['conv4_3'], 512, 3, pad=1)
net['pool4'] = PoolLayer(net['conv4_4'], 2)
net['conv5_1'] = ConvLayer(net['pool4'], 512, 3, pad=1)
net['conv5_2'] = ConvLayer(net['conv5_1'], 512, 3, pad=1)
net['conv5_3'] = ConvLayer(net['conv5_2'], 512, 3, pad=1)
net['conv5_4'] = ConvLayer(net['conv5_3'], 512, 3, pad=1)
net['pool5'] = PoolLayer(net['conv5_4'], 2)
net['fc6'] = DenseLayer(net['pool5'], num_units=4096)
net['fc7'] = DenseLayer(net['fc6'], num_units=4096)
net['fc8'] = DenseLayer(net['fc7'], num_units=1000, nonlinearity=None)
net['prob'] = NonlinearityLayer(net['fc8'], softmax)
print 'Loading parameters...'
output_layer = net['prob']
model = pkl.load(open(path_to_vgg))
lasagne.layers.set_all_param_values(output_layer, model['param values'])
return net
def _get_l_out(self, input_vars):
id_tag = (self.id + '/') if self.id else ''
input_var = input_vars[0]
l_in = InputLayer(shape=(None, ),
input_var=input_var,
name=id_tag + 'desc_input')
embed_size = self.options.listener_cell_size or self.color_vec.num_types
l_in_embed = EmbeddingLayer(l_in,
input_size=len(self.seq_vec.tokens),
output_size=embed_size,
name=id_tag + 'desc_embed')
if self.options.listener_cell_size == 0:
l_scores = l_in_embed # BiasLayer(l_in_embed, name=id_tag + 'bias')
else:
l_hidden = DenseLayer(l_in_embed,
num_units=self.options.listener_cell_size,
nonlinearity=NONLINEARITIES[
self.options.listener_nonlinearity],
name=id_tag + 'hidden')
if self.options.listener_dropout > 0.0:
l_hidden_drop = DropoutLayer(l_hidden,
p=self.options.listener_dropout,
name=id_tag + 'hidden_drop')
else:
l_hidden_drop = l_hidden
l_scores = DenseLayer(l_hidden_drop,
num_units=self.color_vec.num_types,
nonlinearity=None,
name=id_tag + 'scores')
l_out = NonlinearityLayer(l_scores,
nonlinearity=softmax,
name=id_tag + 'out')
return l_out, [l_in]
def _create_net_structure(self):
linear_initializer = lasagne.init.GlorotUniform()
relu_initializer = lasagne.init.GlorotUniform(gain='relu')
# Input layer
in_lay = InputLayer(self.input_shape, input_var=self.input_var)
# First set of encoding layers
conv0_lay = batch_norm(Conv2DLayer(in_lay, 64, 7, pad=3, W=relu_initializer, nonlinearity=lasagne.nonlinearities.rectify))
pool0_lay = MaxPool2DLayer(conv0_lay, 2, stride=2)
# Second set of encoding layers
conv1_lay = batch_norm(Conv2DLayer(pool0_lay, 64, 7, pad=3, W=relu_initializer, nonlinearity=lasagne.nonlinearities.rectify))
pool1_lay = MaxPool2DLayer(conv1_lay, 2, stride=2)
# Third set of encoding layers
conv2_lay = batch_norm(Conv2DLayer(pool1_lay, 64, 7, pad=3, W=relu_initializer, nonlinearity=lasagne.nonlinearities.rectify))
pool2_lay = MaxPool2DLayer(conv2_lay, 2, stride=2)
dropenc2_lay = DropoutLayer(pool2_lay, p=0.5)
# Fourth set of encoding layers
conv3_lay = batch_norm(Conv2DLayer(dropenc2_lay, 64, 7, pad=3, W=relu_initializer, nonlinearity=lasagne.nonlinearities.rectify))
pool3_lay = MaxPool2DLayer(conv3_lay, 2, stride=2)
dropenc3_lay = DropoutLayer(pool3_lay, p=0.5)
# First set of decoding layers
upsample3_lay = InverseLayer(dropenc3_lay, pool3_lay)
deconv3_lay = batch_norm(Conv2DLayer(upsample3_lay, 64, 7, pad=3, W=linear_initializer, nonlinearity=None))
dropdec3_lay = DropoutLayer(deconv3_lay, p=0.5)
# Second set of decoding layers
upsample2_lay = InverseLayer(dropdec3_lay, pool2_lay)
deconv2_lay = batch_norm(Conv2DLayer(upsample2_lay, 64, 7, pad=3, W=linear_initializer, nonlinearity=None))
dropdec2_lay = DropoutLayer(deconv2_lay, p=0.5)
# Third set of decoding layers
upsample1_lay = InverseLayer(dropdec2_lay, pool1_lay)
deconv1_lay = batch_norm(Conv2DLayer(upsample1_lay, 64, 7, pad=3, W=linear_initializer, nonlinearity=None))
# Fourth set of decoding layers
upsample0_lay = InverseLayer(deconv1_lay, pool0_lay)
deconv0_lay = batch_norm(Conv2DLayer(upsample0_lay, 64, 7, pad=3, W=linear_initializer, nonlinearity=None))
# Classifying (softmax layer)
classes_lay = Conv2DLayer(deconv0_lay, 2, 1)
outshape_lay = ReshapeLayer(classes_lay, (BATCH_SIZE, 2, INPUT_SIZE * INPUT_SIZE))
softmax_lay = NonlinearityLayer(outshape_lay, nonlinearity=log_softmax)
self.network = softmax_lay
def build_medium_model():
net = {}
net['input_layer'] = InputLayer((None,3,128,128))
net['conv1_1'] = ConvLayer(
net['input_layer'], 64, 3, pad=1)#, flip_filters=False)
net['conv1_2'] = ConvLayer(
net['conv1_1'], 64, 3, pad=1)#, flip_filters=False)
net['pool1'] = PoolLayer(net['conv1_2'], 2)
net['conv2_1'] = ConvLayer(
net['pool1'], 128, 3, pad=1)#, flip_filters=False)
net['conv2_2'] = ConvLayer(
net['conv2_1'], 128, 3, pad=1 )#, flip_filters=False)
net['pool2'] = PoolLayer(net['conv2_2'], 2)
net['conv3_1'] = ConvLayer(
net['pool2'], 256, 3, pad=1 )#, flip_filters=False)
net['conv3_2'] = ConvLayer(
net['conv3_1'], 256, 3, pad=1)#, flip_filters=False)
net['pool3'] = PoolLayer(net['conv3_2'], 2)
net['conv4_1'] = ConvLayer(
net['pool3'], 512, 3, pad=1)#, flip_filters=False)
net['conv4_2'] = ConvLayer(
net['conv4_1'], 512, 3, pad=1)#, flip_filters=False)
net['pool4'] = PoolLayer(net['conv4_2'], 2)
net['conv5_1'] = ConvLayer(
net['pool4'], 512, 3, pad=1)#, flip_filters=False)
net['conv5_2'] = ConvLayer(
net['conv5_1'], 512, 3, pad=1)#, flip_filters=False)
net['conv5_3'] = ConvLayer(
net['conv5_2'], 512, 3, pad=1)#, flip_filters=False)
net['pool5'] = PoolLayer(net['conv5_3'], 2)
net['fc6'] = DenseLayer(net['pool5'], num_units=10)
net['fc6_dropout'] = DropoutLayer(net['fc6'], p=0.5)
net['fc7'] = DenseLayer(net['fc6_dropout'], num_units=10)
net['fc7_dropout'] = DropoutLayer(net['fc7'], p=0.5)
net['fc8'] = DenseLayer(
net['fc7_dropout'], num_units=2, nonlinearity=None)
net['prob'] = NonlinearityLayer(net['fc8'], softmax)
return net
def build_cnn(input_var, num_classes):
#Get back the convolutional part of a VGG network trained on ImageNet
network = build_model(input_var)
with open('vgg_cnn_s.pkl', 'rb') as f:
params = pickle.load(f, encoding='latin-1')
set_all_param_values(network.values(), params['values'])
# pool5 shape: (None, 512, 6, 6)
del network['fc6']
del network['drop6']
del network['fc7']
del network['drop7']
del network['fc8']
network['shuff6'] = DimshuffleLayer(network['pool5'], (0, 2, 1, 3))
network['lstm7'] = LSTMLayer((None, 512, 6, 6), network['shuff6'])
network['rshp8'] = ReshapeLayer(network['lstm7'], (-1, 64))
network['fc9'] = DenseLayer(network['rshp8'], num_units=4096)
network['drop9'] = DropoutLayer(network['fc9'], p=0.5)
network['fc10'] = DenseLayer(network['drop9'], num_units=num_classes, nonlinearity=None)
network['prob'] = NonlinearityLayer(network['fc10'], softmax)
return network
def model_a():
net = {}
net['input'] = InputLayer((None, 3, 32, 32))
#net['drop_in'] = DropoutLayer(net['input'], p=0.2)
net['conv1_1'] = ConvLayer(net['input'], num_filters=96, filter_size=5, pad=1, flip_filters=False)
net['conv2_1'] = PoolLayer(net['conv1_1'], pool_size=3, stride=2)
#net['drop2_1'] = DropoutLayer(net['conv2_1'], p=0.5)
net['conv3_1'] = ConvLayer(net['conv2_1'], num_filters=192, filter_size=5, pad=1, flip_filters=False)
net['conv4_1'] = PoolLayer(net['conv3_1'], pool_size=3, stride=2)
#net['drop4_1'] = DropoutLayer(net['conv4_1'], p=0.5)
net['conv5_1'] = ConvLayer(net['conv4_1'], num_filters=192, filter_size=3, pad=1, flip_filters=False)
net['conv6_1'] = ConvLayer(net['conv5_1'], num_filters=192, filter_size=1, flip_filters=False)
net['conv7_1'] = ConvLayer(net['conv6_1'], num_filters=10, filter_size=1, flip_filters=False)
net['global_avg'] = GlobalPoolLayer(net['conv7_1'])
#net['fc10'] = DenseLayer(net['conv7_1'], num_units=10, nonlinearity=None)
net['output'] = NonlinearityLayer(net['global_avg'], softmax)
return net
def init_model():
# Build the model and select layers we need - the features are taken from the final network layer,
# before the softmax nonlinearity.
cnn_layers = googlenet.build_model()
cnn_input_var = cnn_layers['input'].input_var
cnn_feature_layer = DenseLayer(cnn_layers['pool5/7x7_s1'],
num_units=len(CLASSES),
nonlinearity=linear)
cnn_output_layer = NonlinearityLayer(cnn_feature_layer,
nonlinearity=softmax)
get_cnn_features = theano.function(
[cnn_input_var], lasagne.layers.get_output(cnn_feature_layer))
logging.info('Compiled new functions')
# Define the function for label prediction.
X_sym = T.tensor4()
prediction = lasagne.layers.get_output(cnn_output_layer, X_sym)
pred_fn = theano.function([X_sym], prediction)
# Load the pretrained weights into the network
with np.load(r'./data/googlenet_model.npz') as f:
model_param_values = [f['arr_%d' % i] for i in range(len(f.files))]
lasagne.layers.set_all_param_values(cnn_output_layer, model_param_values)
return get_cnn_features, pred_fn
def Tiny_VGG(num_of_classes, input_var=None):
net = {}
net['input'] = InputLayer(shape=(None, 3, 224, 224), input_var=input_var)
net['conv1_1'] = ConvLayer(net['input'], 32, 3, pad=1, flip_filters=False)
net['conv1_2'] = ConvLayer(net['conv1_1'],
32,
3,
pad=1,
flip_filters=False)
net['pool1'] = PoolLayer(net['conv1_2'], 2)
net['conv2_1'] = ConvLayer(net['pool1'], 32, 3, pad=1, flip_filters=False)
net['conv2_2'] = ConvLayer(net['conv2_1'],
32,
3,
pad=1,
flip_filters=False)
net['pool2'] = PoolLayer(net['conv2_2'], 2)
net['conv3_1'] = ConvLayer(net['pool2'], 32, 3, pad=1, flip_filters=False)
net['conv3_2'] = ConvLayer(net['conv3_1'],
32,
3,
pad=1,
flip_filters=False)
net['pool3'] = PoolLayer(net['conv3_2'], 2)
net['fc4'] = DenseLayer(net['pool3'], num_units=1024)
net['fc4_dropout'] = DropoutLayer(net['fc4'], p=0)
net['fc5'] = DenseLayer(net['fc4_dropout'], num_units=512)
net['fc5_dropout'] = DropoutLayer(net['fc5'], p=0)
net['fc6'] = DenseLayer(net['fc5_dropout'], num_units=256)
net['fc6_dropout'] = DropoutLayer(net['fc6'], p=0)
net['fc7'] = DenseLayer(net['fc6_dropout'],
num_units=num_of_classes,
nonlinearity=None)
net['prob'] = NonlinearityLayer(net['fc7'], softmax)
return net
def hw3_cnn():
net = {}
net['input'] = InputLayer((None, 3, 32, 32))
#net['drop_in'] = DropoutLayer(net['input'], p=0.2)
net['conv1_1'] = ConvLayer(net['input'],
num_filters=16,
filter_size=5,
flip_filters=False)
net['conv2_1'] = PoolLayer(net['conv1_1'], pool_size=2)
#net['drop2_1'] = DropoutLayer(net['conv2_1'], p=0.5)
net['conv3_1'] = ConvLayer(net['conv2_1'],
num_filters=512,
filter_size=5,
flip_filters=False)
net['conv4_1'] = PoolLayer(net['conv3_1'], pool_size=2)
#net['drop4_1'] = DropoutLayer(net['conv4_1'], p=0.5)
net['fc_5'] = DenseLayer(net['conv4_1'], 500)
net['output'] = NonlinearityLayer(net['fc_5'], softmax)
return net
def bn_relu_conv(self, network, channels, filter_size, dropout,
name_prefix):
nam = name_prefix + '_bn'
network = BatchNormLayer(network, name=nam)
self.layers.append(layer_info('bn', num_params=4))
nam = name_prefix + '_relu'
network = NonlinearityLayer(network, nonlinearity=rectify, name=nam)
self.layers.append(layer_info('relu'))
nam = name_prefix + '_conv'
network = Conv2DLayer(network,
channels,
filter_size,
pad='same',
W=lasagne.init.HeNormal(gain='relu'),
b=None,
nonlinearity=None,
name=nam)
self.layers.append(layer_info('conv', (channels, channels, 3, 3), 1))
if dropout:
network = DropoutLayer(network, dropout)
return network
def all_cnn_c():
net = {}
net['input'] = InputLayer((None, 3, 32, 32))
net['drop_in'] = DropoutLayer(net['input'], p=0.2)
net['conv1_1'] = ConvLayer(net['drop_in'], num_filters=96, filter_size=3, pad=1, flip_filters=False)
net['conv1_2'] = ConvLayer(net['conv1_1'], num_filters=96, filter_size=3, pad=1, flip_filters=False)
net['conv2_1'] = ConvLayer(net['conv1_2'], num_filters=96, filter_size=3, stride=2, pad=1, flip_filters=False)
net['drop2_1'] = DropoutLayer(net['conv2_1'], p=0.5)
net['conv3_1'] = ConvLayer(net['drop2_1'], num_filters=192, filter_size=3, pad=1, flip_filters=False)
net['conv3_2'] = ConvLayer(net['conv3_1'], num_filters=192, filter_size=3, pad=1, flip_filters=False)
net['conv4_1'] = ConvLayer(net['conv3_2'], num_filters=192, filter_size=3, stride=2,pad=1, flip_filters=False)
net['drop4_1'] = DropoutLayer(net['conv4_1'], p=0.5)
net['conv5_1'] = ConvLayer(net['drop4_1'], num_filters=192, filter_size=3, pad=1, flip_filters=False)
net['conv6_1'] = ConvLayer(net['conv5_1'], num_filters=192, filter_size=1, flip_filters=False)
net['conv7_1'] = ConvLayer(net['conv6_1'], num_filters=10, filter_size=1, flip_filters=False)
net['global_avg'] = GlobalPoolLayer(net['conv7_1'])
net['output'] = NonlinearityLayer(net['global_avg'], softmax)
return net
def SonoNet64(input_var, image_size, num_labels):
net = {}
net['input'] = InputLayer(shape=(None, 1, image_size[0], image_size[1]), input_var=input_var)
net['conv1_1'] = batch_norm(Conv2DLayer(net['input'], 64, 3, pad=1, flip_filters=False))
net['conv1_2'] = batch_norm(Conv2DLayer(net['conv1_1'], 64, 3, pad=1, flip_filters=False))
net['pool1'] = MaxPool2DLayer(net['conv1_2'], 2)
net['conv2_1'] = batch_norm(Conv2DLayer(net['pool1'], 128, 3, pad=1, flip_filters=False))
net['conv2_2'] = batch_norm(Conv2DLayer(net['conv2_1'], 128, 3, pad=1, flip_filters=False))
net['pool2'] = MaxPool2DLayer(net['conv2_2'], 2)
net['conv3_1'] = batch_norm(Conv2DLayer(net['pool2'], 256, 3, pad=1, flip_filters=False))
net['conv3_2'] = batch_norm(Conv2DLayer(net['conv3_1'], 256, 3, pad=1, flip_filters=False))
net['conv3_3'] = batch_norm(Conv2DLayer(net['conv3_2'], 256, 3, pad=1, flip_filters=False))
net['pool3'] = MaxPool2DLayer(net['conv3_3'], 2)
net['conv4_1'] = batch_norm(Conv2DLayer(net['pool3'], 512, 3, pad=1, flip_filters=False))
net['conv4_2'] = batch_norm(Conv2DLayer(net['conv4_1'], 512, 3, pad=1, flip_filters=False))
net['conv4_3'] = batch_norm(Conv2DLayer(net['conv4_2'], 512, 3, pad=1, flip_filters=False))
net['pool4'] = MaxPool2DLayer(net['conv4_3'], 2)
net['conv5_1'] = batch_norm(Conv2DLayer(net['pool4'], 512, 3, pad=1, flip_filters=False))
net['conv5_2'] = batch_norm(Conv2DLayer(net['conv5_1'], 512, 3, pad=1, flip_filters=False))
net['conv5_3'] = batch_norm(Conv2DLayer(net['conv5_2'], 512, 3, pad=1, flip_filters=False))
net['conv5_p'] = batch_norm(Conv2DLayer(net['conv5_3'], num_filters=256, filter_size=(1, 1)))
net['conv6_p'] = batch_norm(Conv2DLayer(net['conv5_p'], num_filters=num_labels, filter_size=(1, 1), nonlinearity=linear))
net['average_pool_p'] = GlobalPoolLayer(net['conv6_p'], pool_function=T.mean)
net['softmax_p'] = NonlinearityLayer(net['average_pool_p'], nonlinearity=softmax)
net['output'] = net['softmax_p']
net['feature_maps'] = net['conv6_p']
net['last_activation'] = net['average_pool_p']
return net
def G_paper(
num_channels=1, # Overridden based on dataset.
resolution=32, # Overridden based on dataset.
label_size=0, # Overridden based on dataset.
fmap_base=4096,
fmap_decay=1.0,
fmap_max=256,
latent_size=None,
normalize_latents=True,
use_wscale=True,
use_pixelnorm=True,
use_leakyrelu=True,
use_batchnorm=False,
tanh_at_end=None,
**kwargs):
R = int(np.log2(resolution))
assert resolution == 2**R and resolution >= 4
cur_lod = theano.shared(np.float32(0.0))
def nf(stage):
return min(int(fmap_base / (2.0**(stage * fmap_decay))), fmap_max)
def PN(layer):
return PixelNormLayer(layer, name=layer.name +
'pn') if use_pixelnorm else layer
def BN(layer):
return lasagne.layers.batch_norm(layer) if use_batchnorm else layer
def WS(layer):
return WScaleLayer(layer, name=layer.name +
'S') if use_wscale else layer
if latent_size is None: latent_size = nf(0)
(act, iact) = (lrelu, ilrelu) if use_leakyrelu else (relu, irelu)
input_layers = [InputLayer(name='Glatents', shape=[None, latent_size])]
net = input_layers[-1]
if normalize_latents:
net = PixelNormLayer(net, name='Glnorm')
if label_size:
input_layers += [InputLayer(name='Glabels', shape=[None, label_size])]
net = ConcatLayer(name='Gina', incomings=[net, input_layers[-1]])
net = ReshapeLayer(name='Ginb', incoming=net, shape=[[0], [1], 1, 1])
net = PN(
BN(
WS(
Conv2DLayer(net,
name='G1a',
num_filters=nf(1),
filter_size=4,
pad='full',
nonlinearity=act,
W=iact))))
net = PN(
BN(
WS(
Conv2DLayer(net,
name='G1b',
num_filters=nf(1),
filter_size=3,
pad=1,
nonlinearity=act,
W=iact))))
lods = [net]
for I in xrange(2, R): # I = 2, 3, ..., R-1
net = Upscale2DLayer(net, name='G%dup' % I, scale_factor=2)
net = PN(
BN(
WS(
Conv2DLayer(net,
name='G%da' % I,
num_filters=nf(I),
filter_size=3,
pad=1,
nonlinearity=act,
W=iact))))
net = PN(
BN(
WS(
Conv2DLayer(net,
name='G%db' % I,
num_filters=nf(I),
filter_size=3,
pad=1,
nonlinearity=act,
W=iact))))
lods += [net]
lods = [
WS(
NINLayer(l,
name='Glod%d' % i,
num_units=num_channels,
nonlinearity=linear,
W=ilinear)) for i, l in enumerate(reversed(lods))
]
output_layer = LODSelectLayer(name='Glod',
incomings=lods,
cur_lod=cur_lod,
first_incoming_lod=0)
if tanh_at_end is not None:
output_layer = NonlinearityLayer(output_layer,
name='Gtanh',
nonlinearity=tanh)
if tanh_at_end != 1.0:
output_layer = non_trainable(
ScaleLayer(output_layer,
name='Gtanhs',
scales=lasagne.init.Constant(tanh_at_end)))
return dict(input_layers=input_layers,
output_layers=[output_layer],
cur_lod=cur_lod)
def __init__(self,
l_in=InputLayer((None, 3, 224, 224)),
get_layer='prob',
padded=True,
trainable=False,
regularizable=False,
name='vgg'):
super(Vgg16Layer, self).__init__(l_in, name)
self.l_in = l_in
self.get_layer = get_layer
self.padded = padded
self.trainable = trainable
self.regularizable = regularizable
if padded:
ConvLayer = PaddedConv2DLayer
PoolLayer = PaddedPool2DLayer
else:
try:
ConvLayer = lasagne.layers.dnn.Conv2DDNNLayer
except AttributeError:
ConvLayer = lasagne.layers.Conv2DLayer
PoolLayer = lasagne.layers.Pool2DLayer
net = OrderedDict()
net['input'] = l_in
net['bgr'] = RGBtoBGRLayer(net['input'])
net['conv1_1'] = ConvLayer(net['bgr'],
64,
3,
pad=1,
flip_filters=False)
net['conv1_2'] = ConvLayer(net['conv1_1'],
64,
3,
pad=1,
flip_filters=False)
net['pool1'] = PoolLayer(net['conv1_2'], 2)
net['conv2_1'] = ConvLayer(net['pool1'],
128,
3,
pad=1,
flip_filters=False)
net['conv2_2'] = ConvLayer(net['conv2_1'],
128,
3,
pad=1,
flip_filters=False)
net['pool2'] = PoolLayer(net['conv2_2'], 2)
net['conv3_1'] = ConvLayer(net['pool2'],
256,
3,
pad=1,
flip_filters=False)
net['conv3_2'] = ConvLayer(net['conv3_1'],
256,
3,
pad=1,
flip_filters=False)
net['conv3_3'] = ConvLayer(net['conv3_2'],
256,
3,
pad=1,
flip_filters=False)
net['pool3'] = PoolLayer(net['conv3_3'], 2)
net['conv4_1'] = ConvLayer(net['pool3'],
512,
3,
pad=1,
flip_filters=False)
net['conv4_2'] = ConvLayer(net['conv4_1'],
512,
3,
pad=1,
flip_filters=False)
net['conv4_3'] = ConvLayer(net['conv4_2'],
512,
3,
pad=1,
flip_filters=False)
net['pool4'] = PoolLayer(net['conv4_3'], 2)
net['conv5_1'] = ConvLayer(net['pool4'],
512,
3,
pad=1,
flip_filters=False)
net['conv5_2'] = ConvLayer(net['conv5_1'],
512,
3,
pad=1,
flip_filters=False)
net['conv5_3'] = ConvLayer(net['conv5_2'],
512,
3,
pad=1,
flip_filters=False)
net['pool5'] = PoolLayer(net['conv5_3'], 2)
if 'fc' in get_layer or get_layer == 'prob':
net['fc6'] = DenseLayer(net['pool5'], num_units=4096)
net['fc7'] = DenseLayer(net['fc6'], num_units=4096)
net['fc8'] = DenseLayer(net['fc7'],
num_units=1000,
nonlinearity=None)
net['prob'] = NonlinearityLayer(net['fc8'], softmax)
self.concat_sublayers = []
if 'concat' in get_layer:
n_pool = get_layer[6:]
get_layer = 'pool' + str(n_pool)
l_concat = net['conv1_1']
for i in range(int(n_pool)):
l_conv = net['conv' + str(i + 1) + '_1']
l_pool = net['pool' + str(i + 1)]
l_new = ConvLayer(l_concat,
l_conv.num_filters,
2,
pad=0,
stride=2,
flip_filters=True,
name='vgg16_skipconnection_conv_' +
str(i + 1))
self.concat_sublayers.append(l_new)
l_concat = ConcatLayer(
(l_pool, l_new),
axis=1,
name='vgg16_skipconnection_concat_' + str(i))
self.concat_sublayers.append(l_concat)
out_layer = l_concat
else:
out_layer = net[get_layer]
reached = False
# Collect garbage
for el in net.iteritems():
if reached:
del (net[el[0]])
if el[0] == get_layer:
reached = True
self.sublayers = net
# Set names to layers
for name in net.keys():
if not net[name].name:
net[name].name = 'vgg16_' + name
# Reload weights
nparams = len(lasagne.layers.get_all_params(net.values()))
with open('w_vgg16.pkl', 'rb') as f:
# Note: in python3 use the pickle.load parameter
# `encoding='latin-1'`
vgg16_w = pickle.load(f)['param values']
lasagne.layers.set_all_param_values(net.values(), vgg16_w[:nparams])
# Do not train or regularize vgg
if not trainable or not regularizable:
all_layers = net.values()
for vgg_layer in all_layers:
if 'concat' not in vgg_layer.name:
layer_params = vgg_layer.get_params()
for p in layer_params:
if not regularizable:
try:
vgg_layer.params[p].remove('regularizable')
except KeyError:
pass
if not trainable:
try:
vgg_layer.params[p].remove('trainable')
except KeyError:
pass
# save the vgg sublayers
self.out_layer = out_layer
# HACK LASAGNE
# This will set `self.input_layer`, which is needed by Lasagne to find
# the layers with the get_all_layers() helper function in the
# case of a layer with sublayers
if isinstance(self.out_layer, tuple):
self.input_layer = None
else:
self.input_layer = self.out_layer
def construct_unet(channels=1, no_f_base=8, f_size=3, dropout=False, bs=None, class_nums=2, pad="same",nonlinearity=lasagne.nonlinearities.rectify, input_dim=[512,512]):
net={}
net["input"]= InputLayer(shape=(bs, channels, input_dim[0], input_dim[1]))
# Moving downwards the U-shape. Simplified:
net["conv_down11"] = Conv2DLayer(net["input"],no_f_base,f_size,pad=pad,nonlinearity=nonlinearity,W=lasagne.init.HeNormal(gain='relu'))
net["conv_down12"] = Conv2DLayer(net["conv_down11"],no_f_base,f_size,pad=pad,nonlinearity=nonlinearity,W=lasagne.init.HeNormal(gain='relu'))
net["pool1"] = Pool2DLayer(net["conv_down12"],pool_size=2)
net["conv_down21"] = Conv2DLayer(net["pool1"],no_f_base*2,f_size,pad=pad,nonlinearity=nonlinearity,W=lasagne.init.HeNormal(gain='relu'))
net["conv_down22"] = Conv2DLayer(net["conv_down21"],no_f_base*2,f_size,pad=pad,nonlinearity=nonlinearity,W=lasagne.init.HeNormal(gain='relu'))
net["pool2"] = Pool2DLayer(net["conv_down22"],pool_size=2)
net["conv_down31"] = Conv2DLayer(net["pool2"],no_f_base*4,f_size,pad=pad,nonlinearity=nonlinearity,W=lasagne.init.HeNormal(gain='relu'))
net["conv_down32"] = Conv2DLayer(net["conv_down31"],no_f_base*4,f_size,pad=pad,nonlinearity=nonlinearity,W=lasagne.init.HeNormal(gain='relu'))
net["pool3"] = Pool2DLayer(net["conv_down32"],pool_size=2)
net["conv_down41"] = Conv2DLayer(net["pool3"],no_f_base*8,f_size,pad=pad,nonlinearity=nonlinearity,W=lasagne.init.HeNormal(gain='relu'))
net["conv_down42"] = Conv2DLayer(net["conv_down41"],no_f_base*8,f_size,pad=pad,nonlinearity=nonlinearity,W=lasagne.init.HeNormal(gain='relu'))
to_drop1 = net["pool4"] = Pool2DLayer(net["conv_down42"],pool_size=2)
if dropout:
to_drop1 = DropoutLayer(to_drop1, p=0.5)
#vvvv bottom vvvv
net["conv_bottom1"] = Conv2DLayer(to_drop1,no_f_base*16,f_size,pad=pad,nonlinearity=nonlinearity,W=lasagne.init.HeNormal(gain='relu'))
net["conv_bottom2"] = Conv2DLayer(net["conv_bottom1"],no_f_base*16,f_size,pad=pad,nonlinearity=nonlinearity,W=lasagne.init.HeNormal(gain='relu'))
net["deconv_bottom1"] = Deconv2DLayer(net["conv_bottom2"], no_f_base*8, 2, 2)
#^^^^ bottom ^^^^
# Moving upwards the U-shape. Simplified:
net["concat1"] = concat([net["deconv_bottom1"], net["conv_down42"]], cropping=(None, None, "center", "center"))
net["conv_up11"]= Conv2DLayer(net["concat1"], no_f_base*8, f_size, pad=pad, nonlinearity=nonlinearity,W=lasagne.init.HeNormal(gain='relu'))
net["conv_up11"]= Conv2DLayer(net["conv_up11"], no_f_base*8, f_size, pad=pad, nonlinearity=nonlinearity,W=lasagne.init.HeNormal(gain='relu'))
net["deconv_up1"] = Deconv2DLayer(net["conv_up11"], no_f_base*4, 2, 2)
net["concat2"] = concat([net["deconv_up1"], net["conv_down32"]], cropping=(None, None, "center", "center"))
net["conv_up21"]= Conv2DLayer(net["concat2"], no_f_base*4, f_size, pad=pad, nonlinearity=nonlinearity,W=lasagne.init.HeNormal(gain='relu'))
net["conv_up22"]= Conv2DLayer(net["conv_up21"], no_f_base*4, f_size, pad=pad, nonlinearity=nonlinearity,W=lasagne.init.HeNormal(gain='relu'))
net["deconv_up2"] = Deconv2DLayer(net["conv_up22"], no_f_base*2, 2, 2)
net["concat3"] = concat([net["deconv_up2"], net["conv_down22"]], cropping=(None, None, "center", "center"))
net["conv_up31"]= Conv2DLayer(net["concat3"], no_f_base*2, f_size, pad=pad, nonlinearity=nonlinearity,W=lasagne.init.HeNormal(gain='relu'))
net["conv_up32"]= Conv2DLayer(net["conv_up31"], no_f_base*2, f_size, pad=pad, nonlinearity=nonlinearity,W=lasagne.init.HeNormal(gain='relu'))
net["deconv_up3"] = Deconv2DLayer(net["conv_up32"], no_f_base, 2, 2)
net["concat4"] = concat([net["deconv_up3"], net["conv_down12"]], cropping=(None, None, "center", "center"))
net["conv_up41"]= Conv2DLayer(net["concat4"], no_f_base, f_size, pad=pad, nonlinearity=nonlinearity,W=lasagne.init.HeNormal(gain='relu'))
net["conv_up42"]= Conv2DLayer(net["conv_up41"], no_f_base, f_size, pad=pad, nonlinearity=nonlinearity,W=lasagne.init.HeNormal(gain='relu'))
# Class layer: Work around standard softmax bc. it doesn't work with tensor4/3.
# Hence, we reshape and feed it to an external Nonlinearity layer.
# net["class_ns"] is the output in image-related shape.
net["out"] = Conv2DLayer(net["conv_up42"], class_nums, 1, nonlinearity=None,W=lasagne.init.HeNormal(gain='relu'))
net["layer_shuffle_dim"] = DimshuffleLayer(net["out"], (1, 0, 2, 3))
net["reshape_layer"] = ReshapeLayer(net["layer_shuffle_dim"], (class_nums, -1))
net["layer_shuffle_dim2"] = DimshuffleLayer(net["reshape_layer"], (1, 0))
# Flattened output to be able to feed it to lasagne.objectives.categorical_crossentropy.
net["out_optim"] = NonlinearityLayer(net["layer_shuffle_dim2"], nonlinearity=lasagne.nonlinearities.softmax)
return net
net = None
net['expand_4_2'] = batch_norm(
ConvLayer(net['expand_4_1'],
base_n_filters,
3,
nonlinearity=nonlinearity,
pad=pad,
W=HeNormal(gain="relu")))
net['output_segmentation'] = ConvLayer(net['expand_4_2'],
num_output_classes,
1,
nonlinearity=None)
net['dimshuffle'] = DimshuffleLayer(net['output_segmentation'], (1, 0, 2, 3))
net['reshapeSeg'] = ReshapeLayer(net['dimshuffle'], (num_output_classes, -1))
net['dimshuffle2'] = DimshuffleLayer(net['reshapeSeg'], (1, 0))
net['output_flattened'] = NonlinearityLayer(
net['dimshuffle2'], nonlinearity=lasagne.nonlinearities.softmax)
x_sym = T.tensor4()
seg_sym = T.ivector()
w_sym = T.vector()
output_layer_for_loss = net["output_flattened"]
# add some weight decay
l2_loss = lasagne.regularization.regularize_network_params(
output_layer_for_loss, lasagne.regularization.l2) * 1e-4
# the distinction between prediction_train and test is important only if we enable dropout
prediction_train = lasagne.layers.get_output(output_layer_for_loss,
x_sym,
deterministic=False,
def main():
print("Building model and compiling functions...")
X_batch = [T.tensor4('x')]
y_batch = [T.tensor4('y')]
net = {}
net['input'] = InputLayer((None, 3, 256, 256), input_var= X_batch[0])
net['conv1_1'] = ConvLayer(
net['input'], 64, 3, pad=1, flip_filters=False)
net['conv1_2'] = ConvLayer(
net['conv1_1'], 64, 3, pad=1, flip_filters=False)
net['pool1'] = PoolLayer(net['conv1_2'], 2)
net['conv2_1'] = ConvLayer(
net['pool1'], 128, 3, pad=1, flip_filters=False)
net['conv2_2'] = ConvLayer(
net['conv2_1'], 128, 3, pad=1, flip_filters=False)
net['pool2'] = PoolLayer(net['conv2_2'], 2)
net['conv3_1'] = ConvLayer(
net['pool2'], 256, 3, pad=1, flip_filters=False)
net['conv3_2'] = ConvLayer(
net['conv3_1'], 256, 3, pad=1, flip_filters=False)
net['conv3_3'] = ConvLayer(
net['conv3_2'], 256, 3, pad=1, flip_filters=False)
net['pool3'] = PoolLayer(net['conv3_3'], 2)
net['conv4_1'] = ConvLayer(
net['pool3'], 512, 3, pad=1, flip_filters=False)
net['conv4_2'] = ConvLayer(
net['conv4_1'], 512, 3, pad=1, flip_filters=False)
net['conv4_3'] = ConvLayer(
net['conv4_2'], 512, 3, pad=1, flip_filters=False)
net['pool4'] = PoolLayer(net['conv4_3'], 2)
net['conv5_1'] = ConvLayer(
net['pool4'], 512, 3, pad=1, flip_filters=False)
net['conv5_2'] = ConvLayer(
net['conv5_1'], 512, 3, pad=1, flip_filters=False)
net['conv5_3'] = ConvLayer(
net['conv5_2'], 512, 3, pad=1, flip_filters=False)
initSal = {}
initSal['up'] = Upscale2DLayer(net['conv5_3'], (2, 2))
initSal['concat'] = ConcatLayer([initSal['up'], net['conv4_3']])
initSal['conv1'] = ConvLayer(initSal['concat'], 1024, (3, 3), pad=1, flip_filters=False)
initSal['conv2'] = ConvLayer(initSal['conv1'], 512, (1, 1), pad=0, flip_filters=False)
initSal['conv3'] = ConvLayer(initSal['conv2'], 256, (5, 5), pad=2, flip_filters=False)
initSal['output'] = ConvLayer(initSal['conv3'], 1, (1, 1), nonlinearity=lasagne.nonlinearities.sigmoid, flip_filters=False)
# ***************************************************************************************************
recurent = {}
recurent['1-sal'] = BatchNormLayer(Upscale2DLayer(initSal['conv3'], (2, 2)))
recurent['1-vgg'] = BatchNormLayer(ConvLayer(net['conv3_3'], 256, 1))
recurent['1-input'] = ConcatLayer([recurent['1-sal'], recurent['1-vgg']])
recurent['1-NIN1'] = ConvLayer(recurent['1-input'], 256, 1, pad=0, nonlinearity=lasagne.nonlinearities.linear, flip_filters=False)
recurent['1-NIN1'] = NonlinearityLayer(BatchNormLayer(recurent['1-NIN1']))
recurent['1-rconv1'] = ConvLayer(recurent['1-NIN1'], 256, 3, pad=1, nonlinearity=lasagne.nonlinearities.linear, flip_filters=False)
recurent['1-rconv1'] = NonlinearityLayer(BatchNormLayer(recurent['1-rconv1']))
recurent['1-rconv2'] = ConvLayer(recurent['1-rconv1'], 256, 3, pad=1, flip_filters=False)
recurent['1-rconv2'] = NonlinearityLayer(BatchNormLayer(recurent['1-rconv2']))
recurent['1-rconv3'] = ConvLayer(recurent['1-rconv2'], 256, 1, nonlinearity=lasagne.nonlinearities.linear, flip_filters=False)
recurent['1-sum'] = ElemwiseSumLayer([recurent['1-rconv3'], recurent['1-sal']])
recurent['1-sum'] = NonlinearityLayer(recurent['1-sum'])
# ***************************************************************************************************
recurent['2-sal'] = BatchNormLayer(Upscale2DLayer(recurent['1-sum'], (2, 2)))
recurent['2-vgg'] = BatchNormLayer(ConvLayer(net['conv2_2'], 256, 1))
recurent['2-input'] = ConcatLayer([recurent['2-sal'], recurent['2-vgg']])
recurent['2-NIN1'] = ConvLayer(recurent['2-input'], 256, 1, pad=0, nonlinearity=lasagne.nonlinearities.linear, flip_filters=False)
recurent['2-NIN1'] = NonlinearityLayer(BatchNormLayer(recurent['2-NIN1']))
recurent['2-rconv1'] = ConvLayer(recurent['2-NIN1'], 256, 3, pad=1, flip_filters=False)
recurent['2-rconv1'] = NonlinearityLayer(BatchNormLayer(recurent['2-rconv1']))
recurent['2-rconv2'] = ConvLayer(recurent['2-rconv1'], 256, 3, pad=1, flip_filters=False)
recurent['2-rconv2'] = NonlinearityLayer(BatchNormLayer(recurent['2-rconv2']))
recurent['2-rconv3'] = ConvLayer(recurent['2-rconv2'], 256, 1, nonlinearity=lasagne.nonlinearities.linear, flip_filters=False)
recurent['2-sum'] = ElemwiseSumLayer([recurent['2-rconv3'], recurent['2-sal']])
recurent['2-sum'] = NonlinearityLayer(recurent['2-sum'])
# ***************************************************************************************************
recurent['3-sal'] = BatchNormLayer(Upscale2DLayer(recurent['2-sum'], (2, 2)))
recurent['3-vgg'] = ConvLayer(net['conv1_2'], 128, 3, pad=1)
recurent['3-vgg'] = BatchNormLayer(ConvLayer(recurent['3-vgg'], 256, 1))
recurent['3-input'] = ConcatLayer([recurent['3-sal'], recurent['3-vgg']])
recurent['3-NIN1'] = ConvLayer(recurent['3-input'], 256, 1, pad=0, flip_filters=False)
recurent['3-NIN1'] = NonlinearityLayer(BatchNormLayer(recurent['3-NIN1']))
recurent['3-rconv1'] = ConvLayer(recurent['3-NIN1'], 256, 3, pad=1, nonlinearity=lasagne.nonlinearities.linear, flip_filters=False)
recurent['3-rconv1'] = NonlinearityLayer(BatchNormLayer(recurent['3-rconv1']))
recurent['3-rconv2'] = ConvLayer(recurent['3-rconv1'], 256, 3, pad=1, flip_filters=False)
recurent['3-rconv2'] = NonlinearityLayer(BatchNormLayer(recurent['3-rconv2']))
recurent['3-rconv3'] = ConvLayer(recurent['3-rconv2'], 256, 1, nonlinearity=lasagne.nonlinearities.linear, flip_filters=False)
recurent['3-sum'] = ElemwiseSumLayer([recurent['3-rconv3'], recurent['3-sal']])
recurent['3-sum'] = NonlinearityLayer(recurent['3-sum'])
recurent['3-output'] = ConvLayer(recurent['3-sum'], 1, (1, 1), nonlinearity=lasagne.nonlinearities.sigmoid, flip_filters=False)
prediction = []
# loss_train = []
# all_params = []
# accuracy = []
output_layer = recurent['3-output']
prediction.append(lasagne.layers.get_output(output_layer))
# loss_train.append(T.mean(lasagne.objectives.binary_crossentropy(prediction[0], y_batch[0])))
# all_params.append(lasagne.layers.get_all_params(output_layer, trainable=True))
# accuracy.append(T.mean(T.square(prediction[0]-y_batch[0]))),
# updates = OrderedDict()
# update = lasagne.updates.sgd(loss_train[0], all_params[0][32::], LEARNING_RATE)
# updates.update(update)
# updates = lasagne.updates.apply_nesterov_momentum(updates, momentum=MOMENTUM)
FitSetting = dict(
Input_Shape=Input_Shape,
Output_Shape=Output_Shape,
output_layer=output_layer,
saveParamName=saveParamName,
)
output_layer = [output_layer]
output = lasagne.layers.get_output(output_layer)
Fun_test(['./image/'], ['.jpg'], FitSetting, X_batch, output, writeimg=['TPRPN'])
def build_fan_reworked(input_var,
nb_filter=16,
input_size=(None, 3, tools.INP_PSIZE, tools.INP_PSIZE)):
net = OrderedDict()
# Input, standardization
last = net['input'] = InputLayer(input_size, input_var=input_var)
last = net['norm'] = ExpressionLayer(last, lambda x: normalize(x))
# load feature encoder
feats = get_features(last)
net['features_s8_1'] = feats["conv4_4"]
net['features_s8_2'] = feats["conv4_1"]
net['features_s4'] = feats["conv3_3"]
# Pretrained Encoder as before
last = net["conv1_1"] = ConvLayer(last,
nb_filter,
1,
pad=0,
flip_filters=False,
nonlinearity=linear)
last = net["bn1_1"] = layers.NonUpdateBatchNormLayer(last)
last = net["relu1_1"] = NonlinearityLayer(last, nonlinearity=rectify)
last = net["conv1_2"] = ConvLayer(last,
nb_filter,
1,
pad=0,
flip_filters=False,
nonlinearity=linear)
last = net["bn1_2"] = layers.NonUpdateBatchNormLayer(last)
last = net["relu1_2"] = NonlinearityLayer(last, nonlinearity=rectify)
# feature aggregation at multiple scales
last = net["bn1"] = layers.NonUpdateBatchNormLayer(last,
beta=None,
gamma=None)
last = fan_module_improved(last,
net,
"s8_1",
net['features_s8_1'],
nb_filter=nb_filter,
scale=8,
upsampling_strategy="repeat")
last = net["bn2"] = layers.NonUpdateBatchNormLayer(last,
beta=None,
gamma=None)
last = fan_module_improved(last,
net,
"s8_2",
net['features_s8_2'],
nb_filter=nb_filter,
scale=8,
upsampling_strategy="repeat")
last = net["bn3"] = layers.NonUpdateBatchNormLayer(last,
beta=None,
gamma=None)
last = fan_module_improved(last,
net,
"s4",
net['features_s4'],
nb_filter=nb_filter,
scale=4,
upsampling_strategy="repeat")
# unclear if Fixed, NonUpdate or Regular Layer will work best...
last = net["bn4"] = BatchNormLayer(last)
# Decoder as before
last = net["deconv1_2"] = transpose(last,
net["conv1_2"],
nonlinearity=None)
last = net["deconv1_1"] = transpose(last,
net["conv1_1"],
nonlinearity=None)
return last, net
def G_mnist_mode_recovery(num_channels=1,
resolution=32,
fmap_base=64,
fmap_decay=1.0,
fmap_max=256,
latent_size=None,
label_size=10,
normalize_latents=True,
use_wscale=False,
use_pixelnorm=False,
use_batchnorm=True,
tanh_at_end=True,
progressive=False,
**kwargs):
R = int(np.log2(resolution))
assert resolution == 2**R and resolution >= 4
cur_lod = theano.shared(np.float32(0.0))
def nf(stage):
return min(int(fmap_base / (2.0**(stage * fmap_decay))), fmap_max)
def PN(layer):
return PixelNormLayer(layer, name=layer.name +
'pn') if use_pixelnorm else layer
def BN(layer):
return lasagne.layers.batch_norm(layer) if use_batchnorm else layer
def WS(layer):
return WScaleLayer(layer, name=layer.name +
'S') if use_wscale else layer
if latent_size is None: latent_size = nf(0)
input_layers = [InputLayer(name='Glatents', shape=[None, latent_size])]
net = input_layers[-1]
if normalize_latents:
net = PixelNormLayer(net, name='Glnorm')
if label_size:
input_layers += [InputLayer(name='Glabels', shape=[None, label_size])]
net = ConcatLayer(name='Gina', incomings=[net, input_layers[-1]])
net = ReshapeLayer(name='Ginb', incoming=net, shape=[[0], [1], 1, 1])
net = PN(
BN(
WS(
Conv2DLayer(net,
name='G1a',
num_filters=64,
filter_size=4,
pad='full',
nonlinearity=vlrelu,
W=irelu))))
lods = [net]
for I in xrange(2, R): # I = 2, 3, ..., R-1
net = Upscale2DLayer(net, name='G%dup' % I, scale_factor=2)
net = PN(
BN(
WS(
Conv2DLayer(net,
name='G%da' % I,
num_filters=nf(I - 1),
filter_size=3,
pad=1,
nonlinearity=vlrelu,
W=irelu))))
lods += [net]
if progressive:
lods = [
WS(
Conv2DLayer(l,
name='Glod%d' % i,
num_filters=num_channels,
filter_size=3,
pad=1,
nonlinearity=linear,
W=ilinear)) for i, l in enumerate(reversed(lods))
] # Should be this
#lods = [WS(NINLayer(l, name='Glod%d' % i, num_units=num_channels, nonlinearity=linear, W=ilinear)) for i, l in enumerate(reversed(lods))] # .. but this is better
output_layer = LODSelectLayer(name='Glod',
incomings=lods,
cur_lod=cur_lod,
first_incoming_lod=0)
else:
net = WS(
Conv2DLayer(net,
name='toRGB',
num_filters=num_channels,
filter_size=3,
pad=1,
nonlinearity=linear,
W=ilinear)) # Should be this
#net = WS(NINLayer(net, name='toRGB', num_units=num_channels, nonlinearity=linear, W=ilinear)) # .. but this is better
output_layer = net
if tanh_at_end:
output_layer = NonlinearityLayer(output_layer,
name='Gtanh',
nonlinearity=tanh)
return dict(input_layers=input_layers,
output_layers=[output_layer],
cur_lod=cur_lod)
def build_model():
net = {}
net['input'] = InputLayer((None, 3, 224, 224))
net['conv1_1'] = ConvLayer(net['input'], 64, 3, pad=1, flip_filters=False)
net['conv1_2'] = ConvLayer(net['conv1_1'],
64,
3,
pad=1,
flip_filters=False)
net['pool1'] = PoolLayer(net['conv1_2'], 2)
net['conv2_1'] = ConvLayer(net['pool1'], 128, 3, pad=1, flip_filters=False)
net['conv2_2'] = ConvLayer(net['conv2_1'],
128,
3,
pad=1,
flip_filters=False)
net['pool2'] = PoolLayer(net['conv2_2'], 2)
net['conv3_1'] = ConvLayer(net['pool2'], 256, 3, pad=1, flip_filters=False)
net['conv3_2'] = ConvLayer(net['conv3_1'],
256,
3,
pad=1,
flip_filters=False)
net['conv3_3'] = ConvLayer(net['conv3_2'],
256,
3,
pad=1,
flip_filters=False)
net['conv3_4'] = ConvLayer(net['conv3_3'],
256,
3,
pad=1,
flip_filters=False)
net['pool3'] = PoolLayer(net['conv3_4'], 2)
net['conv4_1'] = ConvLayer(net['pool3'], 512, 3, pad=1, flip_filters=False)
net['conv4_2'] = ConvLayer(net['conv4_1'],
512,
3,
pad=1,
flip_filters=False)
net['conv4_3'] = ConvLayer(net['conv4_2'],
512,
3,
pad=1,
flip_filters=False)
net['conv4_4'] = ConvLayer(net['conv4_3'],
512,
3,
pad=1,
flip_filters=False)
net['pool4'] = PoolLayer(net['conv4_4'], 2)
net['conv5_1'] = ConvLayer(net['pool4'], 512, 3, pad=1, flip_filters=False)
net['conv5_2'] = ConvLayer(net['conv5_1'],
512,
3,
pad=1,
flip_filters=False)
net['conv5_3'] = ConvLayer(net['conv5_2'],
512,
3,
pad=1,
flip_filters=False)
net['conv5_4'] = ConvLayer(net['conv5_3'],
512,
3,
pad=1,
flip_filters=False)
net['pool5'] = PoolLayer(net['conv5_4'], 2)
net['fc6'] = DenseLayer(net['pool5'], num_units=4096)
net['drop6'] = DropoutLayer(net['fc6'], p=0.6)
net['fc7'] = DenseLayer(net['drop6'], num_units=4096)
net['drop7'] = DropoutLayer(net['fc7'], p=0.6)
net['fc8'] = DenseLayer(net['drop7'], num_units=1000, nonlinearity=None)
net['prob'] = NonlinearityLayer(net['fc8'], softmax)
return net
def build_network_final_layer(cls,
input_shape=None,
pool_layers_to_expand=None,
pool_layers_to_remove=None,
full_conv=False,
pad_fc6=False,
last_layer_name=None,
input_layer_constructor=None,
**kwargs):
if pool_layers_to_expand is None:
pool_layers_to_expand = set()
elif isinstance(pool_layers_to_expand, six.string_types):
pool_layers_to_expand = {pool_layers_to_expand}
elif isinstance(pool_layers_to_expand, set):
pass
else:
raise ValueError(
'pool_layers_to_expand should be None, a string or a set, not a {}'
.format(type(pool_layers_to_expand)))
if pool_layers_to_remove is None:
pool_layers_to_remove = set()
elif isinstance(pool_layers_to_remove, six.string_types):
pool_layers_to_remove = {pool_layers_to_remove}
elif isinstance(pool_layers_to_remove, set):
pass
else:
raise ValueError(
'pool_layers_to_remove should be None, a string or a set, not a {}'
.format(type(pool_layers_to_remove)))
if input_shape is None:
# Default input shape: 3 channel images of size 224 x 224.
input_shape = (3, 224, 224)
dilation = 1
try:
if input_layer_constructor is None:
# Input layer: shape is of the form (sample, channel, height, width).
# We leave the sample dimension with no size (`None`) so that the
# minibatch size is whatever we need it to be when we use it
net = InputLayer((None, ) + input_shape, name='input')
else:
net = input_layer_constructor()
if last_layer_name == 'input':
raise StopIteration
# First two convolutional layers: 64 filters, 3x3 convolution, 1 pixel padding
net, dilation = cls.conv_2d_layer(net, 'conv1_1', 64, 3, dilation)
if last_layer_name == 'conv1_1':
raise StopIteration
net, dilation = cls.conv_2d_layer(net, 'conv1_2', 64, 3, dilation)
if last_layer_name == 'conv1_2':
raise StopIteration
# 2x2 max-pooling; will reduce size from 224x224 to 112x112
net, dilation = cls.pool_2d_layer(net, 'pool1', 2, dilation,
pool_layers_to_expand,
pool_layers_to_remove)
if last_layer_name == 'pool1':
raise StopIteration
# Two convolutional layers, 128 filters
net, dilation = cls.conv_2d_layer(net, 'conv2_1', 128, 3, dilation)
if last_layer_name == 'conv2_1':
raise StopIteration
net, dilation = cls.conv_2d_layer(net, 'conv2_2', 128, 3, dilation)
if last_layer_name == 'conv2_2':
raise StopIteration
# 2x2 max-pooling; will reduce size from 112x112 to 56x56
net, dilation = cls.pool_2d_layer(net, 'pool2', 2, dilation,
pool_layers_to_expand,
pool_layers_to_remove)
if last_layer_name == 'pool2':
raise StopIteration
# Three convolutional layers, 256 filters
net, dilation = cls.conv_2d_layer(net, 'conv3_1', 256, 3, dilation)
if last_layer_name == 'conv3_1':
raise StopIteration
net, dilation = cls.conv_2d_layer(net, 'conv3_2', 256, 3, dilation)
if last_layer_name == 'conv3_2':
raise StopIteration
net, dilation = cls.conv_2d_layer(net, 'conv3_3', 256, 3, dilation)
if last_layer_name == 'conv3_3':
raise StopIteration
# 2x2 max-pooling; will reduce size from 56x56 to 28x28
net, dilation = cls.pool_2d_layer(net, 'pool3', 2, dilation,
pool_layers_to_expand,
pool_layers_to_remove)
if last_layer_name == 'pool3':
raise StopIteration
# Three convolutional layers, 512 filters
net, dilation = cls.conv_2d_layer(net, 'conv4_1', 512, 3, dilation)
if last_layer_name == 'conv4_1':
raise StopIteration
net, dilation = cls.conv_2d_layer(net, 'conv4_2', 512, 3, dilation)
if last_layer_name == 'conv4_2':
raise StopIteration
net, dilation = cls.conv_2d_layer(net, 'conv4_3', 512, 3, dilation)
if last_layer_name == 'conv4_3':
raise StopIteration
# 2x2 max-pooling; will reduce size from 28x28 to 14x14
net, dilation = cls.pool_2d_layer(net, 'pool4', 2, dilation,
pool_layers_to_expand,
pool_layers_to_remove)
if last_layer_name == 'pool4':
raise StopIteration
# Three convolutional layers, 512 filters
net, dilation = cls.conv_2d_layer(net, 'conv5_1', 512, 3, dilation)
if last_layer_name == 'conv5_1':
raise StopIteration
net, dilation = cls.conv_2d_layer(net, 'conv5_2', 512, 3, dilation)
if last_layer_name == 'conv5_2':
raise StopIteration
net, dilation = cls.conv_2d_layer(net, 'conv5_3', 512, 3, dilation)
if last_layer_name == 'conv5_3':
raise StopIteration
# 2x2 max-pooling; will reduce size from 14x14 to 7x7
net, dilation = cls.pool_2d_layer(net, 'pool5', 2, dilation,
pool_layers_to_expand,
pool_layers_to_remove)
if last_layer_name == 'pool5':
raise StopIteration
if dilation == 1 and not full_conv:
# Dense layer, 4096 units
net = DenseLayer(net, num_units=4096, name='fc6')
if last_layer_name == 'fc6':
raise StopIteration
# 50% dropout (only applied during training, turned off during prediction)
net = DropoutLayer(net, p=0.5, name='fc6_dropout')
if last_layer_name == 'fc6_dropout':
raise StopIteration
# Dense layer, 4096 units
net = DenseLayer(net, num_units=4096, name='fc7')
if last_layer_name == 'fc7':
raise StopIteration
# 50% dropout (only applied during training, turned off during prediction)
net = DropoutLayer(net, p=0.5, name='fc7_dropout')
if last_layer_name == 'fc7_dropout':
raise StopIteration
# Final dense layer, 1000 units: 1 for each class
net = DenseLayer(net,
num_units=1000,
nonlinearity=None,
name='fc8')
if last_layer_name == 'fc8':
raise StopIteration
# Softmax non-linearity that will generate probabilities
net = NonlinearityLayer(net, softmax, name='prob')
elif full_conv:
# Dense layer as 7x7 convolution, 4096 units
fc6_padding = 3 if pad_fc6 else 0
net, dilation = cls.conv_2d_layer(net,
'fc6',
4096,
7,
dilation,
pad=fc6_padding)
if last_layer_name == 'fc6':
raise StopIteration
# 50% dropout (only applied during training, turned off during prediction)
net = DropoutLayer(net, p=0.5, name='fc6_dropout')
if last_layer_name == 'fc6_dropout':
raise StopIteration
# Dense layer, 4096 units
net, dilation = cls.nin_layer(net, 'fc7', 4096, dilation)
if last_layer_name == 'fc7':
raise StopIteration
# 50% dropout (only applied during training, turned off during prediction)
net = DropoutLayer(net, p=0.5, name='fc7_dropout')
if last_layer_name == 'fc7_dropout':
raise StopIteration
# Final dense layer, 1000 units: 1 for each class
net, dilation = cls.nin_layer(net,
'fc8',
1000,
dilation,
nonlinearity=None)
if last_layer_name == 'fc8':
raise StopIteration
# Softmax non-linearity that will generate probabilities
net = NonlinearityLayer(net,
functools.partial(
util.flexible_softmax, axis=1),
name='prob')
except StopIteration:
pass
return net
def build_vgg_model(prefix,
inputLayer=net_input,
classificationFlag=False,
stnFlag=False,
dropout_ratio=0.5):
net = {}
net[prefix + 'input'] = inputLayer
net[prefix + 'conv1_1'] = ConvLayer(net[prefix + 'input'],
64,
3,
pad=1,
flip_filters=False,
name=prefix + 'conv1_1')
net[prefix + 'conv1_2'] = ConvLayer(net[prefix + 'conv1_1'],
64,
3,
pad=1,
flip_filters=False,
name=prefix + 'conv1_2')
net[prefix + 'pool1'] = PoolLayer(net[prefix + 'conv1_2'],
2,
name=prefix + 'pool1')
net[prefix + 'conv2_1'] = ConvLayer(net[prefix + 'pool1'],
128,
3,
pad=1,
flip_filters=False,
name=prefix + 'conv2_1')
net[prefix + 'conv2_2'] = ConvLayer(net[prefix + 'conv2_1'],
128,
3,
pad=1,
flip_filters=False,
name=prefix + 'conv2_2')
net[prefix + 'pool2'] = PoolLayer(net[prefix + 'conv2_2'],
2,
name=prefix + 'pool2')
net[prefix + 'conv3_1'] = ConvLayer(net[prefix + 'pool2'],
256,
3,
pad=1,
flip_filters=False,
name=prefix + 'conv3_1')
net[prefix + 'conv3_2'] = ConvLayer(net[prefix + 'conv3_1'],
256,
3,
pad=1,
flip_filters=False,
name=prefix + 'conv3_2')
net[prefix + 'conv3_3'] = ConvLayer(net[prefix + 'conv3_2'],
256,
3,
pad=1,
flip_filters=False,
name=prefix + 'conv3_3')
net[prefix + 'pool3'] = PoolLayer(net[prefix + 'conv3_3'],
2,
name=prefix + 'pool3')
net[prefix + 'conv4_1'] = ConvLayer(net[prefix + 'pool3'],
512,
3,
pad=1,
flip_filters=False,
name=prefix + 'conv4_1')
net[prefix + 'conv4_2'] = ConvLayer(net[prefix + 'conv4_1'],
512,
3,
pad=1,
flip_filters=False,
name=prefix + 'conv4_2')
net[prefix + 'conv4_3'] = ConvLayer(net[prefix + 'conv4_2'],
512,
3,
pad=1,
flip_filters=False,
name=prefix + 'conv4_3')
net[prefix + 'pool4'] = PoolLayer(net[prefix + 'conv4_3'],
2,
name=prefix + 'pool4')
net[prefix + 'conv5_1'] = ConvLayer(net[prefix + 'pool4'],
512,
3,
pad=1,
flip_filters=False,
name=prefix + 'conv5_1')
net[prefix + 'conv5_2'] = ConvLayer(net[prefix + 'conv5_1'],
512,
3,
pad=1,
flip_filters=False,
name=prefix + 'conv5_2')
net[prefix + 'conv5_3'] = ConvLayer(net[prefix + 'conv5_2'],
512,
3,
pad=1,
flip_filters=False,
name=prefix + 'conv5_3')
net[prefix + 'pool5'] = PoolLayer(net[prefix + 'conv5_3'],
2,
name=prefix + 'pool5')
if stnFlag == False:
net[prefix + 'fc6'] = DenseLayer(net[prefix + 'pool5'],
num_units=4096,
name=prefix + 'fc6')
net[prefix + 'fc6_dropout'] = DropoutLayer(net[prefix + 'fc6'],
p=dropout_ratio,
name=prefix + 'fc6_dropout')
net[prefix + 'fc7'] = DenseLayer(net[prefix + 'fc6_dropout'],
num_units=4096,
name=prefix + 'fc7')
net[prefix + 'fc7_dropout'] = DropoutLayer(net[prefix + 'fc7'],
p=dropout_ratio,
name=prefix + 'fc7_dropout')
if classificationFlag == True:
net[prefix + 'fc8'] = DenseLayer(net[prefix + 'fc7_dropout'],
num_units=67,
nonlinearity=None,
name=prefix + 'fc8')
net[prefix + 'prob'] = NonlinearityLayer(net[prefix + 'fc8'],
softmax,
name=prefix + 'prob')
return net
def nonlinearity(incoming):
"""Apply the standard nonlinearity."""
return NonlinearityLayer(incoming, nonlinearity=rectify)
def build_baseline8_fan_bilinear(input_var, nb_filter=96):
net = OrderedDict()
# Input, standardization
last = net['input'] = InputLayer(
(None, 3, tools.INP_PSIZE, tools.INP_PSIZE), input_var=input_var)
last = net['norm'] = ExpressionLayer(last, lambda x: normalize(x))
# load feature encoder
net['features_s8'] = get_features(last)["conv4_1"]
net['features_s4'] = get_features(last)["conv3_3"]
# Pretrained Encoder as before
last = net["conv1_1"] = ConvLayer(last,
nb_filter,
1,
pad=0,
flip_filters=False,
nonlinearity=linear)
last = net["bn1_1"] = BatchNormLayer(last)
last = net["relu1_1"] = NonlinearityLayer(last, nonlinearity=rectify)
last = net["conv1_2"] = ConvLayer(last,
nb_filter,
1,
pad=0,
flip_filters=False,
nonlinearity=linear)
last = net["bn1_2"] = BatchNormLayer(last)
last = net["relu1_2"] = NonlinearityLayer(last, nonlinearity=rectify)
# Modified Middle Part
last = net["middle"] = ConvLayer(last, nb_filter, 1, nonlinearity=linear)
# feature aggregation at multiple scales
last = net["bn1"] = BatchNormLayer(last)
last = fan_module_simple(last,
net,
"s8",
net['features_s8'],
nb_filter=nb_filter,
scale=8,
upsampling_strategy="bilinear")
last = net["bn2"] = BatchNormLayer(last)
last = fan_module_simple(last,
net,
"s4",
net['features_s4'],
nb_filter=nb_filter,
scale=4,
upsampling_strategy="bilinear")
# Decoder as before
last = net["deconv1_2"] = transpose(last,
net["conv1_2"],
nonlinearity=None)
last = net["deconv1_1"] = transpose(last,
net["conv1_1"],
nonlinearity=None)
last = net["bn"] = BatchNormLayer(last,
beta=nn.init.Constant(128.),
gamma=nn.init.Constant(25.))
return last, net
def build_model_vgg16(input_shape, verbose):
'''
See Lasagne Modelzoo:
https://github.com/Lasagne/Recipes/blob/master/modelzoo/vgg16.py
'''
if verbose: print('VGG16 (from lasagne model zoo)')
net = {}
net['input'] = InputLayer(input_shape)
net['conv1_1'] = ConvLayer(net['input'], 64, 3, pad=1, flip_filters=False)
net['conv1_2'] = ConvLayer(net['conv1_1'],
64,
3,
pad=1,
flip_filters=False)
net['pool1'] = PoolLayer(net['conv1_2'], 2)
net['conv2_1'] = ConvLayer(net['pool1'], 128, 3, pad=1, flip_filters=False)
net['conv2_2'] = ConvLayer(net['conv2_1'],
128,
3,
pad=1,
flip_filters=False)
net['pool2'] = PoolLayer(net['conv2_2'], 2)
net['conv3_1'] = ConvLayer(net['pool2'], 256, 3, pad=1, flip_filters=False)
net['conv3_2'] = ConvLayer(net['conv3_1'],
256,
3,
pad=1,
flip_filters=False)
net['conv3_3'] = ConvLayer(net['conv3_2'],
256,
3,
pad=1,
flip_filters=False)
net['pool3'] = PoolLayer(net['conv3_3'], 2)
net['conv4_1'] = ConvLayer(net['pool3'], 512, 3, pad=1, flip_filters=False)
net['conv4_2'] = ConvLayer(net['conv4_1'],
512,
3,
pad=1,
flip_filters=False)
net['conv4_3'] = ConvLayer(net['conv4_2'],
512,
3,
pad=1,
flip_filters=False)
net['pool4'] = PoolLayer(net['conv4_3'], 2)
net['conv5_1'] = ConvLayer(net['pool4'], 512, 3, pad=1, flip_filters=False)
net['conv5_2'] = ConvLayer(net['conv5_1'],
512,
3,
pad=1,
flip_filters=False)
net['conv5_3'] = ConvLayer(net['conv5_2'],
512,
3,
pad=1,
flip_filters=False)
net['pool5'] = PoolLayer(net['conv5_3'], 2)
net['fc6'] = DenseLayer(net['pool5'], num_units=4096)
net['fc6_dropout'] = DropoutLayer(net['fc6'], p=0.5)
net['fc7'] = DenseLayer(net['fc6_dropout'], num_units=4096)
net['fc7_dropout'] = DropoutLayer(net['fc7'], p=0.5)
net['fc8'] = DenseLayer(net['fc7_dropout'],
num_units=1000,
nonlinearity=None)
net['prob'] = NonlinearityLayer(net['fc8'], softmax)
# for layer in net.values():
# print str(lasagne.layers.get_output_shape(layer))
return net
def build_baseline9_fan_fan_bilinear(input_var, nb_filter=96):
net = OrderedDict()
import theano.tensor as T
import numpy as np
# Input, standardization
last = net['input'] = InputLayer(
(None, 3, tools.INP_PSIZE, tools.INP_PSIZE), input_var=input_var)
last = net['norm'] = ExpressionLayer(last, lambda x: normalize(x))
# load feature encoder
net['features_s8'] = get_features(last)["conv4_1"]
net['features_s4'] = get_features(last)["conv3_3"]
net['mask'] = ExpressionLayer(
layers.upsample(net["features_s8"], 8, mode="bilinear"),
lambda x: 1. * T.eq(x, x.max(axis=1, keepdims=True)))
# Pretrained Encoder as before
last = net["conv1_1"] = ConvLayer(last,
nb_filter,
1,
pad=0,
flip_filters=False,
nonlinearity=linear)
last = net["bn1_1"] = BatchNormLayer(last)
last = net["relu1_1"] = NonlinearityLayer(last, nonlinearity=rectify)
last = net["conv1_2"] = ConvLayer(last,
nb_filter,
1,
pad=0,
flip_filters=False,
nonlinearity=linear)
last = net["bn1_2"] = BatchNormLayer(last)
last = net["relu1_2"] = NonlinearityLayer(last, nonlinearity=rectify)
# Modified Middle Part
last = net["middle"] = ConvLayer(last, nb_filter, 1, nonlinearity=linear)
# feature aggregation at multiple scales
last = net["fan1"] = FeatureAwareNormLayer((last, net['mask']))
last = fan_module_simple(last,
net,
"s8",
net['features_s8'],
nb_filter=nb_filter,
scale=8,
upsampling_strategy="bilinear")
last = net["fan2"] = FeatureAwareNormLayer((last, net['mask']))
last = fan_module_simple(last,
net,
"s4",
net['features_s4'],
nb_filter=nb_filter,
scale=4,
upsampling_strategy="bilinear")
# Decoder as before
last = net["deconv1_2"] = transpose(last,
net["conv1_2"],
nonlinearity=None)
last = net["deconv1_1"] = transpose(last,
net["conv1_1"],
nonlinearity=None)
last = net["fan"] = FeatureAwareNormLayer(
(last, net['mask']),
beta=nn.init.Constant(np.float32(128.)),
gamma=nn.init.Constant(np.float32(25.)))
return last, net
def build_network_final_layer(cls, input_shape=None):
if input_shape is None:
# Default input shape: 3 channel images of size 224 x 224.
input_shape = (3, 224, 224)
# Input layer: shape is of the form (sample, channel, height, width).
# We leave the sample dimension with no size (`None`) so that the
# minibatch size is whatever we need it to be when we use it
net = InputLayer((None, ) + input_shape, name='input')
# First two convolutional layers: 64 filters, 3x3 convolution, 1 pixel padding
net = Conv2DLayer(net,
64,
3,
pad=1,
flip_filters=False,
name='conv1_1')
net = Conv2DLayer(net,
64,
3,
pad=1,
flip_filters=False,
name='conv1_2')
# 2x2 max-pooling; will reduce size from 224x224 to 112x112
net = Pool2DLayer(net, 2, name='pool1')
# Two convolutional layers, 128 filters
net = Conv2DLayer(net,
128,
3,
pad=1,
flip_filters=False,
name='conv2_1')
net = Conv2DLayer(net,
128,
3,
pad=1,
flip_filters=False,
name='conv2_2')
# 2x2 max-pooling; will reduce size from 112x112 to 56x56
net = Pool2DLayer(net, 2, name='pool2')
# Four convolutional layers, 256 filters
net = Conv2DLayer(net,
256,
3,
pad=1,
flip_filters=False,
name='conv3_1')
net = Conv2DLayer(net,
256,
3,
pad=1,
flip_filters=False,
name='conv3_2')
net = Conv2DLayer(net,
256,
3,
pad=1,
flip_filters=False,
name='conv3_3')
net = Conv2DLayer(net,
256,
3,
pad=1,
flip_filters=False,
name='conv3_4')
# 2x2 max-pooling; will reduce size from 56x56 to 28x28
net = Pool2DLayer(net, 2, name='pool3')
# Four convolutional layers, 512 filters
net = Conv2DLayer(net,
512,
3,
pad=1,
flip_filters=False,
name='conv4_1')
net = Conv2DLayer(net,
512,
3,
pad=1,
flip_filters=False,
name='conv4_2')
net = Conv2DLayer(net,
512,
3,
pad=1,
flip_filters=False,
name='conv4_3')
net = Conv2DLayer(net,
512,
3,
pad=1,
flip_filters=False,
name='conv4_4')
# 2x2 max-pooling; will reduce size from 28x28 to 14x14
net = Pool2DLayer(net, 2, name='pool4')
# Four convolutional layers, 512 filters
net = Conv2DLayer(net,
512,
3,
pad=1,
flip_filters=False,
name='conv5_1')
net = Conv2DLayer(net,
512,
3,
pad=1,
flip_filters=False,
name='conv5_2')
net = Conv2DLayer(net,
512,
3,
pad=1,
flip_filters=False,
name='conv5_3')
net = Conv2DLayer(net,
512,
3,
pad=1,
flip_filters=False,
name='conv5_4')
# 2x2 max-pooling; will reduce size from 14x14 to 7x7
net = Pool2DLayer(net, 2, name='pool5')
# Dense layer, 4096 units
net = DenseLayer(net, num_units=4096, name='fc6')
# 50% dropout (only applied during training, turned off during prediction)
net = DropoutLayer(net, p=0.5, name='fc6_dropout')
# Dense layer, 4096 units
net = DenseLayer(net, num_units=4096, name='fc7')
# 50% dropout (only applied during training, turned off during prediction)
net = DropoutLayer(net, p=0.5, name='fc7_dropout')
# Final dense layer, 1000 units: 1 for each class
net = DenseLayer(net, num_units=1000, nonlinearity=None, name='fc8')
# Softmax non-linearity that will generate probabilities
net = NonlinearityLayer(net, softmax, name='prob')
return net
def build_finetuned2_fan(input_var,
nb_filter=96,
input_size=(None, 3, tools.INP_PSIZE,
tools.INP_PSIZE)):
net = OrderedDict()
# Input, standardization
last = net['input'] = InputLayer(input_size, input_var=input_var)
last = net['norm'] = ExpressionLayer(last, lambda x: normalize(x))
# load feature encoder
# TODO this is clearly a bug. only for compatibility reasons. remove once all weights are converted
net['features_s8'] = get_features(last)["conv4_1"]
net['features_s4'] = get_features(last)["conv3_3"]
# Pretrained Encoder as before
last = net["conv1_1"] = ConvLayer(last,
nb_filter,
1,
pad=0,
flip_filters=False,
nonlinearity=linear)
last = net["bn1_1"] = layers.NonUpdateBatchNormLayer(last)
last = net["relu1_1"] = NonlinearityLayer(last, nonlinearity=rectify)
last = net["conv1_2"] = ConvLayer(last,
nb_filter,
1,
pad=0,
flip_filters=False,
nonlinearity=linear)
last = net["bn1_2"] = layers.NonUpdateBatchNormLayer(last)
last = net["relu1_2"] = NonlinearityLayer(last, nonlinearity=rectify)
# Modified Middle Part
last = net["middle"] = ConvLayer(last, nb_filter, 1, nonlinearity=linear)
# feature aggregation at multiple scales
last = net["bn1"] = layers.NonUpdateBatchNormLayer(last)
last = fan_module_simple(last,
net,
"s8",
net['features_s8'],
nb_filter=nb_filter,
scale=8)
last = net["bn2"] = layers.NonUpdateBatchNormLayer(last)
last = fan_module_simple(last,
net,
"s4",
net['features_s4'],
nb_filter=nb_filter,
scale=4)
# Decoder as before
last = net["deconv1_2"] = transpose(last,
net["conv1_2"],
nonlinearity=None)
last = net["deconv1_1"] = transpose(last,
net["conv1_1"],
nonlinearity=None)
last = net["bn"] = layers.FixedBatchNormLayer(last)
weights = "170123_runs/run_H.E.T._1485012575.4045253/3.npz"
data = tools.load_weights(last, weights)
return last, net
def build_model():
net = {}
net['input'] = InputLayer((None, 3, None, None))
net['conv1/7x7_s2'] = ConvLayer(net['input'],
64,
7,
stride=2,
pad=3,
flip_filters=False)
net['pool1/3x3_s2'] = PoolLayer(net['conv1/7x7_s2'],
pool_size=3,
stride=2,
ignore_border=False)
net['pool1/norm1'] = LRNLayer(net['pool1/3x3_s2'], alpha=0.00002, k=1)
net['conv2/3x3_reduce'] = ConvLayer(net['pool1/norm1'],
64,
1,
flip_filters=False)
net['conv2/3x3'] = ConvLayer(net['conv2/3x3_reduce'],
192,
3,
pad=1,
flip_filters=False)
net['conv2/norm2'] = LRNLayer(net['conv2/3x3'], alpha=0.00002, k=1)
net['pool2/3x3_s2'] = PoolLayer(net['conv2/norm2'],
pool_size=3,
stride=2,
ignore_border=False)
net.update(
build_inception_module('inception_3a', net['pool2/3x3_s2'],
[32, 64, 96, 128, 16, 32]))
net.update(
build_inception_module('inception_3b', net['inception_3a/output'],
[64, 128, 128, 192, 32, 96]))
net['pool3/3x3_s2'] = PoolLayer(net['inception_3b/output'],
pool_size=3,
stride=2,
ignore_border=False)
net.update(
build_inception_module('inception_4a', net['pool3/3x3_s2'],
[64, 192, 96, 208, 16, 48]))
net.update(
build_inception_module('inception_4b', net['inception_4a/output'],
[64, 160, 112, 224, 24, 64]))
net.update(
build_inception_module('inception_4c', net['inception_4b/output'],
[64, 128, 128, 256, 24, 64]))
net.update(
build_inception_module('inception_4d', net['inception_4c/output'],
[64, 112, 144, 288, 32, 64]))
net.update(
build_inception_module('inception_4e', net['inception_4d/output'],
[128, 256, 160, 320, 32, 128]))
net['pool4/3x3_s2'] = PoolLayer(net['inception_4e/output'],
pool_size=3,
stride=2,
ignore_border=False)
net.update(
build_inception_module('inception_5a', net['pool4/3x3_s2'],
[128, 256, 160, 320, 32, 128]))
net.update(
build_inception_module('inception_5b', net['inception_5a/output'],
[128, 384, 192, 384, 48, 128]))
net['pool5/7x7_s1'] = GlobalPoolLayer(net['inception_5b/output'])
net['loss3/classifier'] = DenseLayer(net['pool5/7x7_s1'],
num_units=1000,
nonlinearity=linear)
net['prob'] = NonlinearityLayer(net['loss3/classifier'],
nonlinearity=softmax)
return net
def build_big_fan(input_var,
nb_filter=96,
input_size=(None, 3, tools.INP_PSIZE, tools.INP_PSIZE)):
net = OrderedDict()
# Input, standardization
last = net['input'] = InputLayer(input_size, input_var=input_var)
last = net['norm'] = ExpressionLayer(last, lambda x: normalize(x))
# load feature encoder
f = get_features(last)
net['features_s8'] = f["conv4_1"]
net['features_s4'] = f["conv3_3"]
# Pretrained Encoder as before
last = net["conv1_1"] = ConvLayer(last,
nb_filter,
1,
pad=0,
flip_filters=False,
nonlinearity=linear)
last = net["bn1_1"] = layers.NonUpdateBatchNormLayer(last)
last = net["relu1_1"] = NonlinearityLayer(last, nonlinearity=rectify)
last = net["conv1_2"] = ConvLayer(last,
nb_filter,
1,
pad=0,
flip_filters=False,
nonlinearity=linear)
last = net["bn1_2"] = layers.NonUpdateBatchNormLayer(last)
last = net["relu1_2"] = NonlinearityLayer(last, nonlinearity=rectify)
# Modified Middle Part
last = net["middle"] = ConvLayer(last, nb_filter, 1, nonlinearity=linear)
# feature aggregation at multiple scales
last = net["bn1"] = layers.NonUpdateBatchNormLayer(last)
last = fan_module_simple(last,
net,
"s8",
net['features_s8'],
nb_filter=nb_filter,
scale=8)
last = net["bn1"] = layers.NonUpdateBatchNormLayer(last)
last = fan_module_simple(last,
net,
"s8",
net['features_s8'],
nb_filter=nb_filter,
scale=8)
last = net["bn3"] = layers.NonUpdateBatchNormLayer(last)
last = fan_module_simple(last,
net,
"s4",
net['features_s4'],
nb_filter=nb_filter,
scale=4)
last = net["bn4"] = layers.NonUpdateBatchNormLayer(last)
last = fan_module_simple(last,
net,
"s4",
net['features_s4'],
nb_filter=nb_filter,
scale=4)
last = net["bn5"] = layers.NonUpdateBatchNormLayer(last)
# Decoder as before
last = net["deconv1_2"] = transpose(last,
net["conv1_2"],
nonlinearity=None)
last = net["deconv1_1"] = transpose(last,
net["conv1_1"],
nonlinearity=None)
return last, net
