def high_capacity_encoder(name,
inputs,
n_channels,
latent_dim,
is_training,
mode=None,
nonlinearity=tf.nn.relu):
output = tf.reshape(inputs, [-1, n_channels, DIM, DIM])
output = Conv2D(name + '.0', n_channels, DIM, 5, output, stride=2)
output = Normalize(name + '.BN0', [0, 2, 3], output, is_training, mode)
output = nonlinearity(output)
output = Conv2D(name + '.1', DIM, DIM * 2, 5, output, stride=2)
output = Normalize(name + '.BN1', [0, 2, 3], output, is_training, mode)
output = nonlinearity(output)
output = Conv2D(name + '.2', DIM * 2, DIM * 4, 5, output, stride=2)
output = Normalize(name + '.BN2', [0, 2, 3], output, is_training, mode)
output = nonlinearity(output)
output = tf.reshape(output, [-1, DIM * 4 * 8 * 8])
output = Linear(name + '.FC', DIM * 4 * 8 * 8, DIM * 4 * 8, output)
output = Normalize(name + '.BNFC', [0], output, is_training, mode)
output = nonlinearity(output)
output = Linear(name + '.Output', DIM * 4 * 8, latent_dim, output)
return output
def classification_net(name,
z,
class_net_unit_num,
class_num,
is_training,
mode=None,
nonlinearity=tf.nn.relu):
#print('In classification network')
output = Linear(name + '.Input',
z.get_shape().as_list()[1], class_net_unit_num, z)
#print output.shape
output = Normalize(name + '.BN01', [0], output, is_training, mode)
#print output.shape
output = nonlinearity(output)
# output=Linear(name +'.Input1', 32,8,output)
#
# output = Normalize(name + '.BN02', [0], output, is_training, mode)
# # print output.shape
# output = nonlinearity(output)
#last layer
output = Linear(name + '.Input1', class_net_unit_num, class_num, output)
#print output.shape
return output
def dcgan_encoder(name,
inputs,
n_channels,
latent_dim,
is_training,
mode=None,
nonlinearity=LeakyReLU):
conv2d.set_weights_stdev(0.02)
deconv2d.set_weights_stdev(0.02)
linear.set_weights_stdev(0.02)
output = tf.reshape(inputs, [-1, n_channels, DIM, DIM])
output = Conv2D(name + '.1', 3, DIM, 5, output, stride=2)
output = nonlinearity(output)
output = Conv2D(name + '.2', DIM, 2 * DIM, 5, output, stride=2)
output = Normalize(name + '.BN2', [0, 2, 3], output, is_training, mode)
output = nonlinearity(output)
output = Conv2D(name + '.3', 2 * DIM, 4 * DIM, 5, output, stride=2)
output = Normalize(name + '.BN3', [0, 2, 3], output, is_training, mode)
output = nonlinearity(output)
output = Conv2D(name + '.4', 4 * DIM, 8 * DIM, 5, output, stride=2)
output = Normalize(name + '.BN4', [0, 2, 3], output, is_training, mode)
output = nonlinearity(output)
output = tf.reshape(output, [-1, 4 * 4 * 8 * DIM])
output = Linear(name + '.Output', 4 * 4 * 8 * DIM, latent_dim, output)
conv2d.unset_weights_stdev()
deconv2d.unset_weights_stdev()
linear.unset_weights_stdev()
return output
def high_capacity_decoder(name,
z,
n_channels,
is_training,
mode=None,
nonlinearity=tf.nn.relu):
output = Linear(name + '.Input',
z.get_shape().as_list()[1], DIM * 4 * 8 * 8, z)
output = Normalize(name + '.BN0', [0], output, is_training, mode)
output = nonlinearity(output)
output = tf.reshape(output, [-1, DIM * 4, 8, 8])
output = Deconv2D(name + '.1', DIM * 4, DIM * 4, 5, output)
output = Normalize(name + '.BN1', [0, 2, 3], output, is_training, mode)
output = nonlinearity(output)
output = Deconv2D(name + '.2', DIM * 4, DIM * 2, 5, output)
output = Normalize(name + '.BN2', [0, 2, 3], output, is_training, mode)
output = nonlinearity(output)
output = Deconv2D(name + '.3', DIM * 2, DIM // 2, 5, output)
output = Normalize(name + '.BN3', [0, 2, 3], output, is_training, mode)
output = nonlinearity(output)
output = Conv2D(name + '.4', DIM // 2, n_channels, 5, output)
output = tf.reshape(output, [-1, n_channels * DIM * DIM])
return output
def dcgan_decoder(name, z, n_channels, is_training, mode=None, nonlinearity=tf.nn.relu):
conv2d.set_weights_stdev(0.02)
deconv2d.set_weights_stdev(0.02)
linear.set_weights_stdev(0.02)
output = Linear(name + '.Input', z.get_shape().as_list()[1], 4*4*8*DIM, z)
output = tf.reshape(output, [-1, 8*DIM, 4, 4])
output = Normalize(name + '.BN1', [0,2,3], output, is_training, mode)
output = nonlinearity(output)
output = Deconv2D(name +'.2', 8*DIM, 4*DIM, 5, output)
output = Normalize(name + '.BN2', [0,2,3], output, is_training, mode)
output = nonlinearity(output)
output = Deconv2D(name +'.3', 4*DIM, 2*DIM, 5, output)
output = Normalize(name + '.BN3', [0,2,3], output, is_training, mode)
output = nonlinearity(output)
output = Deconv2D(name +'.4', 2*DIM, DIM, 5, output)
output = Normalize(name + '.BN4', [0,2,3], output, is_training, mode)
output = nonlinearity(output)
output = Deconv2D(name +'.5', DIM, n_channels, 5, output)
output = tf.reshape(output, [-1, n_channels*DIM*DIM])
conv2d.unset_weights_stdev()
deconv2d.unset_weights_stdev()
linear.unset_weights_stdev()
return output
def resnet_decoder(name, z, n_channels, is_training, mode=None, nonlinearity=tf.nn.relu):
#print('In decoder network')
output = Linear(name + '.Input', z.get_shape().as_list()[1], 4*4*1*DIM, z)
#print output.shape
output = Normalize(name + '.BN0', [0], output, is_training, mode)
#print output.shape
output = nonlinearity(output)
#print output.shape
output = tf.reshape(output, [-1, 1*DIM, 4, 4])
#print output.shape
#output = ResidualBlock(name + '.Res1', 8*DIM, 8*DIM, 3, output, is_training, mode, resample='up', norm_inputs=True)
#output = ResidualBlock(name + '.Res2', 8*DIM, 4*DIM, 3, output, is_training, mode, resample='up')
output = ResidualBlock(name + '.Res1', 1*DIM, 2*DIM, 3, output, is_training, mode, resample='up', norm_inputs=True)
#print output.shape
output = ResidualBlock(name + '.Res2', 2*DIM, 4*DIM, 3, output, is_training, mode, resample='up')
#print output.shape
output = ResidualBlock(name + '.Res3', 4*DIM, 4*DIM, 3, output, is_training, mode, resample='up')
#print output.shape
output = Normalize(name + '.BN5', [0,2,3], output, is_training, mode)
#print output.shape
output = nonlinearity(output)
#print output.shape
output = Conv2D(name + '.Output', 4*DIM, n_channels, 3, output)
#print output.shape
output = tf.reshape(output, [-1, n_channels*DIM*DIM])
#print output.shape
return output
def gan_discriminator(name,
inputs,
n_channels,
is_training,
mode=None,
nonlinearity=LeakyReLU):
output = tf.reshape(inputs, [-1, n_channels, DIM, DIM])
output = Conv2D(name + '.discriminator1',
n_channels,
DIM,
5,
output,
stride=2)
output = nonlinearity(output)
output = Conv2D(name + '.discriminator2',
DIM,
2 * DIM,
5,
output,
stride=2)
output = nonlinearity(output)
output = Conv2D(name + '.discriminator3',
2 * DIM,
4 * DIM,
5,
output,
stride=2)
output = nonlinearity(output)
output = tf.reshape(output, [-1, 4 * 4 * 4 * DIM])
output = Linear(name + '.Output', 4 * 4 * 4 * DIM, 1, output)
return output
def resnet_decoder(name,
z,
n_channels,
is_training,
mode=None,
nonlinearity=tf.nn.relu):
output = Linear(name + '.Input',
z.get_shape().as_list()[1],
(DIM / 16) * (DIM / 16) * 8 * DIM, z)
output = Normalize(name + '.BN0', [0], output, is_training, mode)
output = nonlinearity(output)
output = tf.reshape(output, [-1, 8 * DIM, (DIM / 16), (DIM / 16)])
output = ResidualBlock(name + '.Res1',
8 * DIM,
8 * DIM,
3,
output,
is_training,
mode,
resample='up',
norm_inputs=True)
output = ResidualBlock(name + '.Res2',
8 * DIM,
4 * DIM,
3,
output,
is_training,
mode,
resample='up')
output = ResidualBlock(name + '.Res3',
4 * DIM,
2 * DIM,
3,
output,
is_training,
mode,
resample='up')
output = ResidualBlock(name + '.Res4',
2 * DIM,
1 * DIM,
3,
output,
is_training,
mode,
resample='up')
output = Normalize(name + '.BN5', [0, 2, 3], output, is_training, mode)
output = nonlinearity(output)
output = Conv2D(name + '.Output', DIM, n_channels, 3, output)
output = tf.reshape(output, [-1, n_channels * DIM * DIM])
return output
def resnet_encoder_new(name,
inputs,
n_channels,
latent_dim,
is_training,
mode=None,
nonlinearity=tf.nn.relu):
output = tf.reshape(inputs, [-1, n_channels, DIM, DIM])
output = Conv2D(name + '.Input',
n_channels,
DIM,
3,
output,
he_init=False,
cpu=CPU)
output = ResidualBlock(name + '.Res1',
DIM,
2 * DIM,
3,
output,
is_training,
mode,
resample='down')
output = ResidualBlock(name + '.Res2',
2 * DIM,
4 * DIM,
3,
output,
is_training,
mode,
resample='down')
output = ResidualBlock(name + '.Res3',
4 * DIM,
8 * DIM,
3,
output,
is_training,
mode,
resample='down')
output = ResidualBlock(name + '.Res4',
8 * DIM,
8 * DIM,
3,
output,
is_training,
mode,
resample='down')
output = Normalize(name + '.BN.5', [0, 2, 3], output, is_training, mode)
output = nonlinearity(output)
output = tf.reshape(output, [-1, 4 * 4 * 8 * DIM])
output = Linear(name + '.Output', 4 * 4 * 8 * DIM, latent_dim, output)
return output
def resnet_encoder(name,
inputs,
n_channels,
latent_dim,
is_training,
mode=None,
nonlinearity=tf.nn.relu):
output = tf.reshape(inputs, [-1, n_channels, DIM, DIM])
#Conv2D(name, input_dim, output_dim, filter_size, inputs, he_init=True, mask_type=None, stride=1, weightnorm=None, biases=True, gain=1., cpu=False):
output = Conv2D(name + '.Input',
n_channels,
DIM,
3,
output,
he_init=False,
cpu=CPU)
output = ResidualBlock(name + '.Res1',
DIM,
2 * DIM,
3,
output,
is_training,
mode,
resample='down')
output = ResidualBlock(name + '.Res2',
2 * DIM,
4 * DIM,
3,
output,
is_training,
mode,
resample='down')
output = ResidualBlock(name + '.Res3',
4 * DIM,
8 * DIM,
3,
output,
is_training,
mode,
resample='down')
output = ResidualBlock(name + '.Res4',
8 * DIM,
8 * DIM,
3,
output,
is_training,
mode,
resample='down')
output = tf.reshape(output, [-1, (DIM / 16) * (DIM / 16) * 8 * DIM]) #
output = Linear(name + '.Output', (DIM / 16) * (DIM / 16) * 8 * DIM,
latent_dim, output)
return output
def resnet_encoder(name,
inputs,
n_channels,
latent_dim,
is_training,
mode=None,
nonlinearity=tf.nn.relu):
#print('in encoder network')
#print inputs.shape
output = tf.reshape(inputs, [-1, n_channels, DIM, DIM])
#print output.shape
output = Conv2D(name + '.Input',
n_channels,
DIM,
3,
output,
he_init=False,
cpu=CPU)
#print output.shape
output = ResidualBlock(name + '.Res1',
DIM,
2 * DIM,
3,
output,
is_training,
mode,
resample='down')
#print output.shape
output = ResidualBlock(name + '.Res2',
2 * DIM,
4 * DIM,
3,
output,
is_training,
mode,
resample='down')
#print output.shape
output = ResidualBlock(name + '.Res3',
4 * DIM,
8 * DIM,
3,
output,
is_training,
mode,
resample='down')
#print output.shape
#output = ResidualBlock(name + '.Res4', 8*DIM, 8*DIM, 3, output, is_training, mode, resample='down')
output = tf.reshape(output, [-1, 4 * 4 * 8 * DIM])
#print output.shape
output = Linear(name + '.Output', 4 * 4 * 8 * DIM, latent_dim, output)
#print output.shape
return output
