def define_net():
net = {}
# net['input_img'] = ll.InputLayer(shape=(None, 1, 28, 28), input_var=input_img)
# net['input_noise'] = ll.InputLayer(shape=(None, 1, 28, 28), input_var=noise)
# ll.ConcatLayer([net['input_img'], net['input_noise']], axis=1)
net['input'] = ll.InputLayer(shape=(None, 2, 28, 28))
net['conv_1'] = ll.batch_norm(
ll.Conv2DLayer(net['input'],
num_filters=32,
stride=(2, 2),
filter_size=(5, 5),
pad='same'))
net['conv_2'] = ll.batch_norm(
ll.Conv2DLayer(net['conv_1'],
num_filters=64,
stride=(2, 2),
filter_size=(5, 5),
pad='same'))
net['unconv_3'] = ll.batch_norm(
ll.TransposedConv2DLayer(net['conv_2'],
filter_size=(5, 5),
num_filters=32,
stride=(2, 2),
crop=(2, 2)))
net['out'] = ll.batch_norm(
ll.TransposedConv2DLayer(net['unconv_3'],
filter_size=(4, 4),
num_filters=1,
stride=(2, 2),
crop=(0, 0),
nonlinearity=lasagne.nonlinearities.sigmoid))
return net
def build_generator(input_var=None):
#D_inp = T.tensor4('ds')
G = l.InputLayer(shape=(None, 1, noise_H, noise_W), input_var=input_var)
G = batch_norm(
l.DenseLayer(G, num_units=(noise_H * noise_W * 256),
nonlinearity=reLU))
G = l.ReshapeLayer(G, shape=([0], 256, noise_H, noise_W)) #4
G = l.TransposedConv2DLayer(G,
1,
filter_size=(2, 2),
stride=(2, 2),
output_size=8) #8
G = batch_norm(l.Conv2DLayer(G, 40, (3, 3), nonlinearity=reLU,
pad='full')) #10
G = l.TransposedConv2DLayer(G,
1,
filter_size=(2, 2),
stride=(2, 2),
output_size=20) #20
G = batch_norm(l.Conv2DLayer(G, 20, (3, 3), nonlinearity=reLU,
pad='full')) #22
G = batch_norm(l.Conv2DLayer(G, 20, (5, 5), nonlinearity=reLU,
pad='full')) #26
G = batch_norm(l.Conv2DLayer(G, 1, (3, 3), nonlinearity=reLU,
pad='full')) #28
return G
def build_auto_encoder_mnist_cnn(input_var=None):
"""
Generate an auto-encoder cnn using the Lasagne library
"""
# Build encoder part
network = lyr.InputLayer(shape=(None, 1, 28, 28), input_var=input_var)
network = lyr.Conv2DLayer(network, 64, (5, 5), W=lasagne.init.Normal())
network = lyr.MaxPool2DLayer(network, (2, 2))
network = lyr.Conv2DLayer(network, 128, (5, 5), W=lasagne.init.Normal())
network = lyr.MaxPool2DLayer(network, (2, 2))
network = lyr.FlattenLayer(network)
network = lyr.DenseLayer(network, 2048, W=lasagne.init.Normal())
network = lyr.ReshapeLayer(network, (input_var.shape[0], 2048, 1, 1))
# Build decoder part
network = lyr.TransposedConv2DLayer(network,
128, (5, 5),
W=lasagne.init.Normal())
network = lyr.Upscale2DLayer(network, (2, 2))
network = lyr.TransposedConv2DLayer(network,
64, (4, 4),
W=lasagne.init.Normal())
network = lyr.Upscale2DLayer(network, (2, 2))
network = lyr.TransposedConv2DLayer(network,
1, (3, 3),
W=lasagne.init.Normal(),
nonlinearity=None)
return network
def build_generator(input_var=None,
noise_size=100,
nfilters=[512, 256, 128, 64, 3]):
###############################
# Build Network Configuration #
###############################
print('... Building the generator')
# Input of the network : shape = (batch_size, 100)
network = layers.InputLayer(shape=(None, noise_size), input_var=input_var)
# Reshape layer : shape = (batch_size, 100, 1, 1)
network = layers.ReshapeLayer(network, (-1, noise_size, 1, 1))
# Tranposed conv layer : shape = (batch_size, 512, 4, 4)
network = layers.batch_norm(
layers.TransposedConv2DLayer(network,
num_filters=nfilters[0],
filter_size=(4, 4),
stride=(1, 1)))
# Tranposed conv layer : shape = (batch_size, 256, 8, 8)
network = layers.batch_norm(
layers.TransposedConv2DLayer(network,
num_filters=nfilters[1],
filter_size=(5, 5),
stride=(2, 2),
crop=2,
output_size=8))
# Tranposed conv layer : shape = (batch_size, 128, 16, 16)
network = layers.batch_norm(
layers.TransposedConv2DLayer(network,
num_filters=nfilters[2],
filter_size=(5, 5),
stride=(2, 2),
crop=2,
output_size=16))
# Tranposed conv layer : shape = (batch_size, 64, 32, 32)
network = layers.batch_norm(
layers.TransposedConv2DLayer(network,
num_filters=nfilters[3],
filter_size=(5, 5),
stride=(2, 2),
crop=2,
output_size=32))
# Tranposed conv layer : shape = (batch_size, 3, 64, 64)
network = layers.TransposedConv2DLayer(network,
num_filters=nfilters[4],
filter_size=5,
stride=2,
crop=2,
output_size=64,
nonlinearity=nonlinearities.sigmoid)
return network
def generator(z_dim=100, num_units=64, input_var=None, batch_size=64):
generator = []
theano_rng = RandomStreams(rng.randint(2**15))
noise = theano_rng.normal(size=(batch_size, z_dim))
input_var = noise if input_var is None else input_var
relu = lasagne.nonlinearities.rectify
generator.append(
ll.InputLayer(shape=(batch_size, z_dim), input_var=input_var))
# no bn
generator.append((ll.DenseLayer(generator[-1],
num_units * 8 * 4 * 4,
nonlinearity=None)))
generator.append(
ll.ReshapeLayer(generator[-1], shape=(-1, num_units * 8, 4, 4)))
# no bn
generator.append((ll.TransposedConv2DLayer(generator[-1],
num_filters=num_units * 4,
filter_size=(4, 4),
stride=(2, 2),
crop=1,
nonlinearity=relu)))
# no bn
generator.append((ll.TransposedConv2DLayer(generator[-1],
num_filters=num_units * 2,
filter_size=(4, 4),
stride=(2, 2),
crop=1,
nonlinearity=relu)))
# no bn
generator.append((ll.TransposedConv2DLayer(generator[-1],
num_filters=num_units,
filter_size=(4, 4),
stride=(2, 2),
crop=1,
nonlinearity=relu)))
generator.append(
ll.TransposedConv2DLayer(generator[-1],
num_filters=3,
filter_size=(4, 4),
stride=(2, 2),
crop=1,
nonlinearity=T.tanh))
for layer in generator:
print layer.output_shape
print ""
return generator
def generator(z_dim=100, num_units=128, input_var=None, batch_size=64):
generator = []
theano_rng = RandomStreams(rng.randint(2**15))
noise = theano_rng.normal(size=(batch_size, z_dim), avg=0.0, std=1.0)
input_var = noise if input_var is None else input_var
generator.append(
ll.InputLayer(shape=(batch_size, z_dim), input_var=input_var))
generator.append(ll.DenseLayer(generator[-1], num_units * 8 * 5 * 10))
generator.append(
ll.ReshapeLayer(generator[-1], shape=(-1, num_units * 8, 5, 10)))
generator.append(
ll.batch_norm(
ll.TransposedConv2DLayer(generator[-1],
num_filters=num_units * 4,
filter_size=(4, 4),
stride=(2, 2),
crop=1)))
generator.append(
ll.batch_norm(
ll.TransposedConv2DLayer(generator[-1],
num_filters=num_units * 2,
filter_size=(4, 4),
stride=(2, 2),
crop=1)))
generator.append(
ll.batch_norm(
ll.TransposedConv2DLayer(generator[-1],
num_filters=num_units,
filter_size=(4, 4),
stride=(2, 2),
crop=1)))
generator.append(
ll.TransposedConv2DLayer(generator[-1],
num_filters=3,
filter_size=(4, 4),
stride=(2, 2),
crop=1,
nonlinearity=T.tanh))
for layer in generator:
print layer.output_shape
print ""
return generator
def build_deconv(l_input):
l_input = L.ReshapeLayer(l_input, ([0], 1, 4, 6))
l_out = L.TransposedConv2DLayer(l_input,
num_filters=1, filter_size=(4,4), stride=2,
nonlinearity=None, W=LI.Constant(0.4), b=LI.Constant(0.)
)
l_out = L.TransposedConv2DLayer(l_out,
num_filters=1, filter_size=(4,4), stride=2,
nonlinearity=None, W=LI.Constant(0.4), b=LI.Constant(0.)
)
l_out = L.TransposedConv2DLayer(l_out,
num_filters=1, filter_size=(6,6), stride=2,
nonlinearity=None, W=LI.Constant(0.4), b=LI.Constant(0.)
)
return l_out
def simpleConv(input_var=None, num_units=32):
network = layers.InputLayer(shape=(None, input_n_channel, input_height,
input_width),
input_var=input_var)
network = layers.Conv2DLayer(network,
num_filters=num_units,
filter_size=(9, 9))
network = layers.MaxPool2DLayer(network, pool_size=(2, 2))
network = layers.Conv2DLayer(network,
num_filters=num_units,
filter_size=(9, 9))
network = layers.MaxPool2DLayer(network, pool_size=(2, 2))
network = layers.Conv2DLayer(network,
num_filters=1000,
filter_size=(10, 10))
network = layers.DenseLayer(layers.DropoutLayer(network, p=0.2),
num_units=1000)
network = layers.DenseLayer(layers.DropoutLayer(network, p=0.5),
num_units=1000)
network = layers.ReshapeLayer(network,
shape=(input_var.shape[0], 1000, 1, 1))
'''
network = layers.TransposedConv2DLayer(network, num_filters=num_units, filter_size=(4,4))
network = layers.Upscale2DLayer(network, 2)
network = layers.TransposedConv2DLayer(network, num_filters=num_units, filter_size=(5,5))
network = layers.Upscale2DLayer(network, 2)
network = layers.TransposedConv2DLayer(network, num_filters=3, filter_size=(9,9))
'''
network = layers.TransposedConv2DLayer(network,
num_filters=num_units,
filter_size=(8, 8))
network = layers.TransposedConv2DLayer(network,
num_filters=num_units,
filter_size=(9, 9))
network = layers.TransposedConv2DLayer(network,
num_filters=num_units,
filter_size=(9, 9))
network = layers.TransposedConv2DLayer(network,
num_filters=3,
filter_size=(9, 9))
return network
def build_transition_up(incoming,
incoming_skip,
layers_per_block,
growth_rate,
W_init=lasagne.init.GlorotUniform(),
b_init=None):
""""Builds a transition in the DenseNet model.
Transitions consist of the sequence: Batch Normalization, 1x1 Convolution,
2x2 Average Pooling. The channels can be compressed by specifying
0 < m <= 1, where num_channels = channels * m.
"""
network = nn.TransposedConv2DLayer(incoming,
growth_rate * layers_per_block,
filter_size=3,
stride=2,
crop='valid',
W=W_init,
b=b_init)
cropping = [None, None, 'center', 'center']
return nn.ConcatLayer([network, incoming_skip], cropping=cropping)
def __init__(self,
input,
num_filters,
filter_size,
stride=(2, 2),
padding=(0, 0),
activation=rectify):
"""
Allocate a TransposedConvLayer with shared variable internal parameters.
"""
self.input = input
self.output = layers.TransposedConv2DLayer(
self.input,
num_filters,
filter_size,
stride=stride,
crop=padding,
W=initialize_parameters()[0],
b=initialize_parameters()[1],
nonlinearity=activation)
def build_expand_level(incoming,
incoming_skip,
num_filters,
nonlin,
W_init=lasagne.init.GlorotUniform(),
b_init=lasagne.init.Constant(0.01),
filter_size=3):
"""Builds a Conv-Conv-Deconv-Concat block of U-Net."""
network = nn.Conv2DLayer(incoming,
num_filters,
filter_size,
pad='same',
W=W_init,
b=b_init,
nonlinearity=nonlin)
network = nn.batch_norm(network)
network = nn.Conv2DLayer(network,
num_filters,
filter_size,
pad='same',
W=W_init,
b=b_init,
nonlinearity=nonlin)
network = nn.batch_norm(network)
network = nn.TransposedConv2DLayer(network,
num_filters // 2,
filter_size,
stride=2,
crop='valid',
W=W_init,
b=b_init,
nonlinearity=nonlin)
network = nn.batch_norm(network)
crop_mode = [None, None, 'center', 'center']
return nn.ConcatLayer([network, incoming_skip], cropping=crop_mode)
def build_uunet_network(network, input_var, num_classes, num_filters=64,
nonlin=lasagne.nonlinearities.rectify, noise=0.0, # Would leaky_rectify improve network?
W_init=lasagne.init.GlorotUniform(),
b_init=lasagne.init.Constant(0.01), **kwargs):
"""Builds a fully-convolutional U-Net model."""
crop_mode = [None, None, 'center', 'center']
image_mean = np.array([103.939, 116.779, 123.68]).reshape(1, 3, 1, 1)
# To use VGG weights, change RGB to BGR and subtract the mean BGR values
sym_var = input_var[:, ::-1] - image_mean.astype(theano.config.floatX)
input_layer = nn.InputLayer((None, 3, None, None), sym_var)
network = nn.Conv2DLayer(input_layer, 64, 3, pad=1, flip_filters=False)
level1 = nn.Conv2DLayer(network, 64, 3, pad=1, flip_filters=False)
network = nn.Pool2DLayer(level1, 2)
network = nn.Conv2DLayer(network, 128, 3, pad=1, flip_filters=False)
level2 = nn.Conv2DLayer(network, 128, 3, pad=1, flip_filters=False)
network = nn.Pool2DLayer(level2, 2)
network = nn.Conv2DLayer(network, 256, 3, pad=1, flip_filters=False)
network = nn.Conv2DLayer(network, 256, 3, pad=1, flip_filters=False)
level3 = nn.Conv2DLayer(network, 256, 3, pad=1, flip_filters=False)
network = nn.Pool2DLayer(level3, 2)
network = nn.Conv2DLayer(network, 512, 3, pad=1, flip_filters=False)
network = nn.Conv2DLayer(network, 512, 3, pad=1, flip_filters=False)
level4 = nn.Conv2DLayer(network, 512, 3, pad=1, flip_filters=False)
network = nn.Pool2DLayer(level4, 2)
network = nn.Conv2DLayer(network, 512, 3, pad=1, flip_filters=False)
network = nn.Conv2DLayer(network, 512, 3, pad=1, flip_filters=False)
level5 = nn.Conv2DLayer(network, 512, 3, pad=1, flip_filters=False)
network = nn.Pool2DLayer(level5, 2)
# Set the weights for VGG portion
vgg_layers = network
# Decoder phase, all these weights will be learned
network = nn.batch_norm(nn.Conv2DLayer(network, 1024, 1, pad='same'))
network = nn.batch_norm(nn.Conv2DLayer(network, 1024, 1, pad='same'))
network = nn.TransposedConv2DLayer(network, 512, 3, stride=2, crop='valid')
network = nn.batch_norm(network)
network = nn.ConcatLayer([network, level5], cropping=crop_mode)
network = nn.batch_norm(nn.Conv2DLayer(network, 512, 3, pad='same'))
network = nn.batch_norm(nn.Conv2DLayer(network, 521, 3, pad='same'))
network = nn.TransposedConv2DLayer(network, 512, 3, stride=2, crop='valid')
network = nn.batch_norm(network)
network = nn.ConcatLayer([network, level4], cropping=crop_mode)
# @two convolutions of the same size with a max pooling step in the middle. How is this useful?
network = nn.batch_norm(nn.Conv2DLayer(network, 512, 3, pad='same'))
network = nn.batch_norm(nn.Conv2DLayer(network, 521, 3, pad='same'))
network = nn.TransposedConv2DLayer(network, 256, 3, stride=2, crop='valid')
network = nn.batch_norm(network)
network = nn.ConcatLayer([network, level3], cropping=crop_mode)
network = nn.batch_norm(nn.Conv2DLayer(network, 256, 3, pad='same'))
network = nn.batch_norm(nn.Conv2DLayer(network, 256, 3, pad='same'))
network = nn.TransposedConv2DLayer(network, 128, 3, stride=2, crop='valid')
network = nn.batch_norm(network)
network = nn.ConcatLayer([network, level2], cropping=crop_mode)
network = nn.batch_norm(nn.Conv2DLayer(network, 128, 3, pad='same'))
network = nn.batch_norm(nn.Conv2DLayer(network, 128, 3, pad='same'))
network = nn.TransposedConv2DLayer(network, 64, 3, stride=2, crop='valid')
network = nn.batch_norm(network)
network = nn.ConcatLayer([network, level1], cropping=crop_mode)
# Final few valid convolutions to output class predictions
network = nn.batch_norm(nn.Conv2DLayer(network, 64, 3, pad='same'))
network = nn.Conv2DLayer(network, num_classes, 1, pad='same', nonlinearity=None)
softmax = SpatialNonlinearityLayer(network, lasagne.nonlinearities.softmax)
# This reshapes previous layer from 2d [batch_size, num_channels * rows * cols]
# to [batch_size, num_channels, rows, cols]
target_shape = (sym_var.shape[0], num_classes,
sym_var.shape[2], sym_var.shape[3])
output = SpatialReshapeLayer(softmax, target_shape)
# Applies a CRF to the output predictions & cleans everything up
output_crf = CRFasRNNLayer(output, input_layer, normalize_final_iter=True)
return softmax, output, output_crf, vgg_layers
def cnn_autoencoder(input_var=None):
"""
Build the network using Lasagne library
"""
##################
# Network config #
##################
input_channels = 3
weight_init = lasagne.init.Normal()
# encoder
conv1_nb_filt = 32
conv1_sz_filt = (9, 9)
conv1_sz_padd = 2
# conv1 output size = (60, 60)
pool1_sz = (2, 2)
# pool1 output size = (30, 30)
conv2_nb_filt = 64
conv2_sz_filt = (7, 7)
conv2_sz_padd = 0
# conv2 output size = (24, 24)
pool2_sz = (4, 4)
# pool2 size = (6, 6)
conv3_nb_filt = 128
conv3_sz_filt = (5, 5)
conv3_sz_padd = 0
# conv3 output size = (2, 2)
pool3_sz = (2, 2)
# pool3 output size = (32, 1, 1)
dens1_nb_unit = 256
# dense1 output (vector 256)
dens2_nb_unit = 256
# dense2 output (vector 256)
rshp_sz = 1
# reshape output (256, 1, 1)
# decoder
tconv1_nb_filt = 64
tconv1_sz_filt = (5, 5)
tconv1_sz_strd = (1, 1)
# conv1 output size = (5, 5)
upsamp1_sz = (2, 2)
# upsamp1 output size = (10, 10)
tconv2_nb_filt = 32
tconv2_sz_filt = (4, 4)
tconv2_sz_strd = (1, 1)
# tconv2 output size = (13, 13)
upsamp2_sz = (2, 2)
# upsamp2 output size = (26, 26)
tconv3_nb_filt = 32
tconv3_sz_filt = (5, 5)
tconv3_sz_strd = (1, 1)
# tconv3 output size = (30, 30)
tconv4_nb_filt = 3
tconv4_sz_filt = (3, 3)
tconv4_sz_strd = (1, 1)
# tconv4 output size = (32, 32)
# final output = (3 channels, 32 x 32)
#####################
# Build the network #
#####################
# Add input layer
network = lyr.InputLayer(shape=(None, input_channels, 64, 64),
input_var=input_var)
# Add convolution layer
network = lyr.Conv2DLayer(incoming=network,
num_filters=conv1_nb_filt,
filter_size=conv1_sz_filt,
pad=conv1_sz_padd,
W=weight_init)
# Add pooling layer
network = lyr.MaxPool2DLayer(incoming=network, pool_size=pool1_sz)
# Add convolution layer
network = lyr.Conv2DLayer(incoming=network,
num_filters=conv2_nb_filt,
filter_size=conv2_sz_filt,
pad=conv2_sz_padd,
W=weight_init)
# Add pooling layer
network = lyr.MaxPool2DLayer(incoming=network, pool_size=pool2_sz)
# Add convolution layer
network = lyr.Conv2DLayer(incoming=network,
num_filters=conv3_nb_filt,
filter_size=conv3_sz_filt,
pad=conv3_sz_padd,
W=weight_init)
# Add pooling layer
network = lyr.MaxPool2DLayer(incoming=network, pool_size=pool3_sz)
network = lyr.FlattenLayer(network)
# Add dense layer
network = lyr.DenseLayer(network, dens1_nb_unit, W=weight_init)
network = lyr.DenseLayer(network, dens2_nb_unit, W=weight_init)
network = lyr.ReshapeLayer(network, (input_var.shape[0], dens2_nb_unit /
(rshp_sz**2), rshp_sz, rshp_sz))
# Add transposed convolution layer
network = lyr.TransposedConv2DLayer(incoming=network,
num_filters=tconv1_nb_filt,
filter_size=tconv1_sz_filt,
stride=tconv1_sz_strd,
W=weight_init)
# Add upsampling layer
network = lyr.Upscale2DLayer(incoming=network, scale_factor=upsamp1_sz)
# Add transposed convolution layer
network = lyr.TransposedConv2DLayer(incoming=network,
num_filters=tconv2_nb_filt,
filter_size=tconv2_sz_filt,
stride=tconv2_sz_strd,
W=weight_init)
# Add upsampling layer
network = lyr.Upscale2DLayer(incoming=network, scale_factor=upsamp2_sz)
# Add transposed convolution layer
network = lyr.TransposedConv2DLayer(incoming=network,
num_filters=tconv3_nb_filt,
filter_size=tconv3_sz_filt,
stride=tconv3_sz_strd,
W=weight_init)
# Add transposed convolution layer
network = lyr.TransposedConv2DLayer(
incoming=network,
num_filters=tconv4_nb_filt,
filter_size=tconv4_sz_filt,
stride=tconv4_sz_strd,
W=weight_init,
nonlinearity=lasagne.nonlinearities.sigmoid)
return network
def build_context_encoder(input_var=None,
nfilters=[64, 128, 256, 512, 3000, 512, 256, 128, 3],
input_channels=3):
###############################
# Build Network Configuration #
###############################
print('... Building the generator')
leaky = nonlinearities.LeakyRectify(0.2)
# Input of the network : shape = (batch_size, 3, 64, 64)
network = layers.InputLayer(shape=(None, input_channels, 64, 64),
input_var=input_var)
# Conv layer : shape = (batch_size, 64, 32, 32)
network = layers.Conv2DLayer(network,
num_filters=nfilters[0],
filter_size=(5, 5),
stride=2,
pad=2,
nonlinearity=leaky)
# Conv layer : shape = (batch_size, 128, 16, 16)
network = layers.batch_norm(
lasagne.layers.Conv2DLayer(network,
num_filters=nfilters[1],
filter_size=(5, 5),
stride=2,
pad=2,
nonlinearity=leaky))
# Conv layer : shape = (batch_size, 256, 8, 8)
network = layers.batch_norm(
lasagne.layers.Conv2DLayer(network,
num_filters=nfilters[2],
filter_size=(5, 5),
stride=2,
pad=2,
nonlinearity=leaky))
# Conv layer : shape = (batch_size, 512, 4, 4)
network = layers.batch_norm(
lasagne.layers.Conv2DLayer(network,
num_filters=nfilters[3],
filter_size=(5, 5),
stride=2,
pad=2,
nonlinearity=leaky))
# Conv layer : shape = (batch_size, 3000, 1, 1)
network = layers.batch_norm(
lasagne.layers.Conv2DLayer(network,
num_filters=nfilters[4],
filter_size=(4, 4),
stride=2,
nonlinearity=leaky))
# Tranposed conv layer : shape = (batch_size, 512, 4, 4)
network = layers.batch_norm(
layers.TransposedConv2DLayer(network,
num_filters=nfilters[5],
filter_size=(4, 4),
stride=(1, 1)))
# Tranposed conv layer : shape = (batch_size, 256, 8, 8)
network = layers.batch_norm(
layers.TransposedConv2DLayer(network,
num_filters=nfilters[6],
filter_size=(5, 5),
stride=(2, 2),
crop=2,
output_size=8))
# Tranposed conv layer : shape = (batch_size, 128, 16, 16)
network = layers.batch_norm(
layers.TransposedConv2DLayer(network,
num_filters=nfilters[7],
filter_size=(5, 5),
stride=(2, 2),
crop=2,
output_size=16))
# Tranposed conv layer : shape = (batch_size, 3, 32, 32)
network = layers.TransposedConv2DLayer(network,
num_filters=nfilters[8],
filter_size=5,
stride=2,
crop=2,
output_size=32,
nonlinearity=nonlinearities.sigmoid)
return network
def define_net():
net = {}
print("Generator layer shapes:")
net['input'] = ll.InputLayer(shape=(None, 3, IMAGE_SHAPE[0],
IMAGE_SHAPE[1]))
leaky_relu = lasagne.nonlinearities.LeakyRectify(0.2)
# net['stand'] = ll.standardize(net['input'], offset=np.array([0, 0, 0], dtype='float32'),
# scale=np.array([128.0, 128.0, 128.0], dtype='float32'))
net['conv_1'] = Conv2DLayer(net['input'],
num_filters=64,
stride=(2, 2),
filter_size=(4, 4),
nonlinearity=leaky_relu)
print(lasagne.layers.get_output_shape(net['conv_1']))
net['conv_2'] = batch_norm(
Conv2DLayer(net['conv_1'],
num_filters=128,
stride=(2, 2),
filter_size=(4, 4),
nonlinearity=leaky_relu))
print(lasagne.layers.get_output_shape(net['conv_2']))
net['conv_3'] = batch_norm(
Conv2DLayer(net['conv_2'],
num_filters=256,
stride=(2, 2),
filter_size=(4, 4),
nonlinearity=leaky_relu))
print(lasagne.layers.get_output_shape(net['conv_3']))
net['conv_4'] = batch_norm(
Conv2DLayer(net['conv_3'],
num_filters=512,
stride=(2, 2),
filter_size=(4, 4),
nonlinearity=leaky_relu))
print(lasagne.layers.get_output_shape(net['conv_4']))
net['conv_5'] = batch_norm(
Conv2DLayer(net['conv_4'],
num_filters=512,
stride=(2, 2),
filter_size=(4, 4),
nonlinearity=leaky_relu))
print(lasagne.layers.get_output_shape(net['conv_5']))
net['conv_6'] = batch_norm(
Conv2DLayer(net['conv_5'],
num_filters=512,
stride=(2, 2),
filter_size=(4, 4),
nonlinearity=leaky_relu))
print(lasagne.layers.get_output_shape(net['conv_6']))
net['conv_6'] = DropoutLayer(net['conv_6'])
net['unconv_1'] = ll.batch_norm(
ll.TransposedConv2DLayer(net['conv_6'],
num_filters=512,
stride=(2, 2),
filter_size=(4, 4)))
print(lasagne.layers.get_output_shape(net['unconv_1']))
concat = DropoutLayer(
ll.ConcatLayer([net['unconv_1'], net['conv_5']], axis=1))
net['unconv_2'] = (ll.batch_norm(
ll.TransposedConv2DLayer(concat,
num_filters=512,
stride=(2, 2),
filter_size=(4, 4))))
print(lasagne.layers.get_output_shape(net['unconv_2']))
concat = DropoutLayer(
ll.ConcatLayer([net['unconv_2'], net['conv_4']], axis=1))
net['unconv_3'] = ll.batch_norm(
ll.TransposedConv2DLayer(concat,
num_filters=256,
stride=(2, 2),
filter_size=(4, 4)))
print(lasagne.layers.get_output_shape(net['unconv_3']))
concat = ll.ConcatLayer([net['unconv_3'], net['conv_3']], axis=1)
net['unconv_4'] = ll.batch_norm(
ll.TransposedConv2DLayer(concat,
num_filters=128,
stride=(2, 2),
filter_size=(4, 4)))
print(lasagne.layers.get_output_shape(net['unconv_4']))
concat = ll.ConcatLayer([net['unconv_4'], net['conv_2']], axis=1)
net['unconv_5'] = ll.batch_norm(
ll.TransposedConv2DLayer(concat,
num_filters=64,
stride=(2, 2),
filter_size=(5, 5)))
print(lasagne.layers.get_output_shape(net['unconv_5']))
concat = ll.ConcatLayer([net['unconv_5'], net['conv_1']], axis=1)
net['unconv_6'] = ll.batch_norm(
ll.TransposedConv2DLayer(concat,
num_filters=32,
stride=(2, 2),
filter_size=(4, 4)))
print(lasagne.layers.get_output_shape(net['unconv_6']))
net['pre_out'] = batch_norm(
Conv2DLayer(net['unconv_6'],
num_filters=3,
filter_size=(3, 3),
nonlinearity=lasagne.nonlinearities.tanh,
pad='same'))
print(lasagne.layers.get_output_shape(net['pre_out']))
net['out'] = ll.standardize(net['pre_out'],
offset=np.array([0, 0, 0], dtype='float32'),
scale=np.array(
[1 / 128.0, 1 / 128.0, 1 / 128.0],
dtype='float32'))
print(lasagne.layers.get_output_shape(net['out']))
return net
def build_autoencoder(layer,
nonlinearity='same',
b=init.Constant(0.),
learnable_conv=False):
"""
Unfolds a stack of layers into a symmetric autoencoder with tied weights.
Given a :class:`Layer` instance, this function builds a
symmetric autoencoder with tied weights.
Parameters
----------
layer : a :class:`Layer` instance or a tuple
The :class:`Layer` instance with respect to which a symmetric
autoencoder is built.
nonlinearity : 'same', list, callable, or None
The nonlinearities that are applied to the decoding layer.
If 'same', each decoder layer has the same nonlinearity as its
corresponding encoder layer. If a list is provided, it must contain
nonlinearities for each decoding layer. Otherwise, if a single
nonlinearity is provided, it is applied to all decoder layers.
If set to ``None``, all nonlinearities for the decoder layers are set
to lasagne.nonlinearities.identity.
b : callable, Theano shared variable, numpy array, list or None
An initializer for the decoder biases. By default, all decoder
biases are initialized to lasagne.init.Constant(0.). If a shared
variable or a numpy array is provided, the shape must match the
incoming shape (only in case all incoming shapes are the same).
Additianlly, a list containing initializers for the biases of each
decoder layer can be provided. If set to ``None``, the decoder
layers will have no biases, and pass through their input instead.
Returns
-------
layer: :class:`Layer` instance
The output :class:`Layer` of the symmetric autoencoder with
tied weights.
encoder: :class:`Layer` instance
The code :class:`Layer` of the autoencoder (see Notes)
Notes
-----
The encoder (input) :class:`Layer` is changed using
`unfold_bias_and_nonlinearity_layers`. Therefore, this layer is not the
code layer anymore, because it has got its bias and nonlinearity stripped
off.
Examples
--------
>>> from lasagne.layers import InputLayer, DenseLayer
>>> from lasagne.layers import build_autoencoder
>>> l_in = InputLayer((100, 20))
>>> l1 = DenseLayer(l_in, num_units=50)
>>> l2 = DenseLayer(l1, num_units=10)
>>> l_ae, l2 = build_autoencoder(l2, nonlinearity='same', b=None)
"""
if isinstance(nonlinearity, (tuple, list)):
n_idx = 0
if isinstance(b, (tuple, list)):
b_idx = 0
encoder = unfold_bias_and_nonlinearity_layers(layer)
layers = get_all_layers(encoder)
autoencoder_layers = [encoder]
kwargs_b = dict(b=None)
kwargs_n = dict(nonlinearity=nonlinearities.identity)
for i, layer in enumerate(layers[::-1]):
incoming = autoencoder_layers[-1]
if isinstance(layer, InputLayer):
continue
elif isinstance(layer, BiasLayer):
if b is None:
kwargs_b = dict(b=None)
elif isinstance(b, (tuple, list)):
kwargs_b = dict(b=b[b_idx])
b_idx += 1
else:
kwargs_b = dict(b=b)
elif isinstance(layer, NonlinearityLayer):
if nonlinearity == 'same':
kwargs_n = dict(nonlinearity=layer.nonlinearity)
elif nonlinearity is None:
kwargs_n = dict(nonlinearity=nonlinearities.identity)
elif isinstance(nonlinearity, (tuple, list)):
kwargs_n = dict(nonlinearity=nonlinearity[n_idx])
n_idx += 1
else:
kwargs_n = dict(nonlinearity=nonlinearity)
elif isinstance(layer, DropoutLayer):
a_layer = DropoutLayer(incoming=incoming,
p=layer.p,
rescale=layer.rescale)
autoencoder_layers.append(a_layer)
elif isinstance(layer, GaussianNoiseLayer):
a_layer = GaussianNoiseLayer(incoming=incoming, sigma=layer.sigma)
autoencoder_layers.append(a_layer)
elif isinstance(layer, L.Conv2DLayer):
a_layer = L.TransposedConv2DLayer(incoming=incoming,
num_filters=layer.input_shape[1],
filter_size=layer.filter_size,
stride=layer.stride,
crop=layer.pad,
untie_biases=layer.untie_biases,
b=None,
nonlinearity=None)
elif isinstance(layer, L.MaxPool2DLayer):
a_layer = L.Upscale2DLayer(incoming=incoming,
scale_factor=layer.pool_size)
elif isinstance(layer, L.BatchNormLayer):
a_layer = L.BatchNormLayer(incoming)
else:
a_layer = InverseLayer(incoming=incoming, layer=layer)
if hasattr(layer, 'b'):
a_layer = BiasLayer(incoming=a_layer, **kwargs_b)
if hasattr(layer, 'nonlinearity'):
a_layer = NonlinearityLayer(incoming=a_layer, **kwargs_n)
autoencoder_layers.append(a_layer)
return autoencoder_layers, encoder
