def encoder_CNN(inputs,
is_training,
wd=0,
bn=False,
name='encoder_CNN',
init_w=tf.compat.v1.keras.initializers.he_normal()):
# init_w = tf.keras.initializers.he_normal()
layer_dict = {}
layer_dict['cur_input'] = inputs
with tf.variable_scope(name):
arg_scope = tf.contrib.framework.arg_scope
with arg_scope([L.conv],
layer_dict=layer_dict,
bn=bn,
nl=tf.nn.relu,
init_w=init_w,
padding='SAME',
pad_type='ZERO',
is_training=is_training,
wd=0):
L.conv(filter_size=5, out_dim=32, name='conv1', add_summary=False)
L.max_pool(layer_dict, name='pool1')
L.conv(filter_size=3, out_dim=64, name='conv2', add_summary=False)
L.max_pool(layer_dict, name='pool2')
# L.conv(filter_size=3, out_dim=128, name='conv3', add_summary=False)
# L.max_pool(layer_dict, name='pool3')
return layer_dict['cur_input']
def inception_fc(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'] = L.global_avg_pool(layer_dict['cur_input'],
keepdims=True)
# layer_dict['cur_input'] = tf.expand_dims(layer_dict['cur_input'], [1, 2])
L.drop_out(layer_dict, is_training, keep_prob=keep_prob)
L.conv(filter_size=1,
out_dim=n_class,
layer_dict=layer_dict,
pretrained_dict=pretrained_dict,
trainable=trainable,
bn=False,
init_w=init_w,
wd=wd,
is_training=is_training,
name='loss3_classifier')
layer_dict['cur_input'] = tf.squeeze(layer_dict['cur_input'], [1, 2])
return layer_dict['cur_input']
def build_model(self, input_image):
with tf.variable_scope("conv1_1"):
conv1 = conv(input_image, 64)
relu1 = tf.nn.relu(conv1)
with tf.variable_scope("conv1_2"):
conv1 = conv(relu1, 64)
relu1 = tf.nn.relu(conv1)
pool1 = maxpool("pool1", relu1)
with tf.variable_scope("conv2_1"):
conv2 = conv(pool1, 128)
relu2 = tf.nn.relu(conv2)
with tf.variable_scope("conv2_2"):
conv2 = conv(relu2, 128)
relu2 = tf.nn.relu(conv2)
pool2 = maxpool("pool2", relu2)
with tf.variable_scope("conv3_1"):
conv3 = conv(pool2, 256)
relu3 = tf.nn.relu(conv3)
with tf.variable_scope("conv3_2"):
conv3 = conv(relu3, 256)
relu3 = tf.nn.relu(conv3)
pool3 = maxpool("pool3", relu3)
with tf.variable_scope("conv4_1"):
conv4 = conv(pool3, 256)
relu4 = tf.nn.relu(conv4)
with tf.variable_scope("conv4_2"):
conv4 = conv(relu4, 256)
relu4 = tf.nn.relu(conv4)
pool4 = maxpool("pool3", relu4)
with tf.variable_scope('fc1'):
fc1 = fc(pool4, 256)
fc1 = tf.nn.relu(fc1)
if self.is_training:
fc1 = dropout(fc1, self.keep_prob)
with tf.variable_scope('fc2'):
out = fc(fc1, self.num_class)
self.feature_map = {
"conv1": conv1,
"conv3": conv3,
"pool1": pool1,
"pool3": pool3
}
self.logits = out
return out
def vgg_small_fc(layer_dict,
n_class,
keep_prob,
inputs=None,
pretrained_dict=None,
bn=False,
init_w=None,
trainable=True,
is_training=True,
wd=0):
if inputs is not None:
layer_dict['cur_input'] = inputs
arg_scope = tf.contrib.framework.arg_scope
with arg_scope([L.conv],
layer_dict=layer_dict,
pretrained_dict=pretrained_dict,
init_w=init_w,
trainable=trainable,
is_training=is_training,
wd=wd,
add_summary=False,
padding='VALID'):
L.conv(filter_size=1, out_dim=1024, nl=tf.nn.relu, name='fc6', bn=bn)
L.drop_out(layer_dict, is_training, keep_prob=keep_prob)
L.conv(filter_size=1, out_dim=1024, nl=tf.nn.relu, name='fc7', bn=bn)
L.drop_out(layer_dict, is_training, keep_prob=keep_prob)
L.conv(filter_size=1, out_dim=n_class, name='fc8', bn=False)
return layer_dict['cur_input']
def inception_conv_layers_cifar(layer_dict,
inputs=None,
pretrained_dict=None,
bn=False,
wd=0,
init_w=None,
is_training=True,
trainable=True,
conv_stride=2):
if inputs is None:
inputs = layer_dict['cur_input']
layer_dict['cur_input'] = inputs
arg_scope = tf.contrib.framework.arg_scope
with arg_scope([L.conv],
layer_dict=layer_dict,
pretrained_dict=pretrained_dict,
bn=bn,
nl=tf.nn.relu,
init_w=init_w,
trainable=trainable,
is_training=is_training,
wd=wd,
add_summary=False):
L.conv(7, 64, name='conv1_7x7_s2', stride=conv_stride)
# L.max_pool(layer_dict=layer_dict, stride=2,
# filter_size=3, padding='VALID', name='pool1')
L.conv(1, 64, name='conv2_3x3_reduce')
L.conv(3, 192, name='conv2_3x3')
# L.max_pool(layer_dict=layer_dict, stride=2,
# filter_size=3, padding='VALID', name='pool2')
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):
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 res_block(layer_dict,
n1=512,
n2=128,
init_w=None,
wd=0,
bn=True,
is_training=True,
name='res_block'):
with tf.variable_scope(name):
inputs = layer_dict['cur_input']
arg_scope = tf.contrib.framework.arg_scope
with arg_scope([L.conv],
layer_dict=layer_dict,
bn=bn,
init_w=init_w,
is_training=is_training,
wd=wd):
L.conv(filter_size=3,
out_dim=n1,
nl=L.leaky_relu,
padding='SAME',
name='conv1')
L.conv(filter_size=3, out_dim=n2, padding='SAME', name='conv2')
res_out = layer_dict['cur_input']
if n1 != n2:
inputs = L.conv(inputs=inputs,
filter_size=1,
out_dim=n2,
padding='SAME',
name='shortcut')
outputs = inputs + res_out
layer_dict['cur_input'] = L.leaky_relu(outputs)
return layer_dict['cur_input']
def res_block_bottleneck(n1,
n2,
n3,
layer_dict,
init_w=None,
wd=0,
bn=True,
is_training=True,
name='res_block_bottleneck'):
# Deep residual learning for image recognition
# bottleneck version (Fig5 right)
with tf.variable_scope(name):
inputs = layer_dict['cur_input']
arg_scope = tf.contrib.framework.arg_scope
with arg_scope([L.conv],
layer_dict=layer_dict,
bn=bn,
init_w=init_w,
is_training=is_training,
wd=wd):
L.conv(filter_size=1,
out_dim=n2,
nl=L.leaky_relu,
padding='SAME',
name='conv1')
L.conv(filter_size=3,
out_dim=n2,
nl=L.leaky_relu,
padding='SAME',
name='conv2')
L.conv(filter_size=1, out_dim=n3, padding='SAME', name='conv3')
res_out = layer_dict['cur_input']
if n1 != n3:
inputs = L.conv(inputs=inputs,
filter_size=1,
out_dim=n3,
padding='SAME',
name='shortcut')
outputs = inputs + res_out
layer_dict['cur_input'] = L.leaky_relu(outputs)
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 vgg16_conv(layer_dict,
keep_prob,
inputs=None,
pretrained_dict=None,
bn=False,
init_w=None,
trainable=True,
is_training=True,
wd=0):
if inputs is not None:
layer_dict['cur_input'] = inputs
arg_scope = tf.contrib.framework.arg_scope
with arg_scope([L.conv],
layer_dict=layer_dict,
pretrained_dict=pretrained_dict,
bn=bn,
nl=tf.nn.relu,
init_w=init_w,
trainable=trainable,
is_training=is_training,
wd=wd,
add_summary=False):
L.conv(filter_size=3, out_dim=64, name='conv1_1')
L.conv(filter_size=3, out_dim=64, name='conv1_2')
L.max_pool(layer_dict, name='pool1')
L.drop_out(layer_dict, is_training, keep_prob=keep_prob)
L.conv(filter_size=3, out_dim=128, name='conv2_1')
L.conv(filter_size=3, out_dim=128, name='conv2_2')
L.max_pool(layer_dict, name='pool2')
L.drop_out(layer_dict, is_training, keep_prob=keep_prob)
L.conv(filter_size=3, out_dim=256, name='conv3_1')
L.conv(filter_size=3, out_dim=256, name='conv3_2')
L.conv(filter_size=3, out_dim=256, name='conv3_3')
L.max_pool(layer_dict, name='pool3')
L.drop_out(layer_dict, is_training, keep_prob=keep_prob)
L.conv(filter_size=3, out_dim=512, name='conv4_1')
L.conv(filter_size=3, out_dim=512, name='conv4_2')
L.conv(filter_size=3, out_dim=512, name='conv4_3')
L.max_pool(layer_dict, name='pool4')
L.drop_out(layer_dict, is_training, keep_prob=keep_prob)
L.conv(filter_size=3, out_dim=512, name='conv5_1')
L.conv(filter_size=3, out_dim=512, name='conv5_2')
L.conv(filter_size=3, out_dim=512, name='conv5_3')
L.max_pool(layer_dict, name='pool5')
L.drop_out(layer_dict, is_training, keep_prob=keep_prob)
return layer_dict['cur_input']
def inception_conv_layers(layer_dict,
inputs=None,
pretrained_dict=None,
bn=False,
wd=0,
init_w=None,
is_training=True,
trainable=True,
conv_stride=2):
if inputs is None:
inputs = layer_dict['cur_input']
layer_dict['cur_input'] = inputs
arg_scope = tf.contrib.framework.arg_scope
with arg_scope([L.conv],
layer_dict=layer_dict,
pretrained_dict=pretrained_dict,
bn=bn,
nl=tf.nn.relu,
init_w=init_w,
trainable=trainable,
is_training=is_training,
wd=wd,
add_summary=False):
conv1 = L.conv(7,
64,
inputs=inputs,
name='conv1_7x7_s2',
stride=conv_stride)
padding1 = tf.constant([[0, 0], [0, 1], [0, 1], [0, 0]])
conv1_pad = tf.pad(conv1, padding1, 'CONSTANT')
pool1, _ = L.max_pool(layer_dict=layer_dict,
inputs=conv1_pad,
stride=2,
filter_size=3,
padding='VALID',
name='pool1')
pool1_lrn = tf.nn.local_response_normalization(pool1,
depth_radius=2,
alpha=2e-05,
beta=0.75,
name='pool1_lrn')
conv2_reduce = L.conv(1, 64, inputs=pool1_lrn, name='conv2_3x3_reduce')
conv2 = L.conv(3, 192, inputs=conv2_reduce, name='conv2_3x3')
padding2 = tf.constant([[0, 0], [0, 1], [0, 1], [0, 0]])
conv2_pad = tf.pad(conv2, padding2, 'CONSTANT')
pool2, _ = L.max_pool(layer_dict=layer_dict,
inputs=conv2_pad,
stride=2,
filter_size=3,
padding='VALID',
name='pool2')
pool2_lrn = tf.nn.local_response_normalization(pool2,
depth_radius=2,
alpha=2e-05,
beta=0.75,
name='pool2_lrn')
layer_dict['cur_input'] = pool2_lrn
return pool2_lrn
def inception_layer(conv_11_size,
conv_33_reduce_size,
conv_33_size,
conv_55_reduce_size,
conv_55_size,
pool_size,
layer_dict,
inputs=None,
bn=False,
wd=0,
init_w=None,
pretrained_dict=None,
trainable=True,
is_training=True,
name='inception'):
if inputs is None:
inputs = layer_dict['cur_input']
layer_dict['cur_input'] = inputs
arg_scope = tf.contrib.framework.arg_scope
with arg_scope([L.conv],
layer_dict=layer_dict,
pretrained_dict=pretrained_dict,
bn=bn,
nl=tf.nn.relu,
init_w=init_w,
trainable=trainable,
is_training=is_training,
wd=wd,
add_summary=False):
conv_11 = L.conv(filter_size=1,
out_dim=conv_11_size,
inputs=inputs,
name='{}_1x1'.format(name))
L.conv(filter_size=1,
out_dim=conv_33_reduce_size,
inputs=inputs,
name='{}_3x3_reduce'.format(name))
conv_33 = L.conv(filter_size=3,
out_dim=conv_33_size,
name='{}_3x3'.format(name))
L.conv(filter_size=1,
out_dim=conv_55_reduce_size,
inputs=inputs,
name='{}_5x5_reduce'.format(name))
conv_55 = L.conv(filter_size=5,
out_dim=conv_55_size,
name='{}_5x5'.format(name))
L.max_pool(layer_dict=layer_dict,
inputs=inputs,
stride=1,
filter_size=3,
padding='SAME',
name='{}_pool'.format(name))
convpool = L.conv(filter_size=1,
out_dim=pool_size,
name='{}_pool_proj'.format(name))
output = tf.concat([conv_11, conv_33, conv_55, convpool],
3,
name='{}_concat'.format(name))
layer_dict['cur_input'] = output
layer_dict[name] = output
return output
