def build_st_spline_network(input_shape):
W = b = lasagne.init.Constant(0.0)
num_points = 4
num_filters = 64
filter_size = (3, 3)
pool_size = (2, 2)
l_in = InputLayer(shape=(None, input_shape[1], input_shape[2],
input_shape[3]))
l_conv1 = Conv2DLayer(l_in,
num_filters=num_filters,
filter_size=filter_size)
l_pool1 = MaxPool2DLayer(l_conv1, pool_size=pool_size)
l_conv2 = Conv2DLayer(l_pool1,
num_filters=num_filters,
filter_size=filter_size)
l_pool2 = MaxPool2DLayer(l_conv2, pool_size=pool_size)
l_dense1 = DenseLayer(l_pool2, num_units=128)
l_dense2 = DenseLayer(l_dense1,
num_units=num_points * 2,
W=W,
b=b,
nonlinearity=None)
l_st = TPSTransformerLayer(l_in, l_dense2, control_points=num_points)
l_output = ReshapeLayer(l_st, shape=([0], -1))
return l_output
def create_network():
l = 1000
pool_size = 5
test_size1 = 13
test_size2 = 7
test_size3 = 5
kernel1 = 128
kernel2 = 128
kernel3 = 128
layer1 = InputLayer(shape=(None, 1, 4, l + 1024))
layer2_1 = SliceLayer(layer1, indices=slice(0, l), axis=-1)
layer2_2 = SliceLayer(layer1, indices=slice(l, None), axis=-1)
layer2_3 = SliceLayer(layer2_2, indices=slice(0, 4), axis=-2)
layer2_f = FlattenLayer(layer2_3)
layer3 = Conv2DLayer(layer2_1,
num_filters=kernel1,
filter_size=(4, test_size1))
layer4 = Conv2DLayer(layer3,
num_filters=kernel1,
filter_size=(1, test_size1))
layer5 = Conv2DLayer(layer4,
num_filters=kernel1,
filter_size=(1, test_size1))
layer6 = MaxPool2DLayer(layer5, pool_size=(1, pool_size))
layer7 = Conv2DLayer(layer6,
num_filters=kernel2,
filter_size=(1, test_size2))
layer8 = Conv2DLayer(layer7,
num_filters=kernel2,
filter_size=(1, test_size2))
layer9 = Conv2DLayer(layer8,
num_filters=kernel2,
filter_size=(1, test_size2))
layer10 = MaxPool2DLayer(layer9, pool_size=(1, pool_size))
layer11 = Conv2DLayer(layer10,
num_filters=kernel3,
filter_size=(1, test_size3))
layer12 = Conv2DLayer(layer11,
num_filters=kernel3,
filter_size=(1, test_size3))
layer13 = Conv2DLayer(layer12,
num_filters=kernel3,
filter_size=(1, test_size3))
layer14 = MaxPool2DLayer(layer13, pool_size=(1, pool_size))
layer14_d = DenseLayer(layer14, num_units=256)
layer3_2 = DenseLayer(layer2_f, num_units=128)
layer15 = ConcatLayer([layer14_d, layer3_2])
layer16 = DropoutLayer(layer15, p=0.5)
layer17 = DenseLayer(layer16, num_units=256)
network = DenseLayer(layer17, num_units=2, nonlinearity=softmax)
return network
def build_st_network(b_size, input_shape, withdisc=True):
# General Params
num_filters = 64
filter_size = (3, 3)
pool_size = (2, 2)
# SP Param
b = np.zeros((2, 3), dtype=theano.config.floatX)
b[0, 0] = 1
b[1, 1] = 1
b = b.flatten() # identity transform
# Localization Network
l_in = InputLayer(shape=(None, input_shape[1], input_shape[2],
input_shape[3]))
l_conv1 = Conv2DLayer(l_in,
num_filters=num_filters,
filter_size=filter_size)
l_pool1 = MaxPool2DLayer(l_conv1, pool_size=pool_size)
l_conv2 = Conv2DLayer(l_pool1,
num_filters=num_filters,
filter_size=filter_size)
l_pool2 = MaxPool2DLayer(l_conv2, pool_size=pool_size)
l_loc = DenseLayer(l_pool2, num_units=64, W=lasagne.init.HeUniform('relu'))
l_param_reg = DenseLayer(l_loc,
num_units=6,
b=b,
nonlinearity=lasagne.nonlinearities.linear,
W=lasagne.init.Constant(0.0),
name='param_regressor')
if withdisc:
l_dis = DiscreteLayer(l_param_reg,
start=Constant(-3.),
stop=Constant(3.),
linrange=Constant(50.))
else:
l_dis = l_param_reg
# Transformer Network
l_trans = TransformerLayer(l_in, l_dis, downsample_factor=1.0)
final = ReshapeLayer(l_trans, shape=([0], -1))
return final
def net_lenet5(input_shape, nclass):
input_x, target_y, Winit = T.tensor4("input"), T.vector(
"target", dtype='int32'), init.Normal()
net = ll.InputLayer(input_shape, input_x)
net = ConvLayer(net, 20, 5, W=init.Normal())
net = MaxPool2DLayer(net, 2)
net = ConvLayer(net, 50, 5, W=init.Normal())
net = MaxPool2DLayer(net, 2)
net = ll.DenseLayer(net, 500, W=init.Normal())
net = ll.DenseLayer(net, nclass, W=init.Normal(), nonlinearity=nl.softmax)
return net, input_x, target_y, 1
def _build_middle(self,
l_in,
num_conv_layers=1,
num_dense_layers=1,
**kwargs):
assert len(l_in.shape) == 4, 'InputLayer shape must be (batch_size, channels, width, height) -- ' \
'reshape data or use RGB format?'
l_bottom = l_in
for i in xrange(num_conv_layers):
conv_kwargs = self._extract_layer_kwargs('c', i, kwargs)
if 'border_mode' not in conv_kwargs:
conv_kwargs['border_mode'] = 'same'
has_max_pool = conv_kwargs.pop('mp', False)
l_bottom = Conv2DLayer(l_bottom,
W=HeUniform(gain='relu'),
**conv_kwargs)
if has_max_pool:
max_pool_kwargs = self._extract_layer_kwargs('m', i, kwargs)
if 'pool_size' not in max_pool_kwargs:
max_pool_kwargs['pool_size'] = (2, 2)
l_bottom = MaxPool2DLayer(l_bottom, **max_pool_kwargs)
for i in xrange(num_dense_layers):
dense_kwargs = self._extract_layer_kwargs('d', i, kwargs)
dropout = dense_kwargs.pop('dropout', 0.5)
l_bottom = DenseLayer(l_bottom,
W=HeUniform(gain='relu'),
**dense_kwargs)
if dropout:
l_bottom = DropoutLayer(l_bottom, p=dropout)
return l_bottom
def net_vgglike(k, input_shape, nclass):
input_x, target_y, Winit = T.tensor4("input"), T.vector(
"target", dtype='int32'), init.Normal()
net = ll.InputLayer(input_shape, input_x)
net = conv_bn_rectify(net, 64 * k)
net = ll.DropoutLayer(net, 0.3)
net = conv_bn_rectify(net, 64 * k)
net = MaxPool2DLayer(net, 2, 2)
net = conv_bn_rectify(net, 128 * k)
net = ll.DropoutLayer(net, 0.4)
net = conv_bn_rectify(net, 128 * k)
net = MaxPool2DLayer(net, 2, 2)
net = conv_bn_rectify(net, 256 * k)
net = ll.DropoutLayer(net, 0.4)
net = conv_bn_rectify(net, 256 * k)
net = ll.DropoutLayer(net, 0.4)
net = conv_bn_rectify(net, 256 * k)
net = MaxPool2DLayer(net, 2, 2)
net = conv_bn_rectify(net, 512 * k)
net = ll.DropoutLayer(net, 0.4)
net = conv_bn_rectify(net, 512 * k)
net = ll.DropoutLayer(net, 0.4)
net = conv_bn_rectify(net, 512 * k)
net = MaxPool2DLayer(net, 2, 2)
net = conv_bn_rectify(net, 512 * k)
net = ll.DropoutLayer(net, 0.4)
net = conv_bn_rectify(net, 512 * k)
net = ll.DropoutLayer(net, 0.4)
net = conv_bn_rectify(net, 512 * k)
net = MaxPool2DLayer(net, 2, 2)
net = ll.DenseLayer(net,
int(512 * k),
W=init.Normal(),
nonlinearity=nl.rectify)
net = BatchNormLayer(net, epsilon=1e-3)
net = ll.NonlinearityLayer(net)
net = ll.DropoutLayer(net, 0.5)
net = ll.DenseLayer(net, nclass, W=init.Normal(), nonlinearity=nl.softmax)
return net, input_x, target_y, k
def model_train(X_train, y_train, learning_rate=1e-4, epochs=10):
l = 1000
layer1 = InputLayer(shape=(None, 1, 4, l + 1024))
layer2_1 = SliceLayer(layer1, indices=slice(0, l), axis=-1)
layer2_2 = SliceLayer(layer1, indices=slice(l, None), axis=-1)
layer2_3 = SliceLayer(layer2_2, indices=slice(0, 4), axis=-2)
layer2_f = FlattenLayer(layer2_3)
layer3 = Conv2DLayer(layer2_1, num_filters=64, filter_size=(4, 7))
layer4 = Conv2DLayer(layer3, num_filters=64, filter_size=(1, 7))
layer5 = Conv2DLayer(layer4, num_filters=64, filter_size=(1, 7))
layer6 = MaxPool2DLayer(layer5, pool_size=(1, 6))
layer7 = Conv2DLayer(layer6, num_filters=64, filter_size=(1, 7))
layer8 = Conv2DLayer(layer7, num_filters=64, filter_size=(1, 7))
layer9 = Conv2DLayer(layer8, num_filters=64, filter_size=(1, 7))
layer10 = MaxPool2DLayer(layer9, pool_size=(1, 6))
layer11 = Conv2DLayer(layer10, num_filters=64, filter_size=(1, 7))
layer12 = Conv2DLayer(layer11, num_filters=64, filter_size=(1, 7))
layer13 = Conv2DLayer(layer12, num_filters=64, filter_size=(1, 7))
layer14 = MaxPool2DLayer(layer13, pool_size=(1, 6))
layer14_d = DenseLayer(layer14, num_units=64)
layer3_2 = DenseLayer(layer2_f, num_units=64)
layer15 = ConcatLayer([layer14_d, layer3_2])
#layer15 = ConcatLayer([layer10_d,])
layer16 = DropoutLayer(layer15)
layer17 = DenseLayer(layer16, num_units=32)
network = DenseLayer(layer17, num_units=2, nonlinearity=None)
lr = theano.shared(np.float32(learning_rate))
net = NeuralNet(
network,
max_epochs=epochs,
update=adam,
update_learning_rate=lr,
regression=True,
train_split=TrainSplit(eval_size=0.1),
objective_loss_function=squared_error,
#on_epoch_finished=[AdjustVariable(lr, target=1e-8, half_life=20)],
verbose=4)
net.fit(X_train, y_train)
return net
def build_cnnae_network(input_shape):
conv_filters = 16
filter_size = 3
pool_size = 2
encode_size = input_shape[2] * 2
l_in = InputLayer(shape=(None, input_shape[1], input_shape[2],
input_shape[3]))
l_conv1 = Conv2DLayer(l_in,
num_filters=conv_filters,
filter_size=(filter_size, filter_size),
nonlinearity=None)
l_pool1 = MaxPool2DLayer(l_conv1, pool_size=(pool_size, pool_size))
l_dropout1 = DropoutLayer(l_pool1, p=0.5)
l_reshape1 = ReshapeLayer(l_dropout1, shape=([0], -1))
l_encode = DenseLayer(l_reshape1, name='encode', num_units=encode_size)
l_decode = DenseLayer(l_encode,
W=l_encode.W.T,
num_units=l_reshape1.output_shape[1])
l_reshape2 = ReshapeLayer(
l_decode,
shape=([0], conv_filters,
int(np.sqrt(l_reshape1.output_shape[1] / conv_filters)),
int(np.sqrt(l_reshape1.output_shape[1] / conv_filters))))
l_unpool1 = Upscale2DLayer(l_reshape2, scale_factor=pool_size)
l_de = TransposedConv2DLayer(l_unpool1,
num_filters=l_conv1.input_shape[1],
W=l_conv1.W,
filter_size=l_conv1.filter_size,
stride=l_conv1.stride,
crop=l_conv1.pad,
flip_filters=not l_conv1.flip_filters)
l_output = ReshapeLayer(l_de, shape=([0], -1))
return l_output
def build_mitosis_encoder(input_shape, encoding_size=32, withst=False):
# Parameters
filter_size = (3, 3)
num_filters = 32
pool_size = (2, 2)
# Localization Network
l_input = InputLayer(shape=(None, input_shape[1], input_shape[2],
input_shape[3]))
l_conv1 = Conv2DLayer(l_input,
num_filters=num_filters,
filter_size=filter_size)
l_conv2 = Conv2DLayer(l_conv1,
num_filters=num_filters,
filter_size=filter_size)
l_pool1 = MaxPool2DLayer(l_conv2, pool_size=pool_size)
l_pipe1_layer = l_pool1 # We need this
# ST Network
if withst:
# ST Params
b = np.zeros((2, 3), dtype=theano.config.floatX)
b[0, 0] = 1
b[1, 1] = 1
b = b.flatten()
# ST Layers
st_encode1 = DenseLayer(l_pool1,
num_units=50,
W=lasagne.init.HeUniform('relu'))
st_encode2 = DenseLayer(st_encode1,
num_units=6,
b=b,
W=lasagne.init.Constant(0.0))
l_trans1 = TransformerLayer(l_input, st_encode2, downsample_factor=1.0)
# Localization Network
st_conv1 = Conv2DLayer(l_trans1,
num_filters=num_filters,
filter_size=filter_size)
st_covn2 = Conv2DLayer(st_conv1,
num_filters=num_filters,
filter_size=filter_size)
st_pool1 = MaxPool2DLayer(st_covn2, pool_size=pool_size)
l_pipe1_layer = st_pool1
# Encoding Step
l_reshape1 = ReshapeLayer(l_pipe1_layer, shape=([0], -1))
l_encode = DenseLayer(l_reshape1,
num_units=encoding_size,
W=lasagne.init.HeUniform('relu'),
name='encoder')
# Decoding Step
l_decode = DenseLayer(l_encode,
W=l_encode.W.T,
num_units=l_reshape1.output_shape[1])
l_reshape2 = ReshapeLayer(
l_decode,
shape=([0], num_filters,
int(np.sqrt(l_reshape1.output_shape[1] / num_filters)),
int(np.sqrt(l_reshape1.output_shape[1] / num_filters))))
# Deconv Network
l_unpool1 = Upscale2DLayer(l_reshape2, scale_factor=pool_size)
l_deconv2 = TransposedConv2DLayer(l_unpool1,
num_filters=l_conv2.input_shape[1],
W=l_conv2.W,
filter_size=l_conv2.filter_size,
stride=l_conv2.stride,
crop=l_conv2.pad,
flip_filters=not l_conv2.flip_filters)
l_deconv1 = TransposedConv2DLayer(l_deconv2,
num_filters=l_conv1.input_shape[1],
W=l_conv1.W,
filter_size=l_conv1.filter_size,
stride=l_conv1.stride,
crop=l_conv1.pad,
flip_filters=not l_conv1.flip_filters)
return l_deconv1
def build_st_network_MNIST(input_shape, mins, maxs, ranges, withdisc=True):
# General Params
num_filters = 64
filter_size = (3, 3)
pool_size = (2, 2)
# SP Param
b = np.zeros((2, 3), dtype=theano.config.floatX)
b[0, 0] = 1
b[1, 1] = 1
b = b.flatten() # identity transform
# Localization Network
l_in = InputLayer(shape=(None, input_shape[1], input_shape[2],
input_shape[3]))
l_conv1 = Conv2DLayer(l_in,
num_filters=num_filters,
filter_size=filter_size)
l_pool1 = MaxPool2DLayer(l_conv1, pool_size=pool_size)
l_conv2 = Conv2DLayer(l_pool1,
num_filters=num_filters,
filter_size=filter_size)
l_pool2 = MaxPool2DLayer(l_conv2, pool_size=pool_size)
l_loc = DenseLayer(l_pool2, num_units=64, W=lasagne.init.HeUniform('relu'))
l_param_reg = DenseLayer(l_loc,
num_units=6,
b=b,
nonlinearity=lasagne.nonlinearities.linear,
W=lasagne.init.Constant(0.0),
name='param_regressor')
if withdisc:
l_dis = DiscreteLayer(l_param_reg, mins, maxs, ranges)
else:
l_dis = l_param_reg
# Transformer Network
l_trans = TransformerLayer(l_in, l_dis, downsample_factor=1.0)
# Classification Network
network = lasagne.layers.Conv2DLayer(
l_trans,
num_filters=32,
filter_size=(5, 5),
nonlinearity=lasagne.nonlinearities.rectify,
W=lasagne.init.GlorotUniform())
# Expert note: Lasagne provides alternative convolutional layers that
# override Theano's choice of which implementation to use; for details
# please see http://lasagne.readthedocs.org/en/latest/user/tutorial.html.
# Max-pooling layer of factor 2 in both dimensions:
network = lasagne.layers.MaxPool2DLayer(network, pool_size=(2, 2))
# Another convolution with 32 5x5 kernels, and another 2x2 pooling:
network = lasagne.layers.Conv2DLayer(
network,
num_filters=32,
filter_size=(5, 5),
nonlinearity=lasagne.nonlinearities.rectify)
network = lasagne.layers.MaxPool2DLayer(network, pool_size=(2, 2))
# A fully-connected layer of 256 units with 50% dropout on its inputs:
network = lasagne.layers.DenseLayer(
lasagne.layers.dropout(network, p=.5),
num_units=256,
nonlinearity=lasagne.nonlinearities.rectify)
# And, finally, the 10-unit output layer with 50% dropout on its inputs:
network = lasagne.layers.DenseLayer(
lasagne.layers.dropout(network, p=.5),
num_units=10,
nonlinearity=lasagne.nonlinearities.softmax)
return network
def build_model(batch_size=BATCH_SIZE):
""" Compile net architecture """
nonlin = lasagne.nonlinearities.rectify
# --- input layers ---
l_in = lasagne.layers.InputLayer(shape=(None, INPUT_SHAPE[0],
INPUT_SHAPE[1], INPUT_SHAPE[2]),
name='Input')
net = l_in
nf = 64
# --- conv layers ---
net = Conv2DLayer(net,
num_filters=nf,
filter_size=5,
stride=2,
pad=2,
W=init_conv(gain="relu"),
nonlinearity=nonlin)
net = batch_norm(net, alpha=0.1)
net = Conv2DLayer(net,
num_filters=nf,
filter_size=3,
stride=1,
pad=1,
W=init_conv(gain="relu"),
nonlinearity=nonlin)
net = batch_norm(net, alpha=0.1)
net = MaxPool2DLayer(net, pool_size=2)
net = DropoutLayer(net, p=0.3)
net = Conv2DLayer(net,
num_filters=2 * nf,
filter_size=3,
stride=1,
pad=1,
W=init_conv(gain="relu"),
nonlinearity=nonlin)
net = batch_norm(net, alpha=0.1)
net = Conv2DLayer(net,
num_filters=2 * nf,
filter_size=3,
stride=1,
pad=1,
W=init_conv(gain="relu"),
nonlinearity=nonlin)
net = batch_norm(net, alpha=0.1)
net = MaxPool2DLayer(net, pool_size=2)
net = DropoutLayer(net, p=0.3)
net = Conv2DLayer(net,
num_filters=4 * nf,
filter_size=3,
stride=1,
pad=1,
W=init_conv(gain="relu"),
nonlinearity=nonlin)
net = batch_norm(net, alpha=0.1)
net = DropoutLayer(net, p=0.3)
net = Conv2DLayer(net,
num_filters=4 * nf,
filter_size=3,
stride=1,
pad=1,
W=init_conv(gain="relu"),
nonlinearity=nonlin)
net = batch_norm(net, alpha=0.1)
net = DropoutLayer(net, p=0.3)
net = Conv2DLayer(net,
num_filters=6 * nf,
filter_size=3,
stride=1,
pad=1,
W=init_conv(gain="relu"),
nonlinearity=nonlin)
net = batch_norm(net, alpha=0.1)
net = DropoutLayer(net, p=0.3)
net = Conv2DLayer(net,
num_filters=6 * nf,
filter_size=3,
stride=1,
pad=1,
W=init_conv(gain="relu"),
nonlinearity=nonlin)
net = batch_norm(net, alpha=0.1)
net = MaxPool2DLayer(net, pool_size=2)
net = DropoutLayer(net, p=0.3)
net = Conv2DLayer(net,
num_filters=8 * nf,
filter_size=3,
stride=1,
pad=1,
W=init_conv(gain="relu"),
nonlinearity=nonlin)
net = batch_norm(net, alpha=0.1)
net = Conv2DLayer(net,
num_filters=8 * nf,
filter_size=3,
stride=1,
pad=1,
W=init_conv(gain="relu"),
nonlinearity=nonlin)
net = batch_norm(net, alpha=0.1)
net = MaxPool2DLayer(net, pool_size=(1, 2))
net = DropoutLayer(net, p=0.3)
net = Conv2DLayer(net,
num_filters=8 * nf,
filter_size=3,
stride=1,
pad=1,
W=init_conv(gain="relu"),
nonlinearity=nonlin)
net = batch_norm(net, alpha=0.1)
net = Conv2DLayer(net,
num_filters=8 * nf,
filter_size=3,
stride=1,
pad=1,
W=init_conv(gain="relu"),
nonlinearity=nonlin)
net = batch_norm(net, alpha=0.1)
net = MaxPool2DLayer(net, pool_size=(1, 2))
net = DropoutLayer(net, p=0.3)
net = Conv2DLayer(net,
num_filters=8 * nf,
filter_size=3,
pad=0,
W=init_conv(gain="relu"),
nonlinearity=nonlin)
net = batch_norm(net, alpha=0.1)
net = DropoutLayer(net, p=0.5)
net = Conv2DLayer(net,
num_filters=8 * nf,
filter_size=1,
pad=0,
W=init_conv(gain="relu"),
nonlinearity=nonlin)
net = batch_norm(net, alpha=0.1)
net = DropoutLayer(net, p=0.5)
# --- feed forward part ---
net = Conv2DLayer(net,
num_filters=41,
filter_size=1,
W=init_conv(gain="relu"),
nonlinearity=None)
net = batch_norm(net, alpha=0.1)
net = GlobalPoolLayer(net)
net = FlattenLayer(net)
net = NonlinearityLayer(net, nonlinearity=lasagne.nonlinearities.softmax)
return net
def build_model(num_classes, pretrained_w_path="", input_var=None, drop_p=0.5):
net = {}
net['data'] = InputLayer(shape=(None, 3, 227, 227), input_var=input_var)
# conv1
net['conv1'] = Conv2DLayer(net['data'],
num_filters=96,
filter_size=(11, 11),
stride=4,
nonlinearity=lasagne.nonlinearities.rectify)
# pool1
net['pool1'] = MaxPool2DLayer(net['conv1'], pool_size=(3, 3), stride=2)
# norm1
net['norm1'] = LocalResponseNormalization2DLayer(net['pool1'],
n=5,
alpha=0.0001 / 5.0,
beta=0.75,
k=1)
# conv2
# The caffe reference model uses a parameter called group.
# This parameter splits input to the convolutional layer.
# The first half of the filters operate on the first half
# of the input from the previous layer. Similarly, the
# second half operate on the second half of the input.
#
# Lasagne does not have this group parameter, but we can
# do it ourselves.
#
# see https://github.com/BVLC/caffe/issues/778
# also see https://code.google.com/p/cuda-convnet/wiki/LayerParams
# before conv2 split the data
# norm1 size: 23 x 23 x 96
net['conv2_data1'] = SliceLayer(net['norm1'], indices=slice(0, 48), axis=1)
net['conv2_data2'] = SliceLayer(net['norm1'],
indices=slice(48, 96),
axis=1)
# now do the convolutions
net['conv2_part1'] = Conv2DLayer(net['conv2_data1'],
num_filters=128,
filter_size=(5, 5),
pad=2)
net['conv2_part2'] = Conv2DLayer(net['conv2_data2'],
num_filters=128,
filter_size=(5, 5),
pad=2)
# now combine
net['conv2'] = concat((net['conv2_part1'], net['conv2_part2']), axis=1)
# pool2
net['pool2'] = MaxPool2DLayer(net['conv2'], pool_size=(3, 3), stride=2)
# norm2
net['norm2'] = LocalResponseNormalization2DLayer(net['pool2'],
n=5,
alpha=0.0001 / 5.0,
beta=0.75,
k=1)
# conv3
# no group
net['conv3'] = Conv2DLayer(net['norm2'],
num_filters=384,
filter_size=(3, 3),
pad=1)
# conv4
# group = 2
net['conv4_data1'] = SliceLayer(net['conv3'],
indices=slice(0, 192),
axis=1)
net['conv4_data2'] = SliceLayer(net['conv3'],
indices=slice(192, 384),
axis=1)
net['conv4_part1'] = Conv2DLayer(net['conv4_data1'],
num_filters=192,
filter_size=(3, 3),
pad=1)
net['conv4_part2'] = Conv2DLayer(net['conv4_data2'],
num_filters=192,
filter_size=(3, 3),
pad=1)
net['conv4'] = concat((net['conv4_part1'], net['conv4_part2']), axis=1)
# conv5
# group 2
net['conv5_data1'] = SliceLayer(net['conv4'],
indices=slice(0, 192),
axis=1)
net['conv5_data2'] = SliceLayer(net['conv4'],
indices=slice(192, 384),
axis=1)
net['conv5_part1'] = Conv2DLayer(net['conv5_data1'],
num_filters=128,
filter_size=(3, 3),
pad=1)
net['conv5_part2'] = Conv2DLayer(net['conv5_data2'],
num_filters=128,
filter_size=(3, 3),
pad=1)
net['conv5'] = concat((net['conv5_part1'], net['conv5_part2']), axis=1)
# pool 5
net['pool5'] = MaxPool2DLayer(net['conv5'], pool_size=(3, 3), stride=2)
# fc6
net['fc6'] = DenseLayer(net['pool5'],
num_units=4096,
nonlinearity=lasagne.nonlinearities.rectify)
# fc7
net['fc7'] = DenseLayer(DropoutLayer(net['fc6'], p=drop_p),
num_units=4096,
nonlinearity=lasagne.nonlinearities.rectify)
# fc8 - changes: (i) num_classes, (ii) sigmoid activation
net['fc8'] = DenseLayer(DropoutLayer(net['fc7'], p=drop_p),
num_units=num_classes,
nonlinearity=lasagne.nonlinearities.sigmoid)
return net['fc8']
def build_stereo_cnn(input_var=None, in_shape_1=100, in_shape_2=150):
conv_num_filters1 = 16
conv_num_filters2 = 32
conv_num_filters3 = 64
conv_num_filters4 = 128
filter_size1 = 7
filter_size2 = 5
filter_size3 = 3
filter_size4 = 3
pool_size = 2
scale_factor = 2
pad_in = 'valid'
pad_out = 'full'
# Input layer, as usual:
network = InputLayer(shape=(None, 2, in_shape_1, in_shape_2),
input_var=input_var,
name="input_layer")
network = batch_norm(
Conv2DLayer(network,
num_filters=conv_num_filters1,
filter_size=(filter_size1, filter_size1),
pad=pad_in,
nonlinearity=lasagne.nonlinearities.rectify,
W=lasagne.init.GlorotUniform(),
name="conv1"))
network = MaxPool2DLayer(network,
pool_size=(pool_size, pool_size),
name="pool1")
network = batch_norm(
Conv2DLayer(network,
num_filters=conv_num_filters2,
filter_size=(filter_size2, filter_size2),
pad=pad_in,
nonlinearity=lasagne.nonlinearities.rectify,
W=lasagne.init.GlorotUniform(),
name="conv2"))
network = MaxPool2DLayer(network,
pool_size=(pool_size, pool_size),
name="pool2")
network = batch_norm(
Conv2DLayer(network,
num_filters=conv_num_filters3,
filter_size=(filter_size3, filter_size3),
pad=pad_in,
nonlinearity=lasagne.nonlinearities.rectify,
W=lasagne.init.GlorotUniform(),
name="conv3"))
network = MaxPool2DLayer(network,
pool_size=(pool_size, pool_size),
name="pool3")
network = batch_norm(
Conv2DLayer(network,
num_filters=conv_num_filters4,
filter_size=(filter_size4, filter_size4),
pad=pad_in,
nonlinearity=lasagne.nonlinearities.rectify,
W=lasagne.init.GlorotUniform(),
name="conv4"))
network = batch_norm(
Conv2DLayer(network,
num_filters=32,
filter_size=(filter_size4, filter_size4),
pad=pad_out,
nonlinearity=lasagne.nonlinearities.rectify,
W=lasagne.init.GlorotUniform(),
name="deconv1"))
network = Upscale2DLayer(network,
scale_factor=(pool_size, pool_size),
name="upscale1")
network = batch_norm(
Conv2DLayer(network,
num_filters=16,
filter_size=(filter_size3, filter_size3),
pad=pad_out,
nonlinearity=lasagne.nonlinearities.rectify,
W=lasagne.init.GlorotUniform(),
name="deconv2"))
network = Upscale2DLayer(network,
scale_factor=(pool_size, pool_size),
name="upscale2")
network = batch_norm(
Conv2DLayer(network,
num_filters=8,
filter_size=(filter_size2, filter_size2),
pad=pad_out,
nonlinearity=lasagne.nonlinearities.rectify,
W=lasagne.init.GlorotUniform(),
name="deconv3"))
network = Upscale2DLayer(network,
scale_factor=(pool_size, pool_size),
name="upscale3")
network = batch_norm(
Conv2DLayer(network,
num_filters=1,
filter_size=(filter_size1, filter_size1),
pad=pad_out,
nonlinearity=lasagne.nonlinearities.sigmoid,
W=lasagne.init.GlorotUniform(),
name="deconv4"))
return network
def build_model(width=512, height=512, filename=None,
n_classes=5, batch_size=None, p_conv=0.0):
"""Setup network structure for the original formulation of JeffreyDF's
network and optionally load pretrained weights
Parameters
----------
width : Optional[int]
image width
height : Optional[int]
image height
filename : Optional[str]
if filename is not None, weights are loaded from filename
n_classes : Optional[int]
default 5 for transfer learning on Kaggle DR data
batch_size : should only be set if all batches have the same size!
p_conv: dropout applied to conv. layers, by default turned off (0.0)
Returns
-------
dict
one lasagne layer per key
Notes
-----
Reference: Jeffrey De Fauw, 2015:
http://jeffreydf.github.io/diabetic-retinopathy-detection/
Download pretrained weights from:
https://github.com/JeffreyDF/kaggle_diabetic_retinopathy/blob/
master/dumps/2015_07_17_123003_PARAMSDUMP.pkl
original net has leaky rectifier units
"""
net = OrderedDict()
net['0'] = InputLayer((batch_size, 3, width, height), name='images')
net['1'] = ConvLayer(net['0'], 32, 7, stride=(2, 2), pad='same',
untie_biases=True,
nonlinearity=LeakyRectify(leakiness=0.5),
W=lasagne.init.Orthogonal(1.0),
b=lasagne.init.Constant(0.1))
net['1d'] = DropoutLayer(net['1'], p=p_conv)
net['2'] = MaxPool2DLayer(net['1d'], 3, stride=(2, 2))
net['3'] = ConvLayer(net['2'], 32, 3, stride=(1, 1), pad='same',
untie_biases=True,
nonlinearity=LeakyRectify(leakiness=0.5),
W=lasagne.init.Orthogonal(1.0),
b=lasagne.init.Constant(0.1))
net['3d'] = DropoutLayer(net['3'], p=p_conv)
net['4'] = ConvLayer(net['3d'], 32, 3, stride=(1, 1), pad='same',
untie_biases=True,
nonlinearity=LeakyRectify(leakiness=0.5),
W=lasagne.init.Orthogonal(1.0),
b=lasagne.init.Constant(0.1))
net['4d'] = DropoutLayer(net['4'], p=p_conv)
net['5'] = MaxPool2DLayer(net['4d'], 3, stride=(2, 2))
net['6'] = ConvLayer(net['5'], 64, 3, stride=(1, 1), pad='same',
untie_biases=True,
nonlinearity=LeakyRectify(leakiness=0.5),
W=lasagne.init.Orthogonal(1.0),
b=lasagne.init.Constant(0.1))
net['6d'] = DropoutLayer(net['6'], p=p_conv)
net['7'] = ConvLayer(net['6d'], 64, 3, stride=(1, 1), pad='same',
untie_biases=True,
nonlinearity=LeakyRectify(leakiness=0.5),
W=lasagne.init.Orthogonal(1.0),
b=lasagne.init.Constant(0.1))
net['7d'] = DropoutLayer(net['7'], p=p_conv)
net['8'] = MaxPool2DLayer(net['7d'], 3, stride=(2, 2))
net['9'] = ConvLayer(net['8'], 128, 3, stride=(1, 1), pad='same',
untie_biases=True,
nonlinearity=LeakyRectify(leakiness=0.5),
W=lasagne.init.Orthogonal(1.0),
b=lasagne.init.Constant(0.1))
net['9d'] = DropoutLayer(net['9'], p=p_conv)
net['10'] = ConvLayer(net['9d'], 128, 3, stride=(1, 1), pad='same',
untie_biases=True,
nonlinearity=LeakyRectify(leakiness=0.5),
W=lasagne.init.Orthogonal(1.0),
b=lasagne.init.Constant(0.1))
net['10d'] = DropoutLayer(net['10'], p=p_conv)
net['11'] = ConvLayer(net['10d'], 128, 3, stride=(1, 1), pad='same',
untie_biases=True,
nonlinearity=LeakyRectify(leakiness=0.5),
W=lasagne.init.Orthogonal(1.0),
b=lasagne.init.Constant(0.1))
net['11d'] = DropoutLayer(net['11'], p=p_conv)
net['12'] = ConvLayer(net['11d'], 128, 3, stride=(1, 1), pad='same',
untie_biases=True,
nonlinearity=LeakyRectify(leakiness=0.5),
W=lasagne.init.Orthogonal(1.0),
b=lasagne.init.Constant(0.1))
net['12d'] = DropoutLayer(net['12'], p=p_conv)
net['13'] = MaxPool2DLayer(net['12d'], 3, stride=(2, 2))
net['14'] = ConvLayer(net['13'], 256, 3, stride=(1, 1), pad='same',
untie_biases=True,
nonlinearity=LeakyRectify(leakiness=0.5),
W=lasagne.init.Orthogonal(1.0),
b=lasagne.init.Constant(0.1))
net['14d'] = DropoutLayer(net['14'], p=p_conv)
net['15'] = ConvLayer(net['14d'], 256, 3, stride=(1, 1), pad='same',
untie_biases=True,
nonlinearity=LeakyRectify(leakiness=0.5),
W=lasagne.init.Orthogonal(1.0),
b=lasagne.init.Constant(0.1))
net['15d'] = DropoutLayer(net['15'], p=p_conv)
net['16'] = ConvLayer(net['15'], 256, 3, stride=(1, 1), pad='same',
untie_biases=True,
nonlinearity=LeakyRectify(leakiness=0.5),
W=lasagne.init.Orthogonal(1.0),
b=lasagne.init.Constant(0.1))
net['16d'] = DropoutLayer(net['16'], p=p_conv)
net['17'] = ConvLayer(net['16d'], 256, 3, stride=(1, 1), pad='same',
untie_biases=True,
nonlinearity=LeakyRectify(leakiness=0.5),
W=lasagne.init.Orthogonal(1.0),
b=lasagne.init.Constant(0.1))
net['17d'] = DropoutLayer(net['17'], p=p_conv)
net['18'] = MaxPool2DLayer(net['17d'], 3, stride=(2, 2),
name='coarse_last_pool')
net['19'] = DropoutLayer(net['18'], p=0.5)
net['20'] = DenseLayer(net['19'], num_units=1024, nonlinearity=None,
W=lasagne.init.Orthogonal(1.0),
b=lasagne.init.Constant(0.1),
name='first_fc_0')
net['21'] = FeaturePoolLayer(net['20'], 2)
net['22'] = InputLayer((batch_size, 2), name='imgdim')
net['23'] = ConcatLayer([net['21'], net['22']])
# Combine representations of both eyes
net['24'] = ReshapeLayer(net['23'],
(-1, net['23'].output_shape[1] * 2))
net['25'] = DropoutLayer(net['24'], p=0.5)
net['26'] = DenseLayer(net['25'], num_units=1024, nonlinearity=None,
W=lasagne.init.Orthogonal(1.0),
b=lasagne.init.Constant(0.1),
name='combine_repr_fc')
net['27'] = FeaturePoolLayer(net['26'], 2)
net['28'] = DropoutLayer(net['27'], p=0.5)
net['29'] = DenseLayer(net['28'],
num_units=n_classes * 2,
nonlinearity=None,
W=lasagne.init.Orthogonal(1.0),
b=lasagne.init.Constant(0.1))
# Reshape back to the number of desired classes
net['30'] = ReshapeLayer(net['29'], (-1, n_classes))
net['31'] = NonlinearityLayer(net['30'], nonlinearity=softmax)
if filename is not None:
with open(filename, 'r') as f:
weights = pickle.load(f)
set_all_param_values(net['31'], weights)
return net
