def sample_latent(self):
with tf.variable_scope('sample_latent'):
cnn_out = self.layers['encoder_out']
z_mean = L.linear(
out_dim=self._n_code, layer_dict=self.layers,
inputs=cnn_out, init_w=INIT_W, wd=self._wd, name='latent_mean')
z_std = L.linear(
out_dim=self._n_code, layer_dict=self.layers, nl=L.softplus,
inputs=cnn_out, init_w=INIT_W, wd=self._wd, name='latent_std')
z_log_std = tf.log(z_std + 1e-8)
b_size = tf.shape(cnn_out)[0]
z = ops.tf_sample_diag_guassian(z_mean, z_std, b_size, self._n_code)
return z, z_mean, z_std, z_log_std
def encoder_FC(inputs, is_training, n_hidden=1000, nl=tf.nn.relu,
keep_prob=0.5, wd=0, name='encoder_FC', init_w=None):
layer_dict = {}
layer_dict['cur_input'] = inputs
with tf.variable_scope(name):
arg_scope = tf.contrib.framework.arg_scope
with arg_scope([L.linear],
out_dim=n_hidden, layer_dict=layer_dict, init_w=init_w,
wd=wd):
L.linear(name='linear1', nl=nl)
L.drop_out(layer_dict, is_training, keep_prob=keep_prob)
L.linear(name='linear2', nl=nl)
L.drop_out(layer_dict, is_training, keep_prob=keep_prob)
return layer_dict['cur_input']
def decoder(self, inputs):
with tf.variable_scope('decoder'):
# out_h = int(self._im_size[0] / 4)
# out_w = int(self._im_size[1] / 4)
# out_dim = out_h * out_w * 64
# z_linear = L.linear(
# out_dim=out_dim, layer_dict=self.layers, nl=tf.nn.relu,
# inputs=inputs, init_w=INIT_W, wd=self._wd, name='z_linear')
# z_linear = tf.reshape(z_linear, (-1, out_h, out_w, 64))
# decoder_out = modules.decoder_CNN(
# z_linear, is_training=self.is_training, out_channel=self._n_channel,
# wd=self._wd, bn=False, name='decoder_CNN')
fc_out = modules.decoder_FC(inputs,
self.is_training,
keep_prob=self.keep_prob,
wd=self._wd,
name='decoder_FC',
init_w=INIT_W)
out_dim = self._im_size[0] * self._im_size[1] * self._n_channel
decoder_out = L.linear(out_dim=out_dim,
layer_dict=self.layers,
inputs=fc_out,
init_w=None,
wd=self._wd,
name='decoder_linear')
decoder_out = tf.reshape(
decoder_out,
(-1, self._im_size[0], self._im_size[1], self._n_channel))
return decoder_out
def cls_layer(self, encoder_out):
""" estimate digit label for semi-supervised model """
cls_logits = L.linear(out_dim=self.n_class,
layer_dict=self.layers,
inputs=encoder_out,
init_w=INIT_W,
wd=self._wd,
name='cls_layer')
return cls_logits
def decoder(self, inputs):
with tf.variable_scope('decoder'):
fc_out = modules.decoder_FC(
inputs, self.is_training, keep_prob=self.keep_prob,
wd=self._wd, name='decoder_FC', init_w=INIT_W)
out_dim = self._im_size[0] * self._im_size[1] * self._n_channel
decoder_out = L.linear(
out_dim=out_dim, layer_dict=self.layers,
inputs=fc_out, init_w=None, wd=self._wd, name='decoder_linear')
decoder_out = tf.reshape(
decoder_out, (-1, self._im_size[0], self._im_size[1], self._n_channel))
return tf.tanh(decoder_out)
def _create_model(self, inputs):
self.layers['cur_input'] = inputs
with tf.variable_scope('embedding_net', reuse=tf.AUTO_REUSE):
arg_scope = tf.contrib.framework.arg_scope
with arg_scope([L.conv, L.linear],
layer_dict=self.layers,
bn=True,
init_w=INIT_W,
is_training=self.is_training,
wd=WD):
L.conv(filter_size=5,
out_dim=32,
nl=tf.nn.relu,
padding='SAME',
name='conv1')
L.max_pool(layer_dict=self.layers,
padding='SAME',
name='max_pool1')
L.conv(filter_size=5,
out_dim=64,
nl=tf.nn.relu,
padding='SAME',
name='conv2')
L.max_pool(layer_dict=self.layers,
padding='SAME',
name='max_pool2')
L.linear(
out_dim=256,
name='linear1',
nl=tf.nn.relu,
)
L.linear(out_dim=self.embedding_dim, bn=False, name='linear2')
return self.layers['cur_input']
def discriminator_FC(inputs, is_training, n_hidden=1000, nl=tf.nn.relu,
wd=0, name='discriminator_FC', init_w=None):
layer_dict = {}
layer_dict['cur_input'] = inputs
with tf.variable_scope(name):
arg_scope = tf.contrib.framework.arg_scope
with arg_scope([L.linear],
layer_dict=layer_dict, init_w=init_w,
wd=wd):
L.linear(name='linear1', nl=nl, out_dim=n_hidden)
L.linear(name='linear2', nl=nl, out_dim=n_hidden)
L.linear(name='output', out_dim=1)
return layer_dict['cur_input']
def auxiliary_classifier(layer_dict,
n_class,
keep_prob=1.,
inputs=None,
pretrained_dict=None,
is_training=True,
bn=False,
init_w=None,
trainable=True,
wd=0):
if inputs is not None:
layer_dict['cur_input'] = inputs
# layer_dict['cur_input'] = tf.layers.average_pooling2d(
# inputs=layer_dict['cur_input'],
# pool_size=5, strides=3,
# padding='valid', name='averagepool')
layer_dict['cur_input'] = L.global_avg_pool(layer_dict['cur_input'],
keepdims=True)
arg_scope = tf.contrib.framework.arg_scope
with arg_scope([L.conv, L.linear],
layer_dict=layer_dict,
bn=bn,
init_w=init_w,
trainable=trainable,
is_training=is_training,
wd=wd,
add_summary=False):
L.conv(1, 128, name='conv', stride=1, nl=tf.nn.relu)
L.linear(out_dim=512, name='fc_1', nl=tf.nn.relu)
L.drop_out(layer_dict, is_training, keep_prob=keep_prob)
L.linear(out_dim=512, name='fc_2', nl=tf.nn.relu)
L.drop_out(layer_dict, is_training, keep_prob=keep_prob)
L.linear(out_dim=n_class, name='classifier', bn=False)
return layer_dict['cur_input']
def _create_model(self, inputs):
with tf.variable_scope('LuNet', reuse=tf.AUTO_REUSE):
self.layers['cur_input'] = inputs
arg_scope = tf.contrib.framework.arg_scope
with arg_scope([
L.conv, L.linear, resblock.res_block_bottleneck,
resblock.res_block
],
layer_dict=self.layers,
bn=True,
init_w=INIT_W,
is_training=self.is_training,
wd=WD):
with tf.variable_scope('block_1'):
L.conv(filter_size=7,
out_dim=128,
nl=L.leaky_relu,
padding='SAME',
name='conv1')
resblock.res_block_bottleneck(128,
32,
128,
name='resblock1')
L.max_pool(layer_dict=self.layers,
filter_size=3,
stride=2,
padding='SAME',
name='max_pool1')
with tf.variable_scope('block_2'):
resblock.res_block_bottleneck(128,
32,
128,
name='resblock1')
resblock.res_block_bottleneck(128,
32,
128,
name='resblock2')
resblock.res_block_bottleneck(128,
64,
256,
name='resblock3')
L.max_pool(layer_dict=self.layers,
filter_size=3,
stride=2,
padding='SAME',
name='max_pool1')
with tf.variable_scope('block_3'):
resblock.res_block_bottleneck(256,
64,
256,
name='resblock1')
resblock.res_block_bottleneck(256,
64,
256,
name='resblock2')
L.max_pool(layer_dict=self.layers,
filter_size=3,
stride=2,
padding='SAME',
name='max_pool1')
with tf.variable_scope('block_4'):
resblock.res_block_bottleneck(256,
64,
256,
name='resblock1')
resblock.res_block_bottleneck(256,
64,
256,
name='resblock2')
resblock.res_block_bottleneck(256,
128,
512,
name='resblock3')
L.max_pool(layer_dict=self.layers,
filter_size=3,
stride=2,
padding='SAME',
name='max_pool1')
with tf.variable_scope('block_5'):
resblock.res_block_bottleneck(512,
128,
512,
name='resblock1')
resblock.res_block_bottleneck(512,
128,
512,
name='resblock2')
L.max_pool(layer_dict=self.layers,
filter_size=3,
stride=2,
padding='SAME',
name='max_pool1')
with tf.variable_scope('block_6'):
resblock.res_block(n1=512, n2=128, name='res_block1')
L.linear(out_dim=512, nl=L.leaky_relu, name='linear1')
L.linear(out_dim=self.embedding_dim, name='linear2')
return self.layers['cur_input']
def generator(self, inputs):
with tf.variable_scope('generator', reuse=tf.AUTO_REUSE):
self.layers['cur_input'] = inputs
b_size = tf.shape(inputs)[0]
d_height_2, d_width_2 = L.deconv_size(self.im_h, self.im_w)
d_height_4, d_width_4 = L.deconv_size(d_height_2, d_width_2)
d_height_8, d_width_8 = L.deconv_size(d_height_4, d_width_4)
d_height_16, d_width_16 = L.deconv_size(d_height_8, d_width_8)
L.linear(out_dim=d_height_16 * d_width_16 * 256,
layer_dict=self.layers,
init_w=INIT_W,
wd=0,
bn=True,
is_training=self.is_training,
name='Linear',
nl=tf.nn.relu)
self.layers['cur_input'] = tf.reshape(
self.layers['cur_input'], [-1, d_height_16, d_width_16, 256])
arg_scope = tf.contrib.framework.arg_scope
with arg_scope([L.transpose_conv],
filter_size=3,
layer_dict=self.layers,
init_w=INIT_W,
wd=0,
is_training=self.is_training):
output_shape = [b_size, d_height_8, d_width_8, 256]
L.transpose_conv(out_shape=output_shape,
stride=2,
bn=True,
nl=tf.nn.relu,
name='dconv1')
L.transpose_conv(out_shape=output_shape,
stride=1,
bn=True,
nl=tf.nn.relu,
name='dconv2')
L.drop_out(self.layers,
self.is_training,
keep_prob=self.keep_prob)
output_shape = [b_size, d_height_4, d_width_4, 256]
L.transpose_conv(out_shape=output_shape,
stride=2,
bn=True,
nl=tf.nn.relu,
name='dconv3')
L.transpose_conv(out_shape=output_shape,
stride=1,
bn=True,
nl=tf.nn.relu,
name='dconv4')
L.drop_out(self.layers,
self.is_training,
keep_prob=self.keep_prob)
output_shape = [b_size, d_height_2, d_width_2, 128]
L.transpose_conv(out_shape=output_shape,
stride=2,
bn=True,
nl=tf.nn.relu,
name='dconv5')
output_shape = [b_size, self.im_h, self.im_w, 64]
L.transpose_conv(out_shape=output_shape,
stride=2,
bn=True,
nl=tf.nn.relu,
name='dconv6')
L.drop_out(self.layers,
self.is_training,
keep_prob=self.keep_prob)
output_shape = [b_size, self.im_h, self.im_w, self.n_channels]
L.transpose_conv(out_shape=output_shape,
stride=1,
bn=False,
nl=tf.tanh,
name='dconv7')
return self.layers['cur_input']
