def SemanticFeatureGenerationBlock(inputs, D_features, D_prime_features, O_features, bottleneck_factor=2, cardinality=32):
d_1 = ConvBlock(inputs, D_features, kernel_size=[3, 3])
pool_1 = slim.pool(d_1, [5, 5], stride=[1, 1], pooling_type='MAX')
d_prime_1 = ConvBlock(pool_1, D_prime_features, kernel_size=[3, 3])
d_2 = ConvBlock(pool_1, D_features, kernel_size=[3, 3])
pool_2 = slim.pool(d_2, [5, 5], stride=[1, 1], pooling_type='MAX')
d_prime_2 = ConvBlock(pool_2, D_prime_features, kernel_size=[3, 3])
d_3 = ConvBlock(pool_2, D_features, kernel_size=[3, 3])
pool_3 = slim.pool(d_3, [5, 5], stride=[1, 1], pooling_type='MAX')
d_prime_3 = ConvBlock(pool_3, D_prime_features, kernel_size=[3, 3])
d_4 = ConvBlock(pool_3, D_features, kernel_size=[3, 3])
pool_4 = slim.pool(d_4, [5, 5], stride=[1, 1], pooling_type='MAX')
d_prime_4 = ConvBlock(pool_4, D_prime_features, kernel_size=[3, 3])
net = tf.concat([d_prime_1, d_prime_2, d_prime_3, d_prime_4], axis=-1)
net = ConvBlock(net, n_filters=D_features, kernel_size=[3, 3])
net = ResNeXtBlock(net, n_filters_out=D_features, bottleneck_factor=bottleneck_factor)
net = ResNeXtBlock(net, n_filters_out=D_features, bottleneck_factor=bottleneck_factor)
net = ResNeXtBlock(net, n_filters_out=D_features, bottleneck_factor=bottleneck_factor)
net = ResNeXtBlock(net, n_filters_out=D_features, bottleneck_factor=bottleneck_factor)
net = ConvBlock(net, O_features, kernel_size=[3, 3])
return net
def vggm1234(x, TRAIN_COVN=True):
net = slim.convolution(x,
96, [7, 7],
2,
padding='VALID',
scope='conv1',
activation_fn=tf.nn.relu,
reuse=tf.AUTO_REUSE,
trainable=TRAIN_COVN)
net = tf.nn.lrn(net, depth_radius=5, bias=2, alpha=1e-4 * 1, beta=0.75)
net = slim.pool(net, [3, 3],
'MAX',
stride=2,
padding='VALID',
scope='pool1')
net = slim.convolution(net,
256, [5, 5],
2,
padding='VALID',
scope='conv2',
activation_fn=tf.nn.relu,
reuse=tf.AUTO_REUSE,
trainable=TRAIN_COVN)
net = tf.nn.lrn(net, depth_radius=5, bias=2, alpha=1e-4 * 1, beta=0.75)
net = slim.pool(net, [3, 3],
'MAX',
stride=2,
padding='VALID',
scope='pool2')
net = slim.convolution(net,
512, [3, 3],
1,
padding='VALID',
scope='conv3',
activation_fn=tf.nn.relu,
reuse=tf.AUTO_REUSE,
trainable=TRAIN_COVN)
net = slim.convolution(net,
512, [3, 3],
1,
padding='VALID',
scope='conv4',
activation_fn=tf.nn.relu,
reuse=tf.AUTO_REUSE,
trainable=TRAIN_COVN)
return U.flattenallbut0(net)
def create_model(self, model_input, vocab_size, num_frames, **unused_params):
output = model_input
output = slim.convolution(output, 1024, [3], stride = 1, padding = "SAME")
output = slim.convolution(output, 1024, [3], stride = 1, padding = "SAME")
# output = slim.convolution(output, 512, [3], stride = 1, padding = "SAME")
output = tf.contrib.layers.batch_norm(output,center = True, scale = True, is_training = True, scope = None)
output = slim.pool(output, [2], "MAX", stride = 2)
# output = slim.convolution(output, 512, [3], stride = 1, padding = "SAME")
output = slim.convolution(output, 1024, [3], stride = 1, padding = "SAME")
output = slim.convolution(output, 1024, [3], stride = 1, padding = "SAME")
output = tf.contrib.layers.batch_norm(output,center = True, scale = True, is_training = True, scope = None)
output = slim.pool(output, [2], "MAX", stride = 2)
output = slim.convolution(output, 1024, [3], stride = 1, padding = "SAME")
output = slim.convolution(output, 1024, [3], stride = 1, padding = "SAME")
output = slim.convolution(output, 1024, [3], stride = 1, padding = "SAME")
output = tf.contrib.layers.batch_norm(output,center = True, scale = True, is_training = True, scope = None)
output = slim.pool(output, [3], "MAX", stride = 2)
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
output = tf.contrib.layers.batch_norm(output,center = True, scale = True, is_training = True, scope = None)
output = slim.pool(output, [3], "MAX", stride=2)
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
output = tf.contrib.layers.batch_norm(output,center = True, scale = True, is_training = True, scope = None)
output = slim.pool(output, [2], "MAX", stride=2)
output = slim.flatten(output)
output = slim.fully_connected(output, 4096)
output = tf.contrib.layers.batch_norm(output,center = True, scale = True, is_training = True, scope = None)
output = slim.dropout(output)
output = slim.fully_connected(output, 4096)
output = tf.contrib.layers.batch_norm(output,center = True, scale = True, is_training = True, scope = None)
output = slim.dropout(output)
output = slim.fully_connected(output, vocab_size, activation_fn = tf.nn.sigmoid)
return {"predictions": output}
def netD_discriminator_adloss_32(image_input, reuse=False):
with tf.variable_scope('discriminator', reuse=reuse) as vs:
kernel_size = [3, 3]
filter_num = 64
imageshape = image_input.get_shape().as_list()[1]
with slim.arg_scope([slim.conv2d], normalizer_fn=slim.batch_norm, activation_fn=tf.nn.elu, padding='SAME',
weights_initializer=tf.truncated_normal_initializer(stddev=0.02)):
# 224/96/32
net = slim.conv2d(image_input, filter_num, kernel_size, normalizer_fn=None, scope='conv1')
net = slim.conv2d(net, filter_num * 2, kernel_size, scope='conv2')
# 112/48/16
net = slim.conv2d(net, filter_num * 2, stride=2, kernel_size=kernel_size, scope='conv3')
net = slim.conv2d(net, filter_num * 2, kernel_size, scope='conv4')
# 56/24/8
net = slim.conv2d(net, filter_num * 4, stride=2, kernel_size=kernel_size, scope='conv6')
net = slim.conv2d(net, filter_num * 4, kernel_size, scope='conv7')
# 28/12/4
net = slim.conv2d(net, filter_num * 6, stride=2, kernel_size=kernel_size, scope='conv9')
net = slim.conv2d(net, filter_num * 6, kernel_size, scope='conv10')
# 14/6/2
net = slim.conv2d(net, filter_num * 8, stride=2, kernel_size=kernel_size, scope='conv12')
net = slim.conv2d(net, filter_num * 8, kernel_size, scope='conv13')
avgpool = slim.pool(net, [int(imageshape / 16), int(imageshape / 16)], stride=int(imageshape / 32),
pooling_type="AVG", scope='avgpool')
adlogits = slim.fully_connected(slim.flatten(avgpool), 1, activation_fn=None, normalizer_fn=None,
weights_initializer=tf.truncated_normal_initializer(stddev=0.02),
scope='ad_soft')
return adlogits
def FullResolutionResidualUnit(pool_stream, res_stream, n_filters_3, n_filters_1, pool_scale):
"""
A full resolution residual unit
Arguments:
pool_stream: The inputs from the pooling stream
res_stream: The inputs from the residual stream
n_filters_3: Number of output feature maps for each 3x3 conv
n_filters_1: Number of output feature maps for each 1x1 conv
pool_scale: scale of the pooling layer i.e window size and stride
Returns:
Output of full resolution residual block
"""
G = tf.concat([pool_stream, slim.pool(res_stream, [pool_scale, pool_scale], stride=[pool_scale, pool_scale], pooling_type='MAX')], axis=-1)
net = slim.conv2d(G, n_filters_3, kernel_size=3, activation_fn=None)
net = slim.batch_norm(net)
net = tf.nn.relu(net)
net = slim.conv2d(net, n_filters_3, kernel_size=3, activation_fn=None)
net = slim.batch_norm(net)
pool_stream_out = tf.nn.relu(net)
net = slim.conv2d(pool_stream_out, n_filters_1, kernel_size=1, activation_fn=None)
net = Upsampling(net, scale=pool_scale)
res_stream_out = tf.add(res_stream, net)
return pool_stream_out, res_stream_out
def FullResolutionResidualUnit(pool_stream, res_stream, n_filters_3,
n_filters_1, pool_scale):
G = tf.concat([
pool_stream,
slim.pool(res_stream, [pool_scale, pool_scale],
stride=[pool_scale, pool_scale],
pooling_type='MAX')
],
axis=-1)
net = slim.conv2d(G, n_filters_3, kernel_size=3, activation_fn=None)
net = slim.batch_norm(net, fused=True)
net = tf.nn.relu(net)
net = slim.conv2d(net, n_filters_3, kernel_size=3, activation_fn=None)
net = slim.batch_norm(net, fused=True)
pool_stream_out = tf.nn.relu(net)
net = slim.conv2d(pool_stream_out,
n_filters_1,
kernel_size=1,
activation_fn=None)
net = Upsampling(net, scale=pool_scale)
res_stream_out = tf.add(res_stream, net)
return pool_stream_out, res_stream_out
def CoRLModel(inputs, num_actions, scope, reuse=False):
with tf.variable_scope(scope, reuse=reuse):
activation = tf.nn.tanh
convs1 = [
[8, [3, 3], 1],
[16, [3, 3], 1],
]
pool1 = [[[2, 2], 2]]
convs2 = [
[16, [3, 3], 1],
[8, [3, 3], 1],
]
pool2 = [[[2, 2], 2]]
hidden = 3528
net = inputs
out_size, kernel, stride = convs1[0]
net = slim.conv2d(net, out_size, kernel, stride, scope="conv1/conv3_1")
out_size, kernel, stride = convs1[1]
net = slim.conv2d(net, out_size, kernel, stride, scope="conv1/conv3_2")
kernel, stride = pool1[0]
net = slim.pool(net, kernel, "MAX", stride=stride, scope="pool1")
#--------
out_size, kernel, stride = convs2[0]
net = slim.conv2d(net, out_size, kernel, stride, scope="conv2/conv3_1")
out_size, kernel, stride = convs2[1]
net = slim.conv2d(net, out_size, kernel, stride, scope="conv2/conv3_2")
kernel, stride = pool2[0]
net = slim.pool(net, kernel, "MAX", stride=stride, scope="pool2")
net = tf.squeeze(net)
net = tf.reshape(net, [-1, 21, 21, 8])
#Flatten pool layer
net = slim.flatten(net, scope="flatten3")
#--------
net = slim.fully_connected(
net,
hidden,
weights_initializer=xavier_initializer(uniform=False),
activation_fn=activation,
scope="fc4")
net = slim.fully_connected(
net,
num_actions,
weights_initializer=xavier_initializer(uniform=False),
activation_fn=None,
scope="y")
return net
def TransitionDown(inputs, n_filters, dropout_p=0.2, scope=None):
with tf.name_scope(scope) as sc:
l = preact_conv(inputs,
n_filters,
filter_size=[1, 1],
dropout_p=dropout_p)
l = slim.pool(l, [2, 2], stride=[2, 2], pooling_type='MAX')
return l
def TransitionDown(inputs, n_filters, dropout_p=0.2, scope=None):
"""
Transition Down (TD) for FC-DenseNet
Apply 1x1 BN + ReLU + conv then 2x2 max pooling
"""
with tf.name_scope(scope) as sc:
l = preact_conv(inputs, n_filters, kernel_size=[1, 1], dropout_p=dropout_p)
l = slim.pool(l, [2, 2], stride=[2, 2], pooling_type='MAX')
return l
def conv_block(self, inputs, no_convs=1, filters=1, kernel_size=[2, 2], dropout=0.0):
# Define i conv layers followed by relu and dropout (if not set to 0.0)
for i in range(0, no_convs):
inputs = slim.conv2d(inputs, filters, kernel_size, activation_fn=None, normalizer_fn=None)
inputs = tf.nn.relu(slim.batch_norm(inputs))
if dropout != 0.0:
inputs = slim.dropout(inputs, keep_prob=dropout)
# Define pooling after conv block
inputs = slim.pool(inputs, [2, 2], stride=[2, 2], pooling_type='MAX')
return inputs
def pool_layer(self, inputs, pool_size=2, n_filters=64, stride=2, _type='MAX', method='pool'):
if method == 'pool':
if _type == 'MAX':
out = slim.pool(inputs, [pool_size, pool_size], stride=[stride, stride], pooling_type=_type)
else:
out = slim.avg_pool2d(inputs, [pool_size, pool_size], stride=[stride, stride])
else:
out = slim.conv2d(inputs, n_filters, kernel_size=[1, 1], stride=[2, 2])
return out
def build_AUnet(inputs, n_classes):
n_filters = 64
net_1 = ConvBlock(inputs, n_filters)
net = slim.pool(net_1, [2, 2], stride=[2, 2], pooling_type='MAX')
net_2 = ConvBlock(net, n_filters * 2)
net = slim.pool(net_2, [2, 2], stride=[2, 2], pooling_type='MAX')
net_3 = ConvBlock(net, n_filters * 4)
net = slim.pool(net_3, [2, 2], stride=[2, 2], pooling_type='MAX')
net_4 = ConvBlock(net, n_filters * 8, third=False)
net = slim.pool(net_4, [2, 2], stride=[2, 2], pooling_type='MAX')
net_5 = ConvBlock(net, n_filters * 16)
#net = slim.pool(net, [2, 2], stride=[2, 2], pooling_type='MAX')
#pooled =
# Attention Mechanism
net_5 = UpBlock(net, 8 * n_filters)
net = attention(net_4, net_5, 8 * n_filters)
net = concat(net_4, net_5)
net = ConvBlock(net, 8 * n_filters)
up_3 = UpBlock(net, 4 * n_filters)
net = attention(net_3, up_3, 4 * n_filters)
net = concat(up_3, net)
net = ConvBlock(net, 4 * n_filters)
up_2 = UpBlock(net, 2 * n_filters)
net = attention(net_2, up_2, 2 * n_filters)
net = concat(up_2, net)
net = ConvBlock(net, 2 * n_filters)
up_1 = UpBlock(net, n_filters)
net = attention(net_1, up_1, n_filters)
net = concat(up_1, net)
net = ConvBlock(net, n_filters)
net = conv2d(net, n_classes, kernel_size=[1, 1], activation_fn=None)
return net
def __init__(self):
self.X = tf.placeholder(tf.float32, [None, 28, 28, 3])
with tf.variable_scope('classifier', reuse=tf.AUTO_REUSE) as scope:
y_ = slim.conv2d(inputs=self.X,
num_outputs=32,
kernel_size=3,
stride=1,
activation_fn=tf.nn.relu)
y_ = slim.pool(y_, kernel_size=2, pooling_type='MAX')
y_ = slim.conv2d(y_,
num_outputs=64,
kernel_size=3,
stride=1,
activation_fn=tf.nn.relu)
y_ = slim.pool(y_, kernel_size=2, pooling_type='MAX')
y_ = slim.flatten(y_)
y_ = tf.layers.dense(y_, 512, activation=tf.nn.relu)
y_ = tf.layers.dense(y_, 512, activation=tf.nn.relu)
self.y_pred = tf.layers.dense(y_, 14)
def adapPooling(inputs, outputsize=1, _type='MAX'):
shape = K.int_shape(inputs)
h, w, ch = shape
stride = np.floor(h/outputsize).astype(np.int32)
kernel = h - (outputsize-1) * stride
if _type == 'MAX':
adapPooling = slim.pool(inputs, [kernel, kernel], stride=[stride, stride], pooling_type='MAX')
else:
adapPooling = slim.avg_pool2d(inputs, [kernel, kernel], stride=[stride, stride])
return adapPooling * inputs
def TransitionLayer(inputs, n_filters, dropout_p=0.2, compression=1.0, scope=None):
"""
Transition layer for DenseNet
Apply 1x1 BN + conv then 2x2 max pooling
"""
with tf.name_scope(scope) as sc:
if compression < 1.0:
n_filters = tf.to_int32(tf.floor(n_filters*compression))
l = preact_conv(inputs, n_filters, filter_size=[1, 1], dropout_p=dropout_p)
l = slim.pool(l, [2, 2], stride=[2, 2], pooling_type='AVG')
return l
def interblock(inputs, level, feature_map, pooling_type):
kernel_size = [feature_map[0] // level, feature_map[1] // level]
stride_size = kernel_size
pool = slim.pool(inputs,
kernel_size,
stride=stride_size,
pooling_type=pooling_type)
conv = ConvBlock(pool, 128, kernel_size=[1, 1])
#conv = desconv(conv, 128, stride=feature_map)
conv = upsampling(conv, feature_map)
conv = slim.conv2d(conv, 128, kernel_size=[3, 3])
return conv
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--test', type=bool, default=False)
args = parser.parse_args()
batch_size = 32
images, labels, images_test, labels_test = read_dataset()
X = tf.placeholder(tf.float32, [None, 28, 28, 3])
y = tf.placeholder(tf.int64, [None, 14])
with tf.variable_scope('classifier', reuse=tf.AUTO_REUSE) as scope:
y_ = slim.conv2d(inputs=X, num_outputs=32, kernel_size=3, stride=1, activation_fn=tf.nn.relu)
y_ = slim.pool(y_, kernel_size=2, pooling_type='MAX')
y_ = slim.conv2d(y_, num_outputs=64, kernel_size=3, stride=1, activation_fn=tf.nn.relu)
y_ = slim.pool(y_, kernel_size=2, pooling_type='MAX')
y_ = slim.flatten(y_)
y_ = tf.layers.dense(y_, 512, activation=tf.nn.relu)
y_ = tf.layers.dense(y_, 512, activation=tf.nn.relu)
y_pred = tf.layers.dense(y_, 14)
loss = tf.reduce_mean(tf.losses.softmax_cross_entropy(y, logits=y_pred))
train_step = tf.train.AdamOptimizer(5e-4).minimize(loss)
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
saver = tf.train.Saver()
with tf.Session(config=config) as sess:
ckpt = tf.train.get_checkpoint_state(os.path.dirname('checkpoints/mnist_plus'))
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
print('successfully restore')
else:
sess.run(tf.global_variables_initializer())
print('no pre-trained model')
if args.test:
run_model(sess, y_pred, loss, train_step, saver, images_test, labels_test, X, y, 1, batch_size, 100, args.test)
else:
run_model(sess, y_pred, loss, train_step, saver, images, labels, X, y, 10, batch_size, 100, args.test)
def build_adaptnet(inputs, num_classes):
"""
Builds the AdaptNet model.
Arguments:
inputs: The input tensor=
preset_model: Which model you want to use. Select which ResNet model to use for feature extraction
num_classes: Number of classes
Returns:
AdaptNet model
"""
net = ConvBlock(inputs, n_filters=64, kernel_size=[3, 3])
net = ConvBlock(net, n_filters=64, kernel_size=[7, 7], stride=2)
net = slim.pool(net, [2, 2], stride=[2, 2], pooling_type='MAX')
net = ResNetBlock_2(net, filters_1=64, filters_2=256, s=1)
net = ResNetBlock_1(net, filters_1=64, filters_2=256)
net = ResNetBlock_1(net, filters_1=64, filters_2=256)
net = ResNetBlock_2(net, filters_1=128, filters_2=512, s=2)
net = ResNetBlock_1(net, filters_1=128, filters_2=512)
net = ResNetBlock_1(net, filters_1=128, filters_2=512)
skip_connection = ConvBlock(net, n_filters=12, kernel_size=[1, 1])
net = MultiscaleBlock_1(net, filters_1=128, filters_2=512, filters_3=64, p=1, d=2)
net = ResNetBlock_2(net, filters_1=256, filters_2=1024, s=2)
net = ResNetBlock_1(net, filters_1=256, filters_2=1024)
net = MultiscaleBlock_1(net, filters_1=256, filters_2=1024, filters_3=64, p=1, d=2)
net = MultiscaleBlock_1(net, filters_1=256, filters_2=1024, filters_3=64, p=1, d=4)
net = MultiscaleBlock_1(net, filters_1=256, filters_2=1024, filters_3=64, p=1, d=8)
net = MultiscaleBlock_1(net, filters_1=256, filters_2=1024, filters_3=64, p=1, d=16)
net = MultiscaleBlock_2(net, filters_1=512, filters_2=2048, filters_3=512, p=2, d=4)
net = MultiscaleBlock_1(net, filters_1=512, filters_2=2048, filters_3=512, p=2, d=8)
net = MultiscaleBlock_1(net, filters_1=512, filters_2=2048, filters_3=512, p=2, d=16)
net = ConvBlock(net, n_filters=12, kernel_size=[1, 1])
net = Upsampling(net, scale=2)
net = tf.add(skip_connection, net)
net = Upsampling(net, scale=8)
net = slim.conv2d(net, num_classes, [1, 1], activation_fn=None, scope='logits')
return net
def FPABlock(inputs, n_filters=1024, pooling_type='MAX', rate=16):
net_1 = conv2d(inputs, n_filters, kernel_size=[1, 1], activation_fn=None)
net_7 = slim.pool(inputs, [2, 2], stride=[2, 2], pooling_type=pooling_type)
net_7 = conv2d(net_7, n_filters, kernel_size=[7, 7])
net_5 = slim.pool(net_7, [2, 2], stride=[2, 2], pooling_type=pooling_type)
net_5 = conv2d(net_5, n_filters, kernel_size=[5, 5])
net_3 = slim.pool(net_5, [2, 2], stride=[2, 2], pooling_type=pooling_type)
net_3 = conv2d(net_3, n_filters, kernel_size=[3, 3])
net_3 = conv2d(net_3, n_filters, kernel_size=[3, 3])
net_3 = relu(net_3)
net_3 = Upsample(net_3)
net_5 = conv2d(net_5, n_filters, kernel_size=[5, 5])
net_5 = relu(net_5)
net_5 = add(net_3, net_5)
net_5 = UpsampleNear(net_5)
net_7 = conv2d(net_7, n_filters, kernel_size=[5, 5])
net_7 = relu(net_7)
net_7 += net_5
net_7 = UpsampleNear(net_7)
net = tf.multiply(net_7, net_1)
GAP = slim.pool(inputs, [rate, rate],
stride=[rate, rate],
padding='SAME',
pooling_type='AVG')
#test = inputs + GAP
#GAP = tf.reduce_mean(GAP, axis=[1, 2])
#GAP = tf.reshape(GAP, (-1, 1, 1, n_filters))
#GAP = Upsample(GAP, rate=16)
net_GAP = conv2d(GAP, n_filters, kernel_size=[1, 1])
net_GAP = UpsampleNear(net_GAP, rate=rate)
net = add(net, net_GAP)
return net
def strided_inference(self, images):
tf.summary.image('input',
images[..., 0:3],
max_outputs=self.max_images)
with tf.variable_scope('encode1'):
net = self.dwscb(images, 64)
net = self.dwscb(net, 64)
net = slim.pool(net, [2, 2], stride=[2, 2], pooling_type='MAX')
with tf.variable_scope('encode2'):
net = self.dwscb(net, 128)
net = self.dwscb(net, 128)
net = slim.pool(net, [2, 2], stride=[2, 2], pooling_type='MAX')
with tf.variable_scope('encode3'):
net = self.dwscb(net, 256)
net = self.dwscb(net, 256)
net = self.dwscb(net, 256)
net = slim.pool(net, [2, 2], stride=[2, 2], pooling_type='MAX')
with tf.variable_scope('decode3'):
net = self.ConvTRBlock(net, 256)
net = self.dwscb(net, 256)
net = self.dwscb(net, 256)
net = self.dwscb(net, 256)
with tf.variable_scope('decode2'):
net = self.ConvTRBlock(net, 128)
net = self.dwscb(net, 128)
net = self.dwscb(net, 128)
net = self.dwscb(net, 128)
with tf.variable_scope('decode1'):
net = self.ConvTRBlock(net, 64)
net = self.dwscb(net, 64)
net = self.dwscb(net, self.n)
return net
def Custom_netD_discriminator_psloss(image_input,posenum=3,reuse=False):
'''
08-04修改，使用avgpool减小网络大小
08-05修改，inst_norm 替换为batchnorm
:param image_input:
:param posenum:
:param reuse:
:return:
'''
with tf.variable_scope('discriminator/psloss',reuse=reuse) as vs:
kernel_size=[3,3]
filter_num=32
with slim.arg_scope([slim.conv2d],normalizer_fn=slim.batch_norm,activation_fn=tf.nn.elu,padding='SAME',weights_initializer=tf.truncated_normal_initializer(stddev=0.02)):
#96
conv1 = slim.conv2d(image_input,filter_num,kernel_size,normalizer_fn=None,scope='conv1')
conv2 = slim.conv2d(conv1,filter_num*2,kernel_size,scope='conv2')
#48
# conv3 = slim.max_pool2d(conv2,[2,2],scope='max1')
conv3 = slim.conv2d(conv2,filter_num*2,stride=2,kernel_size=kernel_size,scope='conv3')
conv4 = slim.conv2d(conv3,filter_num*2,kernel_size,scope='conv4')
conv5 = slim.conv2d(conv4,filter_num*4,kernel_size,scope='conv5')
#24
# conv6 = slim.max_pool2d(conv5,[2,2],scope='max2')
conv6 = slim.conv2d(conv5,filter_num*4,stride=2,kernel_size=kernel_size,scope='conv6')
conv7 = slim.conv2d(conv6,filter_num*3,kernel_size,scope='conv7')
conv8 = slim.conv2d(conv7,filter_num*6,kernel_size,scope='conv8')
#12
# conv9 = slim.max_pool2d(conv8,[2,2],scope='max3')
conv9 = slim.conv2d(conv8,filter_num*6,stride=2,kernel_size=kernel_size,scope='conv9')
conv10= slim.conv2d(conv9,filter_num*4,kernel_size,scope='conv10')
conv11= slim.conv2d(conv10,filter_num*8,kernel_size,scope='conv11')
#6
# conv12= slim.max_pool2d(conv11,[2,2],scope='max4')
conv12= slim.conv2d(conv11,filter_num*8,stride=2,kernel_size=kernel_size,scope='conv12')
conv13= slim.conv2d(conv12,filter_num*6,kernel_size,scope='conv13')
conv14= slim.conv2d(conv13,filter_num*10,kernel_size,scope='conv14')
#two path -feature -W Omegapredict_r_label
#avg出来之后应该是1*1*320的tensor
#3
# conv15= slim.conv2d(conv14,filter_num*10,stride=2,kernel_size=kernel_size,scope='conv15')
# conv16= slim.conv2d(conv15,filter_num*8,kernel_size,scope='conv16')
# conv17= slim.conv2d(conv16,filter_num*12,kernel_size,scope='conv17')
avgpool=slim.pool(conv14,[6,6],pooling_type="AVG",scope='avgpool')
# shape_conv17 = tf.shape(conv17)
# linear17 = tf.reshape(conv17, [-1,1,1, 3456],name='reshape_fc')
pslogits = slim.fully_connected(avgpool,posenum,activation_fn=None,normalizer_fn=None,weights_initializer=tf.truncated_normal_initializer(stddev=0.02),scope='ps_soft')
# variables = tf.contrib.framework.get_variables(vs)
#conv11 means content structure feature
return pslogits
def InterpBlock(net, level, feature_map_shape, pooling_type):
# Compute the kernel and stride sizes according to how large the final feature map will be
# When the kernel size and strides are equal, then we can compute the final feature map size
# by simply dividing the current size by the kernel or stride size
# The final feature map sizes are 1x1, 2x2, 3x3, and 6x6. We round to the closest integer
kernel_size = [int(np.round(float(feature_map_shape[0]) / float(level))), int(np.round(float(feature_map_shape[1]) / float(level)))]
stride_size = kernel_size
net = slim.pool(net, kernel_size, stride=stride_size, pooling_type='MAX')
net = slim.conv2d(net, 512, [1, 1], activation_fn=None)
net = slim.batch_norm(net, fused=True)
net = tf.nn.relu(net)
net = Upsampling(net, feature_map_shape)
return net
def Custom_netD_discriminator_adloss(image_input,reuse=False):
with tf.variable_scope('discriminator/adloss',reuse=reuse) as vs:
kernel_size=[3,3]
filter_num=32
with slim.arg_scope([slim.conv2d],normalizer_fn=slim.batch_norm,activation_fn=tf.nn.elu,padding='SAME',weights_initializer=tf.truncated_normal_initializer(stddev=0.02)):
#96
net = slim.conv2d(image_input,filter_num,kernel_size,normalizer_fn=None,scope='conv1')
net = slim.conv2d(net,filter_num*2,kernel_size,scope='conv2')
#48
# conv3 = slim.max_pool2d(conv2,[2,2],scope='max1')
net = slim.conv2d(net,filter_num*2,stride=2,kernel_size=kernel_size,scope='conv3')
net = slim.conv2d(net,filter_num*2,kernel_size,scope='conv4')
net = slim.conv2d(net,filter_num*4,kernel_size,scope='conv5')
# 24
# conv6 = slim.max_pool2d(conv5,[2,2],scope='max2')
net = slim.conv2d(net,filter_num*4,stride=2,kernel_size=kernel_size,scope='conv6')
net = slim.conv2d(net,filter_num*3,kernel_size,scope='conv7')
net = slim.conv2d(net,filter_num*6,kernel_size,scope='conv8')
#12
# conv9 = slim.max_pool2d(conv8,[2,2],scope='max3')
net = slim.conv2d(net,filter_num*6,stride=2,kernel_size=kernel_size,scope='conv9')
net= slim.conv2d(net,filter_num*4,kernel_size,scope='conv10')
net= slim.conv2d(net,filter_num*8,kernel_size,scope='conv11')
#6
# conv12= slim.max_pool2d(conv11,[2,2],scope='max4')
net = slim.conv2d(net,filter_num*8,stride=2,kernel_size=kernel_size,scope='conv12')
net = slim.conv2d(net,filter_num*6,kernel_size,scope='conv13')
net = slim.conv2d(net,filter_num*10,kernel_size,scope='conv14')
#two path -feature -W Omegapredict_r_label
#avg出来之后应该是1*1*320的tensor
#3
# conv15= slim.conv2d(conv14,filter_num*10,stride=2,kernel_size=kernel_size,scope='conv15')
# conv16= slim.conv2d(conv15,filter_num*8,kernel_size,scope='conv16')
# conv17= slim.conv2d(conv16,filter_num*12,kernel_size,scope='conv17')
# net =slim.conv2d(net,filter_num*10,[1,1],scope='NiN1')
# net = slim.conv2d(net,1, [1, 1], scope='NiN2')
avgpool=slim.pool(net,[6,6],stride=6,pooling_type="AVG",scope='avgpool')
# shape_conv17 = tf.shape(conv17)
# linear17 = tf.reshape(conv17, [shape_conv17[0],1,1, shape_conv17[1] * shape_conv17[2] * shape_conv17[3]],name='reshape_fc')
adlogits = slim.fully_connected(avgpool,1,activation_fn=None,normalizer_fn=None,weights_initializer=tf.truncated_normal_initializer(stddev=0.02),scope='ad_soft')
# variables = tf.contrib.framework.get_variables(vs)
# return tf.nn.softmax(adlogits),adlogits
# [2,2]的预测
return adlogits
def FullResolutionResidualUnit(pool_stream, res_stream, n_filters_3,
n_filters_1, pool_scale):
"""
A full resolution residual unit
Arguments:
pool_stream: The inputs from the pooling stream
res_stream: The inputs from the residual stream
n_filters_3: Number of output feature maps for each 3x3 conv
n_filters_1: Number of output feature maps for each 1x1 conv
pool_scale: scale of the pooling layer i.e window size and stride
Returns:
Output of full resolution residual block
"""
pool = slim.pool(res_stream, [pool_scale, pool_scale],
stride=[pool_scale, pool_scale],
pooling_type='MAX')
# pool = tf.image.resize_image_with_crop_or_pad(pool, tf.shape(pool_stream)[1], tf.shape(pool_stream)[2])
G = tf.concat([pool_stream, pool], axis=-1)
# First convolution layer
net = slim.conv2d(G, n_filters_3, kernel_size=3, activation_fn=None)
net = slim.batch_norm(net, fused=True)
net = tf.nn.relu(net)
# Second convolution layer
net = slim.conv2d(net, n_filters_3, kernel_size=3, activation_fn=None)
net = slim.batch_norm(net, fused=True)
pool_stream_out = tf.nn.relu(net)
# Conv1x1 and Upsample
net = slim.conv2d(pool_stream_out,
n_filters_1,
kernel_size=1,
activation_fn=None)
res_stream_shape = tf.shape(res_stream)
res_stream_out = Upsampling(net,
scale=pool_scale,
spatial_shape=(res_stream_shape[1],
res_stream_shape[2]))
# # Add to form next residual stream
# res_stream_out = tf.add(res_stream, net)
return pool_stream_out, res_stream_out
def interp_block(prev_layer, level, feature_map_shape, input_shape,
is_training):
kernel_strides_map = {1: 90, 2: 45, 3: 30, 6: 15}
prev_layer = slim.pool(prev_layer,
kernel_strides_map[level],
padding='SAME',
pooling_type='AVG',
stride=kernel_strides_map[level])
prev_layer = slim.conv2d(prev_layer,
256,
1,
stride=1,
biases_initializer=None,
activation_fn=None)
prev_layer = slim.batch_norm(prev_layer, is_training=is_training)
prev_layer = tf.nn.relu(prev_layer)
prev_layer = tf.image.resize_bilinear(prev_layer, size=feature_map_shape)
return prev_layer
def TransitionDown(inputs,
n_filters,
dropout_p=0.2,
compression_rate=1,
scope=None):
"""
Transition Down (TD) for FC-DenseNet
Apply 1x1 BN + ReLU + conv then 2x2 max pooling
"""
with tf.name_scope(scope) as sc:
l = preact_conv(inputs,
np.ceil(compression_rate * n_filters),
filter_size=[1, 1],
dropout_p=dropout_p)
l = slim.pool(l, [2, 2],
stride=[2, 2],
pooling_type='MAX',
data_format='NCHW')
return l
def get_pool(pool_4):
pool_list = []
#pool_list.append(slim.pool(pool_4, [16, 16], stride=[1, 1], pooling_type='AVG'))
#pool_list.append(slim.pool(pool_4, [15, 15], stride=[1, 1], pooling_type='AVG'))
pool_list.append(
slim.pool(pool_4, [14, 14], stride=[1, 1], pooling_type='AVG'))
pool_list.append(
slim.pool(pool_4, [13, 13], stride=[1, 1], pooling_type='AVG'))
pool_list.append(
slim.pool(pool_4, [12, 12], stride=[1, 1], pooling_type='AVG'))
pool_list.append(
slim.pool(pool_4, [11, 11], stride=[1, 1], pooling_type='AVG'))
pool_list.append(
slim.pool(pool_4, [9, 9], stride=[1, 1], pooling_type='AVG'))
pool_list.append(
slim.pool(pool_4, [8, 8], stride=[1, 1], pooling_type='AVG'))
pool_list.append(
slim.pool(pool_4, [3, 3], stride=[1, 1], pooling_type='AVG'))
pool_list.append(
slim.pool(pool_4, [1, 1], stride=[1, 1], pooling_type='AVG'))
return pool_list
def build_encoder_decoder(inputs,
num_classes,
preset_model="Encoder-Decoder",
dropout_p=0.5,
scope=None):
"""
Builds the Encoder-Decoder model. Inspired by SegNet with some modifications
Optionally includes skip connections
Arguments:
inputs: the input tensor
n_classes: number of classes
dropout_p: dropout rate applied after each convolution (0. for not using)
Returns:
Encoder-Decoder model
"""
if preset_model == "Encoder-Decoder":
has_skip = False
elif preset_model == "Encoder-Decoder-Skip":
has_skip = True
else:
raise ValueError(
"Unsupported Encoder-Decoder model '%s'. This function only supports Encoder-Decoder and Encoder-Decoder-Skip"
% (preset_model))
#####################
# Downsampling path #
#####################
net = conv_block(inputs, 64)
net = conv_block(net, 64)
net = slim.pool(net, [2, 2], stride=[2, 2], pooling_type='MAX')
skip_1 = net
net = conv_block(net, 128)
net = conv_block(net, 128)
net = slim.pool(net, [2, 2], stride=[2, 2], pooling_type='MAX')
skip_2 = net
net = conv_block(net, 256)
net = conv_block(net, 256)
net = conv_block(net, 256)
net = slim.pool(net, [2, 2], stride=[2, 2], pooling_type='MAX')
skip_3 = net
net = conv_block(net, 512)
net = conv_block(net, 512)
net = conv_block(net, 512)
net = slim.pool(net, [2, 2], stride=[2, 2], pooling_type='MAX')
skip_4 = net
net = conv_block(net, 512)
net = conv_block(net, 512)
net = conv_block(net, 512)
net = slim.pool(net, [2, 2], stride=[2, 2], pooling_type='MAX')
#####################
# Upsampling path #
#####################
net = conv_transpose_block(net, 512)
net = conv_block(net, 512)
net = conv_block(net, 512)
net = conv_block(net, 512)
if has_skip:
net = tf.add(net, skip_4)
net = conv_transpose_block(net, 512)
net = conv_block(net, 512)
net = conv_block(net, 512)
net = conv_block(net, 256)
if has_skip:
net = tf.add(net, skip_3)
net = conv_transpose_block(net, 256)
net = conv_block(net, 256)
net = conv_block(net, 256)
net = conv_block(net, 128)
if has_skip:
net = tf.add(net, skip_2)
net = conv_transpose_block(net, 128)
net = conv_block(net, 128)
net = conv_block(net, 64)
if has_skip:
net = tf.add(net, skip_1)
net = conv_transpose_block(net, 64)
net = conv_block(net, 64)
net = conv_block(net, 64)
#####################
# Softmax #
#####################
net = slim.conv2d(net,
num_classes, [1, 1],
activation_fn=None,
scope='logits')
return net
def create_model(self, model_input, vocab_size, num_frames, **unused_params):
lstm_size = FLAGS.lstm_cells
number_of_layers = FLAGS.lstm_layers
stacked_lstm = tf.contrib.rnn.MultiRNNCell(
[
tf.contrib.rnn.BasicLSTMCell(
lstm_size, forget_bias=1.0)
for _ in range(number_of_layers)
])
loss = 0.0
output, state = tf.nn.dynamic_rnn(stacked_lstm, model_input,
sequence_length=num_frames,
dtype=tf.float32)
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
# output = slim.convolution(output, 512, [3], stride = 1, padding = "SAME")
output = tf.contrib.layers.batch_norm(output, center=True, scale=True, is_training=True, scope=None)
output = slim.pool(output, [2], "MAX", stride=2)
# output = slim.convolution(output, 512, [3], stride = 1, padding = "SAME")
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
output = tf.contrib.layers.batch_norm(output, center=True, scale=True, is_training=True, scope=None)
output = slim.pool(output, [2], "MAX", stride=2)
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
output = tf.contrib.layers.batch_norm(output, center=True, scale=True, is_training=True, scope=None)
output = slim.pool(output, [3], "MAX", stride=2)
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
output = tf.contrib.layers.batch_norm(output, center=True, scale=True, is_training=True, scope=None)
output = slim.pool(output, [3], "MAX", stride=2)
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
output = tf.contrib.layers.batch_norm(output, center=True, scale=True, is_training=True, scope=None)
output = slim.pool(output, [2], "MAX", stride=2)
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
output = tf.contrib.layers.batch_norm(output, center=True, scale=True, is_training=True, scope=None)
output = slim.pool(output, [2], "MAX", stride=1)
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
output = tf.contrib.layers.batch_norm(output, center=True, scale=True, is_training=True, scope=None)
output = slim.pool(output, [2], "MAX", stride=1)
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
output = slim.convolution(output, 1024, [3], stride=1, padding="SAME")
output = tf.contrib.layers.batch_norm(output, center=True, scale=True, is_training=True, scope=None)
output = slim.pool(output, [2], "MAX", stride=1)
output = slim.convolution(output, 512, [3], stride=1, padding="SAME")
output = slim.convolution(output, 512, [3], stride=1, padding="SAME")
output = slim.convolution(output, 512, [3], stride=1, padding="SAME")
output = tf.contrib.layers.batch_norm(output, center=True, scale=True, is_training=True, scope=None)
output = slim.pool(output, [2], "MAX", stride=1)
output = slim.flatten(output)
output = slim.fully_connected(output, 4096)
output = tf.contrib.layers.batch_norm(output, center=True, scale=True, is_training=True, scope=None)
output = slim.dropout(output)
output = slim.fully_connected(output, 4096)
output = tf.contrib.layers.batch_norm(output, center=True, scale=True, is_training=True, scope=None)
output = slim.dropout(output)
output = slim.fully_connected(output, vocab_size, activation_fn=tf.nn.sigmoid)
return {"predictions": output}
def create_model(self, model_input, vocab_size, num_frames, **unused_params):
output = model_input
hidden_size = 1024
output = slim.convolution(output, hidden_size, [8], stride = 2, padding = 'SAME')
tmp_state = output
output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME')
output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME')
output = output + tmp_state
tmp_state = output
output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME')
output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME')
output = output + tmp_state
tmp_state = output
output = slim.convolution(output, hidden_size, [3], stride=2, padding="SAME")
output = slim.convolution(output, hidden_size, [3], stride=1, padding='SAME')
tmp_state = slim.pool(tmp_state, [2], "AVG", stride=2, padding="SAME")
output = output + tmp_state
tmp_state = output
output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME')
output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME')
output = output + tmp_state
tmp_state = output
output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME')
output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME')
output = output + tmp_state
tmp_state = output
output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME')
output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME')
output = output + tmp_state
tmp_state = output
output = slim.convolution(output, hidden_size, [3], stride=2, padding="SAME")
output = slim.convolution(output, hidden_size, [3], stride=1, padding='SAME')
tmp_state = slim.pool(tmp_state, [2], "AVG", stride=2, padding="SAME")
output = output + tmp_state
tmp_state = output
output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME')
output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME')
output = output + tmp_state
tmp_state = output
output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME')
output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME')
output = output + tmp_state
tmp_state = output
output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME')
output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME')
output = output + tmp_state
tmp_state = output
output = slim.convolution(output, hidden_size, [3], stride=2, padding="SAME")
output = slim.convolution(output, hidden_size, [3], stride=1, padding='SAME')
tmp_state = slim.pool(tmp_state, [2], "AVG", stride=2, padding="SAME")
output = output + tmp_state
tmp_state = output
output = slim.convolution(output, hidden_size, [3], stride=1, padding='SAME')
output = slim.convolution(output, hidden_size, [3], stride=1, padding='SAME')
output = output + tmp_state
tmp_state = output
output = slim.convolution(output, hidden_size, [3], stride=1, padding='SAME')
output = slim.convolution(output, hidden_size, [3], stride=1, padding='SAME')
output = output + tmp_state
# output = tf.contrib.layers.batch_norm(output, center=True, scale=True, is_training=True, scope=None)
output = slim.pool(output, [2], "AVG", stride=2, padding="SAME")
output = slim.flatten(output)
output = slim.fully_connected(output, 2048)
# output = tf.contrib.layers.batch_norm(output,center = True, scale = True, is_training = True, scope = None)
output = slim.dropout(output)
output = slim.fully_connected(output, 2048)
# output = tf.contrib.layers.batch_norm(output,center = True, scale = True, is_training = True, scope = None)
output = slim.dropout(output)
output = slim.fully_connected(output, vocab_size, activation_fn = tf.nn.sigmoid)
return {"predictions": output}
