(args.batch_size, gen_dim, 16, 16), (5, 5),
W=Normal(0.05),
nonlinearity=nn.relu),
g=None)) # 8 -> 16
gen_layers.append(
nn.weight_norm(nn.Deconv2DLayer(gen_layers[-1],
(args.batch_size, 1, 32, 32), (5, 5),
W=Normal(0.05),
nonlinearity=T.tanh),
train_g=True,
init_stdv=0.1)) # 16 -> 32
gen_dat = ll.get_output(gen_layers[-1])
# specify discriminative model
disc_layers = [ll.InputLayer(shape=(None, 1, 32, 32))]
disc_layers.append(ll.GaussianNoiseLayer(disc_layers[-1], sigma=0.2))
disc_layers.append(
nn.weight_norm(
dnn.Conv2DDNNLayer(disc_layers[-1],
disc_dim, (5, 5),
pad=1,
W=Normal(0.05),
nonlinearity=nn.lrelu)))
disc_layers.append(
nn.weight_norm(
dnn.Conv2DDNNLayer(disc_layers[-1],
disc_dim, (5, 5),
pad=1,
stride=2,
W=Normal(0.05),
nonlinearity=nn.lrelu)))
def get_discriminator(self):
''' specify discriminator D0 '''
"""
disc0_layers = [LL.InputLayer(shape=(self.args.batch_size, 3, 32, 32))]
disc0_layers.append(LL.GaussianNoiseLayer(disc0_layers[-1], sigma=0.05))
disc0_layers.append(dnn.Conv2DDNNLayer(disc0_layers[-1], 96, (3,3), pad=1, W=Normal(0.02), nonlinearity=nn.lrelu))
disc0_layers.append(nn.batch_norm(dnn.Conv2DDNNLayer(disc0_layers[-1], 96, (3,3), pad=1, stride=2, W=Normal(0.02), nonlinearity=nn.lrelu))) # 16x16
disc0_layers.append(LL.DropoutLayer(disc0_layers[-1], p=0.1))
disc0_layers.append(nn.batch_norm(dnn.Conv2DDNNLayer(disc0_layers[-1], 192, (3,3), pad=1, W=Normal(0.02), nonlinearity=nn.lrelu)))
disc0_layers.append(nn.batch_norm(dnn.Conv2DDNNLayer(disc0_layers[-1], 192, (3,3), pad=1, stride=2, W=Normal(0.02), nonlinearity=nn.lrelu))) # 8x8
disc0_layers.append(LL.DropoutLayer(disc0_layers[-1], p=0.1))
disc0_layers.append(nn.batch_norm(dnn.Conv2DDNNLayer(disc0_layers[-1], 192, (3,3), pad=0, W=Normal(0.02), nonlinearity=nn.lrelu))) # 6x6
disc0_layer_shared = LL.NINLayer(disc0_layers[-1], num_units=192, W=Normal(0.02), nonlinearity=nn.lrelu) # 6x6
disc0_layers.append(disc0_layer_shared)
disc0_layer_z_recon = LL.DenseLayer(disc0_layer_shared, num_units=50, W=Normal(0.02), nonlinearity=None)
disc0_layers.append(disc0_layer_z_recon) # also need to recover z from x
disc0_layers.append(LL.GlobalPoolLayer(disc0_layer_shared))
disc0_layer_adv = LL.DenseLayer(disc0_layers[-1], num_units=10, W=Normal(0.02), nonlinearity=None)
disc0_layers.append(disc0_layer_adv)
return disc0_layers, disc0_layer_adv, disc0_layer_z_recon
"""
disc_x_layers = [LL.InputLayer(shape=(None, 3, 32, 32))]
disc_x_layers.append(
LL.GaussianNoiseLayer(disc_x_layers[-1], sigma=0.2))
disc_x_layers.append(
dnn.Conv2DDNNLayer(disc_x_layers[-1],
96, (3, 3),
pad=1,
W=Normal(0.01),
nonlinearity=nn.lrelu))
disc_x_layers.append(
nn.batch_norm(
dnn.Conv2DDNNLayer(disc_x_layers[-1],
96, (3, 3),
pad=1,
stride=2,
W=Normal(0.01),
nonlinearity=nn.lrelu)))
disc_x_layers.append(LL.DropoutLayer(disc_x_layers[-1], p=0.5))
disc_x_layers.append(
nn.batch_norm(
dnn.Conv2DDNNLayer(disc_x_layers[-1],
192, (3, 3),
pad=1,
W=Normal(0.01),
nonlinearity=nn.lrelu)))
disc_x_layers.append(
nn.batch_norm(
dnn.Conv2DDNNLayer(disc_x_layers[-1],
192, (3, 3),
pad=1,
stride=2,
W=Normal(0.01),
nonlinearity=nn.lrelu)))
disc_x_layers.append(LL.DropoutLayer(disc_x_layers[-1], p=0.5))
disc_x_layers.append(
nn.batch_norm(
dnn.Conv2DDNNLayer(disc_x_layers[-1],
192, (3, 3),
pad=0,
W=Normal(0.01),
nonlinearity=nn.lrelu)))
disc_x_layers_shared = LL.NINLayer(disc_x_layers[-1],
num_units=192,
W=Normal(0.01),
nonlinearity=nn.lrelu)
disc_x_layers.append(disc_x_layers_shared)
disc_x_layer_z_recon = LL.DenseLayer(disc_x_layers_shared,
num_units=self.args.z0dim,
nonlinearity=None)
disc_x_layers.append(
disc_x_layer_z_recon) # also need to recover z from x
# disc_x_layers.append(nn.MinibatchLayer(disc_x_layers_shared, num_kernels=100))
disc_x_layers.append(LL.GlobalPoolLayer(disc_x_layers_shared))
disc_x_layer_adv = LL.DenseLayer(disc_x_layers[-1],
num_units=10,
W=Normal(0.01),
nonlinearity=None)
disc_x_layers.append(disc_x_layer_adv)
#output_before_softmax_x = LL.get_output(disc_x_layer_adv, x, deterministic=False)
#output_before_softmax_gen = LL.get_output(disc_x_layer_adv, gen_x, deterministic=False)
# temp = LL.get_output(gen_x_layers[-1], deterministic=False, init=True)
# temp = LL.get_output(disc_x_layers[-1], x, deterministic=False, init=True)
# init_updates = [u for l in LL.get_all_layers(gen_x_layers)+LL.get_all_layers(disc_x_layers) for u in getattr(l,'init_updates',[])]
return disc_x_layers, disc_x_layer_adv, disc_x_layer_z_recon
gen_layers.append(
nn.Deconv2DLayer(gen_layers[-1], (args.batch_size, 128, 16, 16), (5, 5),
W=Normal(0.05),
nonlinearity=nn.relu))
gen_layers.append(nn.batch_norm(gen_layers[-1], g=None))
gen_layers.append(nn.ConvConcatLayer([gen_layers[-1], gen_in_y], num_classes))
gen_layers.append(
nn.Deconv2DLayer(gen_layers[-1], (args.batch_size, 3, 32, 32), (5, 5),
W=Normal(0.05),
nonlinearity=T.tanh))
gen_layers.append(nn.weight_norm(gen_layers[-1], train_g=True, init_stdv=0.1))
# specify discriminative model
disc_layers = [ll.InputLayer(shape=(None, 3, 32, 32))]
disc_layers.append(ll.GaussianNoiseLayer(
disc_layers[-1],
sigma=0.2)) #uncomment this line if test without data augmentation
disc_layers.append(
nn.weight_norm(
dnn.Conv2DDNNLayer(disc_layers[-1],
96, (3, 3),
pad=1,
W=Normal(0.05),
nonlinearity=nn.lrelu)))
disc_layers.append(
nn.weight_norm(
dnn.Conv2DDNNLayer(disc_layers[-1],
96, (3, 3),
pad=1,
W=Normal(0.05),
nonlinearity=nn.lrelu)))
def build_model(cp):
# Check batch norm flag
batch_norm_flag = cp.getboolean('Hyperparameters', 'BatchNorm')
# Initialize activation functions
relu = lasagne.nonlinearities.rectify
linear = lasagne.nonlinearities.linear
sigmoid = lasagne.nonlinearities.sigmoid
softmax = lasagne.nonlinearities.softmax
# Make activation dictionary
act_dict = {
'ReLU': relu,
'Linear': linear,
'Sigmoid': sigmoid,
'Softmax': softmax
}
# Begin stacking layers
###########################################################################
# Encoder part of AE / GAN Generator
###########################################################################
# Input
input_layer = ae_network = ll.InputLayer(
shape=(None, cp.getint('AAE_Input', 'Width')), name='AAE_Input')
# Add batch norm when flag is true
if batch_norm_flag:
ae_network = ll.BatchNormLayer(incoming=ae_network)
# Dropout
ae_network = ll.DropoutLayer(incoming=ae_network,
p=float(cp.get('Dropout', 'rate')))
# List of encoder sections in config file
enc_sect = [i for i in cp.sections() if 'Encoder' in i]
# Stack endoder layers
for sect in enc_sect:
ae_network = ll.DenseLayer(incoming=ae_network,
num_units=cp.getint(sect, 'Width'),
nonlinearity=act_dict[cp.get(
sect, 'Activation')],
name=sect)
# Add generator flag that will be used in backward pass
ae_network.params[ae_network.W].add('generator_z')
ae_network.params[ae_network.b].add('generator_z')
ae_network.params[ae_network.W].add('generator_y')
ae_network.params[ae_network.b].add('generator_y')
# Add batch norm when flag is true
if batch_norm_flag: # and (sect != enc_sect[-1]):
ae_network = ll.BatchNormLayer(incoming=ae_network)
# Latent variable Y layer also known as q(y|x)
gen_y = ll.DenseLayer(incoming=ae_network,
num_units=cp.getint('Y', 'Width'),
nonlinearity=act_dict[cp.get('Y', 'Activation')],
name='Y')
# Add generator flag that will be used in backward pass
gen_y.params[gen_y.W].add('generator_y')
gen_y.params[gen_y.b].add('generator_y')
# Latent variable Z layer also known as q(z|x)
gen_z = ll.DenseLayer(incoming=ae_network,
num_units=cp.getint('Z', 'Width'),
nonlinearity=act_dict[cp.get('Z', 'Activation')],
name='Z')
# Add generator flag that will be used in backward pass
gen_z.params[gen_z.W].add('generator_z')
gen_z.params[gen_z.b].add('generator_z')
# ---- End of Encoder for AE, Generator Z for GAN1 and Generator Y for GAN2----
###########################################################################
# Merging latent label+style representations
###########################################################################
# Save pre-merge layers for Discriminators
z_dis_net = gen_z
y_dis_net = gen_y
# Prepare Y for merging
gen_y = ll.DenseLayer(incoming=gen_y,
num_units=cp.getint('Decoder1', 'Width'),
nonlinearity=act_dict['Linear'],
b=None,
name='PreDecY')
# Prepare Z for merging
gen_z = ll.DenseLayer(incoming=gen_z,
num_units=cp.getint('Decoder1', 'Width'),
nonlinearity=act_dict['Linear'],
b=None,
name='PreDecZ')
if batch_norm_flag:
gen_y = ll.BatchNormLayer(incoming=gen_y)
gen_z = ll.BatchNormLayer(incoming=gen_z)
ae_network = ll.ConcatLayer([gen_z, gen_y], name='MergeLatent')
###########################################################################
# Decoder part of AE
###########################################################################
ae_network = ll.DenseLayer(incoming=ae_network,
num_units=cp.getint('Decoder1', 'Width'),
nonlinearity=act_dict[cp.get(
'Decoder1', 'Activation')],
name='MergeDec')
# List of decoder section in config file
dec_sect = [i for i in cp.sections() if 'Decoder' in i]
# Stack decoder layers
for sect in dec_sect:
ae_network = ll.DenseLayer(incoming=ae_network,
num_units=cp.getint(sect, 'Width'),
nonlinearity=act_dict[cp.get(
sect, 'Activation')],
name=sect)
ae_out = ae_network = ll.DenseLayer(
incoming=ae_network,
num_units=cp.getint('AAE_Output', 'Width'),
nonlinearity=act_dict[cp.get('AAE_Output', 'Activation')],
name='AAE_Output')
# ---- End of Decoder for AE ----
###########################################################################
# Z Discriminator part of GAN
###########################################################################
# z_prior_inp = ll.InputLayer(
# shape=(None, cp.getint('Z', 'Width')), name='pz_inp')
# z_dis_in = z_dis_net = ll.ConcatLayer(
# [pre_merge_z, z_prior_inp], axis=0, name='Z_Dis_in')
z_dis_net = ll.GaussianNoiseLayer(incoming=z_dis_net, sigma=0.3)
# Stack discriminator layers
for sect in [i for i in cp.sections() if 'Discriminator' in i]:
z_dis_net = ll.DenseLayer(incoming=z_dis_net,
num_units=cp.getint(sect, 'Width'),
nonlinearity=act_dict[cp.get(
sect, 'Activation')],
name='Z_' + sect)
# Add generator flag that will be used in backward pass
z_dis_net.params[z_dis_net.W].add('discriminator_z')
z_dis_net.params[z_dis_net.b].add('discriminator_z')
# Z discriminator output
z_dis_out = z_dis_net = ll.DenseLayer(incoming=z_dis_net,
num_units=cp.getint('Dout', 'Width'),
nonlinearity=act_dict[cp.get(
'Dout', 'Activation')],
name='Z_Dis_out')
z_dis_out.params[z_dis_out.W].add('discriminator_z')
z_dis_out.params[z_dis_out.b].add('discriminator_z')
# ---- End of Z Discriminator ----
###########################################################################
# Y Discriminator part of GAN
###########################################################################
# y_prior_inp = ll.InputLayer(
# shape=(None, cp.getint('Y', 'Width')), name='py_inp')
# y_dis_in = y_dis_net = ll.ConcatLayer(
# [pre_merge_y, y_prior_inp], axis=0, name='Y_Dis_in')
y_dis_net = ll.GaussianNoiseLayer(incoming=y_dis_net, sigma=0.3)
# Stack discriminator layers
for sect in [i for i in cp.sections() if 'Discriminator' in i]:
y_dis_net = ll.DenseLayer(incoming=y_dis_net,
num_units=cp.getint(sect, 'Width'),
nonlinearity=act_dict[cp.get(
sect, 'Activation')],
name='Y_' + sect)
# Add generator flag that will be used in backward pass
y_dis_net.params[y_dis_net.W].add('discriminator_y')
y_dis_net.params[y_dis_net.b].add('discriminator_y')
# Y discriminator output
y_dis_out = y_dis_net = ll.DenseLayer(incoming=y_dis_net,
num_units=cp.getint('Dout', 'Width'),
nonlinearity=act_dict[cp.get(
'Dout', 'Activation')],
name='Y_Dis_out')
y_dis_out.params[y_dis_out.W].add('discriminator_y')
y_dis_out.params[y_dis_out.b].add('discriminator_y')
# ---- End of Y Discriminator ----
aae = ll.get_all_layers([ae_out, z_dis_out, y_dis_out])
layer_dict = {layer.name: layer for layer in aae}
return layer_dict, aae
testx_white = whitener.apply(testx)
print('Done whitening')
if args.activation == 'relu':
f = nn.relu
elif args.activation == 'elu':
f = lasagne.nonlinearities.elu
elif args.activation == 'gelu':
f = nn.gelu
else:
assert False, 'Need "relu" "elu" or "gelu" nonlinearity as input name'
x = T.tensor4()
layers = [ll.InputLayer(shape=(None, 3, 32, 32), input_var=x)]
layers.append(ll.GaussianNoiseLayer(layers[-1], sigma=0.15))
layers.append(
batch_norm(
dnn.Conv2DDNNLayer(layers[-1], 96, (3, 3), pad=1, nonlinearity=f)))
layers.append(
batch_norm(
dnn.Conv2DDNNLayer(layers[-1], 96, (3, 3), pad=1, nonlinearity=f)))
layers.append(
batch_norm(
dnn.Conv2DDNNLayer(layers[-1], 96, (3, 3), pad=1, nonlinearity=f)))
layers.append(ll.MaxPool2DLayer(layers[-1], 2))
layers.append(ll.DropoutLayer(layers[-1], p=0.5))
layers.append(
batch_norm(
dnn.Conv2DDNNLayer(layers[-1], 192, (3, 3), pad=1, nonlinearity=f)))
layers.append(
def build_network(input_shape,
input_var,
num_classes,
num_filters=32,
nonlin=lasagne.nonlinearities.rectify,
noise=0.0,
W_init=lasagne.init.GlorotUniform(),
b_init=lasagne.init.Constant(0.01)):
"""Builds a fully-convolutional U-Net model."""
input_layer = nn.InputLayer(input_shape, input_var)
network = input_layer
if noise > 0:
network = nn.GaussianNoiseLayer(network, noise)
level1, network = build_contract_level(network, num_filters * 1, nonlin,
W_init)
level2, network = build_contract_level(network, num_filters * 2, nonlin,
W_init)
level3, network = build_contract_level(network, num_filters * 4, nonlin,
W_init)
level4, network = build_contract_level(network, num_filters * 8, nonlin,
W_init)
network = build_expand_level(network, level4, num_filters * 16, nonlin,
W_init)
network = build_expand_level(network, level3, num_filters * 8, nonlin,
W_init)
network = build_expand_level(network, level2, num_filters * 4, nonlin,
W_init)
network = build_expand_level(network, level1, num_filters * 2, nonlin,
W_init)
network = nn.Conv2DLayer(network,
num_filters,
3,
pad='same',
W=W_init,
b=b_init,
nonlinearity=nonlin)
network = nn.batch_norm(network)
network = nn.Conv2DLayer(network,
num_filters,
3,
pad='same',
W=W_init,
b=b_init,
nonlinearity=nonlin)
network = nn.batch_norm(network)
# Final few valid convolutions to output class predictions
network = nn.Conv2DLayer(network, num_classes, 1, W=W_init, b=b_init)
softmax = SpatialNonlinearityLayer(network, lasagne.nonlinearities.softmax)
# Reshape the final layer to look like input images
var = input_layer.input_var.shape
target_shape = (var.shape[0], num_classes, var.shape[2], var.shape[3])
reshape = SpatialReshapeLayer(softmax, target_shape)
return softmax, reshape, nn.get_all_params(softmax)
