def forward(self, x):
hidden = conv_layer(x, 5, 3, 6, self.regularizer)
hidden = conv_layer(hidden, 3, 6, 12, self.regularizer)
hidden = tf.reshape(hidden, [-1, 20 * 40 * 12])
y = fc_layer(hidden, 20 * 40 * 12, 10, 'layer_after_conv')
return y
def get_inference(images_ph, dropout_keep_prob_ph):
#subtract average image
with tf.variable_scope('centering') as scope:
mean = tf.constant(vgg.average_image, dtype=tf.float32, name='avg_image')
images_ph = tf.sub(images_ph, mean, name='subtract_avg')
#get layers from vgg19
vgg_layers = vgg.get_VGG_layers(images_ph, dropout_keep_prob_ph, train_fc_layers=True)
#################################################
### Add more layers for semantic segmentation ###
#################################################
# convolution on top of pool4 to 21 chammenls (to make coarse predictions)
with tf.variable_scope('conv9') as scope:
conv9 = conv_layer(vgg_layers['pool4'], 21, 1, 'conv9')
# convolution on top of conv7 (fc7) to 21 chammenls (to make coarse predictions)
with tf.variable_scope('conv8') as scope:
conv8 = conv_layer(vgg_layers['dropout2'], 21, 1, 'conv8')
# 2x upsampling from last layer
with tf.variable_scope('deconv1') as scope:
shape = tf.shape(conv8)
out_shape = tf.pack([shape[0], shape[1]*2, shape[2]*2, 21])
weights = tf.Variable(tf.truncated_normal(mean=MEAN, stddev=0.1, shape=(4, 4, 21, 21)), name='weights')
deconv1 = tf.nn.conv2d_transpose( value=conv8,
filter=weights,
output_shape=out_shape,
strides=(1, 2, 2, 1),
padding='SAME',
name='deconv1')
# slice 2x upsampled tensor in the last layer to fit pool4
shape = tf.shape(conv9)
size = tf.pack([-1, shape[1], shape[2], -1])
deconv1 = tf.slice(deconv1, begin=[0,0,0,0], size=size, name="deconv1_slice")
# combine preductions from last layer and pool4
with tf.variable_scope('combined_pred') as scope:
combined_pred = tf.add(deconv1, conv9, name="combined_pred")
# 16x upsampling
with tf.variable_scope('deconv2') as scope:
shape = tf.shape(combined_pred)
out_shape = tf.pack([shape[0], shape[1]*16, shape[2]*16, 21])
weights = tf.Variable(tf.truncated_normal(mean=MEAN, stddev=0.1, shape=(32, 32, 21, 21)), name='weights')
deconv2 = tf.nn.conv2d_transpose(value=combined_pred,
filter=weights,
output_shape=out_shape,
strides=(1, 16, 16, 1),
padding='SAME',
name='deconv2')
# slice upsampled tensor to original shape
orig_shape = tf.shape(images_ph)
size = tf.pack([-1, orig_shape[1], orig_shape[2], -1])
logits = tf.slice(deconv2, begin=[0,0,0,0], size=size, name='logits')
return logits
def get_VGG_layers(images_ph, dropout_keep_prob_ph, train_fc_layers=False):
"""
Args:
images: Images placeholder in NHWC.
Returns:
dict of tensors, keys are original layer names.
"""
x = images_ph
layers = dict()
for layer in VGG_layers:
layer_type = layer[0]
layer_name = layer[1]
if layer_type == 'conv':
with tf.variable_scope(layer_name) as scope:
x = conv_layer(x, layer[2], 3, layer_name, train=False)
elif layer_type == 'pool':
with tf.variable_scope(layer_name) as scope:
x = max_pool_2x2(x, layer_name)
elif layer_type == 'fc':
with tf.variable_scope(layer_name) as scope:
x = conv_layer(x, layer[2], layer[3], layer_name, train=train_fc_layers)
elif layer_type == 'relu':
x = tf.nn.relu(x, layer_name)
elif layer_type == 'dropout':
x = tf.nn.dropout(x, dropout_keep_prob_ph, name=layer_name)
layers[layer_name] = x
return layers
def __init__(self):
super(feature_r, self).__init__()
#input 28*28
self.layerb1 = conv_layer(512,
512,
kernel_size=3,
stride=(1, 1),
padding=1)
self.layerb2 = conv_layer(512,
512,
kernel_size=3,
stride=(1, 1),
padding=1)
self.drop_layer1 = nn.Dropout(0.1)
#input 28*28
self.layerb3 = conv_layer(512,
512,
kernel_size=3,
stride=(1, 1),
padding=1)
self.layerb4 = conv_layer(512,
512,
kernel_size=3,
stride=(1, 1),
padding=1)
self.drop_layer2 = nn.Dropout(0.1)
def __init__(self, conv_dim=64):
super(Dy, self).__init__()
self.conv1 = conv_layer(3, conv_dim, 4, batch_norm=False)
self.conv2 = conv_layer(conv_dim, conv_dim * 2, 4)
self.conv3 = conv_layer(conv_dim * 2, conv_dim * 4, 4)
self.fc = conv_layer(conv_dim * 4, 1, 4, 1, 0, batch_norm=False)
def graph(self, input, is_training):
with tf.name_scope('model'):
net = ut.conv_layer(input, 64, 7, 2, name='conv1')
net = ut.bottleneck(net,
128,
stride=1,
training=is_training,
name='res1')
net = ut.max_pool(net, 2, 2, 'max_pool')
net = ut.bottleneck(net,
int(self.nFeats / 2),
stride=1,
training=is_training,
name='res2')
net = ut.bottleneck(net,
self.nFeats,
stride=1,
training=is_training,
name='res3')
with tf.name_scope('stacks'):
stack_out = []
with tf.name_scope('stage_0'):
hg = ut.hourglass(net, self.nLow, self.nFeats, 'hourglass')
drop = ut.dropout(hg, self.dropout_rate, is_training,
'dropout')
ll = ut.conv_layer_bn(drop, self.nFeats, 1, 1, is_training)
out = ut.conv_layer(ll, self.num_points, 1, 1, name='out')
out_ = ut.conv_layer(out, self.nFeats, 1, 1, name='out_')
sum_ = tf.add(net, out_, name='merge')
stack_out.append(out)
for i in range(1, self.nStacks):
with tf.name_scope('stage_' + str(i)):
hg = ut.hourglass(sum_, self.nLow, self.nFeats,
'hourglass')
drop = ut.dropout(hg, self.dropout_rate, is_training,
'dropout')
ll = ut.conv_layer_bn(drop, self.nFeats, 1, 1,
is_training)
out = ut.conv_layer(ll,
self.num_points,
1,
1,
name='out')
out_ = ut.conv_layer(ll,
self.nFeats,
1,
1,
name='out_')
sum_ = tf.add(sum_, out_, name='merge')
stack_out.append(out)
with tf.name_scope('upsampling'):
net = ut.batch_norm(sum_, is_training)
net = ut.conv_layer_bn(net, self.nFeats, 3, 1, is_training)
up1 = ut.deconv_layer(net, self.num_points, 1, 2, name='up_1')
net = ut.conv_layer_bn(up1, self.nFeats, 3, 1, is_training)
up2 = ut.deconv_layer(net, self.num_points, 1, 2, name='up_2')
return tf.stack(stack_out, axis=1, name='stack_out'), up1, up2
def __init__(self, conv_dim=64):
super(Gxy, self).__init__()
# encoding block
self.conv1 = conv_layer(1, conv_dim, 4)
self.conv2 = conv_layer(conv_dim, conv_dim * 2, 4)
# residual block (will use res layer when I have good GPU :P)
self.conv3 = conv_layer(conv_dim * 2, conv_dim * 2, 3, 1, 1)
self.conv4 = conv_layer(conv_dim * 2, conv_dim * 2, 3, 1, 1)
# docoding block
self.deconv1 = deconv_layer(conv_dim * 2, conv_dim, 4)
self.deconv2 = deconv_layer(conv_dim, 3, 4, batch_norm=False)
def __init__(self, conv_dim=64):
super(Gyx, self).__init__()
# encoding block
self.conv1 = conv_layer(3, conv_dim, 4)
self.conv2 = conv_layer(conv_dim, conv_dim * 2, 4)
# residual block
self.conv3 = conv_layer(conv_dim * 2, conv_dim * 2, 3, 1, 1)
self.conv4 = conv_layer(conv_dim * 2, conv_dim * 2, 3, 1, 1)
# docoding block
self.deconv1 = deconv_layer(conv_dim * 2, conv_dim, 4)
self.deconv2 = deconv_layer(conv_dim, 1, 4, batch_norm=False)
def __init__(self):
super(decision_r, self).__init__()
#input 28*28
self.layerb1 = conv_layer(512,
1024,
kernel_size=3,
stride=(2, 2),
padding=1)
#input 14*14
self.layerb2 = conv_layer(1024,
4096,
kernel_size=3,
stride=(2, 2),
padding=1)
def __call__(self, loc):
glimpse_input = self.get_glimpse(loc)
#glimpse_input = tf.reshape(glimpse_input,
# (tf.shape(loc)[0], self.sensor_size))
glimpse_input = tf.reshape(
glimpse_input,
(tf.shape(loc)[0], self.win_size, self.win_size, self.depth))
#g = tf.nn.relu(tf.nn.xw_plus_b(glimpse_input, self.w_g0, self.b_g0)) # replace with a CNN?
# CNN
g = glimpse_input
for i in range(1, self.gcnn_depth + 1):
w = self.glimpse_params['w_gconv{}'.format(i)]
b = self.glimpse_params['b_gconv{}'.format(i)]
g = conv_layer(g,
w,
b,
'glimpse_conv{}'.format(i),
stride=1,
padding='SAME')
g = tf.reshape(g, (tf.shape(g)[0], -1))
for i in range(1, self.gfc_depth + 1):
w = self.glimpse_params['w_gfc{}'.format(i)]
b = self.glimpse_params['b_gfc{}'.format(i)]
g = tf.nn.xw_plus_b(g, w, b)
l = tf.nn.relu(tf.nn.xw_plus_b(
loc, self.w_l0,
self.b_l0)) # what's the point other than transforming the dim?
l = tf.nn.xw_plus_b(l, self.w_l1, self.b_l1)
g = tf.nn.relu(g + l)
return g
def builde_encode(self, input):
# output shape 64*28*28*64
input = tf.reshape(
input,
shape=[self.batch_size, self.image_w, self.image_h, self.channel])
tf.summary.image('input_image', input)
with tf.variable_scope('conv_layer1'):
tensor = conv_layer(input,
filters=self.filters[0],
k_size=self.kernel[0],
strides=1)
# output shape = 64*14*14*64
with tf.variable_scope('max_pool_layer_1'):
ksize = [1, 5, 5, 1]
strides = [1, 2, 2, 1]
tensor = tf.nn.max_pool(tensor,
ksize=ksize,
strides=strides,
padding='SAME')
# output shape = 64*14*14*64
with tf.variable_scope('conv_layer2'):
tensor = conv_layer(tensor,
self.filters[1],
self.kernel[1],
strides=1)
# output shape = 64*7*7*64
with tf.variable_scope('max_pool_layer_1'):
ksize = [1, 5, 5, 1]
strides = [1, 2, 2, 1]
tensor = tf.nn.max_pool(tensor,
ksize=ksize,
strides=strides,
padding='SAME')
# output_size = tf.shape(pool)[1,2]
tensor = tf.reshape(tensor, [self.batch_size, -1])
with tf.variable_scope('linear'):
tensor = linear_layer(tensor, self.linear_units)
with tf.variable_scope('latent'):
tensor = linear_layer(tensor, self.variation_dim, lambda x: x)
tensor2 = linear_layer(tensor,
self.variation_dim,
lambda x: x,
name='2')
return tensor, tensor2
def __init__(self):
super(feature_b, self).__init__()
#input 224*224
self.layerb1 = conv_layer(3,
64,
kernel_size=3,
stride=(1, 1),
padding=1)
self.layerb2 = conv_layer(64,
64,
kernel_size=3,
stride=(2, 2),
padding=1)
self.drop_layer1 = nn.Dropout(0.1)
#input 112*112
self.layerb3 = conv_layer(64,
128,
kernel_size=3,
stride=(1, 1),
padding=1)
self.layerb4 = conv_layer(128,
128,
kernel_size=3,
stride=(2, 2),
padding=1)
self.drop_layer2 = nn.Dropout(0.1)
#input 56*56
self.layerb5 = conv_layer(128,
256,
kernel_size=3,
stride=(1, 1),
padding=1)
self.layerb6 = conv_layer(256,
512,
kernel_size=3,
stride=(2, 2),
padding=1)
self.drop_layer3 = nn.Dropout(0.1)
def warper_11(self, input_LR, input_g, is_training, reuse=False):
with tf.variable_scope('warper', reuse=reuse):
x = tf.concat([input_LR, input_g], axis=3)
with tf.variable_scope('input_encoder'):
with tf.variable_scope('conv1'):
x = utils.conv_layer(x, 3, 64, 1)
x = utils.relu_layer(x)
with tf.variable_scope('conv2'):
x = utils.conv_layer(x, 3, 64, 2)
x = utils.relu_layer(x)
with tf.variable_scope('conv3'):
x = utils.conv_layer(x, 3, 64, 1)
x = utils.relu_layer(x)
with tf.variable_scope('conv4'):
x = utils.conv_layer(x, 3, 64, 2)
x = utils.relu_layer(x)
with tf.variable_scope('conv5'):
x = utils.conv_layer(x, 3, 64, 1)
x = utils.relu_layer(x)
with tf.variable_scope('conv6'):
x = utils.conv_layer(x, 3, 64, 2)
x = utils.relu_layer(x)
with tf.variable_scope('conv_input_res'):
x = utils.conv_layer(x, 3, 64, 1, False)
conv_1 = x
with tf.variable_scope('resblocks'):
for i in range(8):
with tf.variable_scope('resblock{}'.format(i + 1)):
x = utils.resBlock_EDSR(x,
filter_size=3,
num_filters=64)
with tf.variable_scope('conv_before_skip'):
x = utils.conv_layer(x, 3, 64, 1, False)
with tf.variable_scope('flow_decoder_input'):
x += conv_1
with tf.variable_scope('flow_decoder'):
with tf.variable_scope('upsampler1'):
x = utils.upsample_EDSR(x, 2, 64, False)
with tf.variable_scope('upsampler2'):
x = utils.upsample_EDSR(x, 2, 64, False)
with tf.variable_scope('upsampler3'):
x = utils.upsample_EDSR(x, 2, 64, False)
with tf.variable_scope('conv1'):
num_input_channels = x.get_shape().as_list()[3]
shape = [3, 3, num_input_channels, 2]
length = [2]
weights1 = tf.get_variable(
name='weight',
shape=shape,
dtype=tf.float32,
initializer=tf.contrib.layers.xavier_initializer())
biases1 = tf.get_variable(
name='bias',
shape=length,
dtype=tf.float32,
initializer=tf.constant_initializer(0.0))
x = tf.nn.conv2d(x, weights1, [1, 1, 1, 1], padding='SAME')
x = tf.nn.bias_add(x, biases1)
self.w_variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope='warper')
return x
def model_guidance_9(self, input_LR, input_g, reuse=False):
with tf.variable_scope('generator', reuse):
with tf.variable_scope('input_g_preprocessing'):
with tf.variable_scope('conv1'):
x_g = utils.conv_layer(input_g, 3, 64, 1)
x_g = utils.relu_layer(x_g)
with tf.variable_scope('conv2'):
x_g = utils.conv_layer(x_g, 3, 64, 2)
x_g = utils.relu_layer(x_g)
with tf.variable_scope('conv3'):
x_g = utils.conv_layer(x_g, 3, 64, 1)
x_g = utils.relu_layer(x_g)
with tf.variable_scope('conv4'):
x_g = utils.conv_layer(x_g, 3, 64, 2)
x_g = utils.relu_layer(x_g)
with tf.variable_scope('conv5'):
x_g = utils.conv_layer(x_g, 3, 64, 1)
x_g = utils.relu_layer(x_g)
with tf.variable_scope('conv6'):
x_g = utils.conv_layer(x_g, 3, 64, 2)
x_g = utils.relu_layer(x_g)
with tf.variable_scope('conv1'):
x = utils.conv_layer(input_LR, 3, self.args.feature_size, 1,
False)
with tf.variable_scope('conv1_g'):
x_g = utils.conv_layer(x_g, 3, self.args.feature_size, 1,
False)
conv_1 = x
with tf.variable_scope('resblocks'):
with tf.variable_scope('resblocks_1'):
for i in range(self.args.merge_resblock):
with tf.variable_scope('resblock{}'.format(i + 1)):
x = utils.resBlock_EDSR(
x,
3,
num_filters=self.args.feature_size,
scale=self.args.scaling_factor)
with tf.variable_scope('resblock_g{}'.format(i + 1)):
x_g = utils.resBlock_EDSR(
x_g,
3,
num_filters=self.args.feature_size,
scale=self.args.scaling_factor)
x = tf.concat([x, x_g], axis=3)
x = utils.conv_layer(x, 3, self.args.feature_size, 1,
False)
with tf.variable_scope('resblocks_2'):
for i in range(self.args.merge_resblock):
with tf.variable_scope('resblock{}'.format(i + 1)):
x = utils.resBlock_EDSR(
x,
3,
num_filters=self.args.feature_size,
scale=self.args.scaling_factor)
with tf.variable_scope('resblock_g{}'.format(i + 1)):
x_g = utils.resBlock_EDSR(
x_g,
3,
num_filters=self.args.feature_size,
scale=self.args.scaling_factor)
x = tf.concat([x, x_g], axis=3)
x = utils.conv_layer(x, 3, self.args.feature_size, 1,
False)
with tf.variable_scope('resblocks_3'):
for i in range(self.args.merge_resblock):
with tf.variable_scope('resblock{}'.format(i + 1)):
x = utils.resBlock_EDSR(
x,
3,
num_filters=self.args.feature_size,
scale=self.args.scaling_factor)
with tf.variable_scope('resblock_g{}'.format(i + 1)):
x_g = utils.resBlock_EDSR(
x_g,
3,
num_filters=self.args.feature_size,
scale=self.args.scaling_factor)
x = tf.concat([x, x_g], axis=3)
x = utils.conv_layer(x, 3, self.args.feature_size, 1,
False)
with tf.variable_scope('resblocks_4'):
for i in range(self.args.merge_resblock):
with tf.variable_scope('resblock{}'.format(i + 1)):
x = utils.resBlock_EDSR(
x,
3,
num_filters=self.args.feature_size,
scale=self.args.scaling_factor)
with tf.variable_scope('conv_before_skip'):
x = utils.conv_layer(x, 3, self.args.feature_size, 1, False)
with tf.variable_scope('upsampler_input'):
x += conv_1
with tf.variable_scope('upsamplers'):
for i in range(3):
with tf.variable_scope('upsampler{}'.format(i + 1)):
x = utils.upsample_EDSR(x, 2, self.args.feature_size,
False)
with tf.variable_scope('conv_final'):
x = utils.conv_layer(x, 3, self.args.output_channels, 1, False)
self.g_variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope='generator')
return x
# Step 1: Get data
train_data, test_data = utils.get_mnist_dataset(batch_size, MNIST)
iterator = tf.data.Iterator.from_structure(train_data.output_types,
train_data.output_shapes)
img, label = iterator.get_next()
img = tf.cast(img, tf.float32)
img = tf.reshape(img, [-1, 28, 28, 1])
train_init = iterator.make_initializer(
train_data) # initializer for train_data
test_init = iterator.make_initializer(test_data) # initializer for train_data
# Step 2: Set layers structure
H1 = utils.conv_layer(img, n_filters, filter_size)
H1_relu = tf.nn.relu(H1)
H1_pool = tf.nn.max_pool(H1_relu,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding="SAME")
feature_dim = H1_pool.shape[1] * H1_pool.shape[2] * H1_pool.shape[3]
logits = tf.layers.dense(tf.reshape(H1_pool, [-1, feature_dim]),
10,
kernel_initializer=tf.random_normal_initializer(
0, 0.01),
name='logits')
#H2 = tf.layers.dense(tf.sigmoid(H1),100,kernel_initializer=tf.random_normal_initializer(0, 0.01),name = 'H2')
# Step 3: define loss function
# use cross entropy of softmax of logits as the loss function
def VGG16(x, n_classes, is_pretrain = True):
x = utils.conv_layer('conv1_1', x, 64, filter = [3,3], strides = [1,1,1,1], is_pretrain = is_pretrain)
x = utils.conv_layer('conv1_2', x, 64, filter = [3,3], strides = [1,1,1,1], is_pretrain = is_pretrain)
x = utils.pool_layer('pool1', x, filter = [1,2,2,1], strides = [1,2,2,1], is_max_pool = True)
x = utils.conv_layer('conv2_1', x, 128, filter = [3,3], strides = [1,1,1,1], is_pretrain = is_pretrain)
x = utils.conv_layer('conv2_2', x, 128, filter = [3,3], strides = [1,1,1,1], is_pretrain = is_pretrain)
x = utils.pool_layer('pool2', x, filter = [1,2,2,1], strides = [1,2,2,1], is_max_pool = True)
x = utils.conv_layer('conv3_1', x, 256, filter=[3, 3], strides=[1, 1, 1, 1], is_pretrain=is_pretrain)
x = utils.conv_layer('conv3_2', x, 256, filter=[3, 3], strides=[1, 1, 1, 1], is_pretrain=is_pretrain)
x = utils.conv_layer('conv3_3', x, 256, filter=[3, 3], strides=[1, 1, 1, 1], is_pretrain=is_pretrain)
x = utils.pool_layer('pool3', x, filter=[1,2,2,1], strides=[1,2,2,1], is_max_pool=True)
x = utils.conv_layer('conv4_1', x, 512, filter=[3, 3], strides=[1, 1, 1, 1], is_pretrain=is_pretrain)
x = utils.conv_layer('conv4_2', x, 512, filter=[3, 3], strides=[1, 1, 1, 1], is_pretrain=is_pretrain)
x = utils.conv_layer('conv4_3', x, 512, filter=[3, 3], strides=[1, 1, 1, 1], is_pretrain=is_pretrain)
x = utils.pool_layer('pool4', x, filter=[1,2,2,1], strides=[1,2,2,1], is_max_pool=True)
x = utils.conv_layer('conv5_1', x, 512, filter=[3, 3], strides=[1, 1, 1, 1], is_pretrain=is_pretrain)
x = utils.conv_layer('conv5_2', x, 512, filter=[3, 3], strides=[1, 1, 1, 1], is_pretrain=is_pretrain)
x = utils.conv_layer('conv5_3', x, 512, filter=[3, 3], strides=[1, 1, 1, 1], is_pretrain=is_pretrain)
x = utils.pool_layer('pool5', x, filter=[1, 2, 2, 1], strides=[1, 2, 2, 1], is_max_pool=True)
x = utils.fc_layer('fc6', x, num_output = 4096)
x = utils.batch_normalization(x)
x = utils.fc_layer('fc7', x, num_output = 4096)
x = utils.batch_normalization(x)
x = utils.fc_layer('fc8', x, num_output = n_classes)
return x
def cnn(self,
input,
ksizes,
strides,
n_channels,
use_dropout=False,
reuse=True):
'''Create all the conv layers as specified in the paper.'''
assert len(ksizes) == len(strides) == len(n_channels), (
'Kernel, stride and channel specs '
'must have same length')
outer_scope_name = flownet_prefix if self.use_flownet else 'cnn'
with tf.variable_scope(outer_scope_name, reuse=reuse):
# biases initialise with a small constant
bias_initializer = tf.constant_initializer(0.01)
# kernels initialise according to He et al.
def kernel_initializer(k):
return tf.random_normal_initializer(stddev=np.sqrt(2 / k))
output = input
for index, [ksize, stride,
channels] in enumerate(zip(ksizes, strides,
n_channels)):
inner_scope_name = flownet_layer_names[
index] if self.use_flownet else f'conv{index}'
with tf.variable_scope(inner_scope_name):
# no relu for last layer
activation = tf.nn.relu if index < len(
ksizes) - 1 else None
if not self.use_flownet:
# I know we shouldn't use tf.layers but since dense + conv are easy to
# implement by oneself we decided to remove this possible source of errors
# and focus on the many others
output = tf.layers.conv2d(
output,
channels,
kernel_size=[ksize, ksize],
strides=stride,
padding='SAME',
activation=activation,
kernel_initializer=kernel_initializer(ksize),
bias_initializer=bias_initializer)
else:
# since we need control over the variable namings, we cannot use
# tf.layers.conv2d
bias_name = flownet_bias_suffix
kernel_name = flownet_kernel_suffix
output = conv_layer(
output,
channels,
kernel_width=ksize,
strides=stride,
activation=activation,
kernel_initializer=kernel_initializer(ksize),
bias_initializer=bias_initializer,
use_bias=True,
padding='SAME',
var_names=(kernel_name, bias_name),
trainable=False)
return output
def forward(self, inputs):
# inputs tensor should be defined like this
# inputs = tf.placeholder(dtype=tf.float32,
# name='input_images',
# shape=[self.BATCH, self.WIDTH, self.HEIGHT, self.CHANNELS])
# The first layer is input images
layers = {-1: inputs}
previous_filters = self.CHANNELS
# weights list
weights_list = []
# YOLO outputs
outputs = None
for index, block in enumerate(self.config_blocks[1:]):
# ====================== convolutional layer ======================
if block['name'] == 'convolutional':
filters = int(block['filters'])
size = int(block['size'])
stride = int(block['stride'])
pad = int(block['pad'])
activation = block['activation']
try:
batch_normalize = int(block['batch_normalize'])
except KeyError:
batch_normalize = 0
if pad:
pad = 'SAME'
else:
pad = 'VALID'
output, weights = utils.conv_layer(
layer_index=index,
layer_input=layers[index - 1],
input_filters=previous_filters,
output_filters=filters,
size=size,
stride=stride,
pad=pad,
activation=activation,
batch_normalize=batch_normalize)
weights_list += weights
previous_filters = filters
# Finally, add this layer output to list
layers[index] = output
# ====================== max pooling layer ======================
elif block['name'] == 'maxpool':
size = int(block['size'])
stride = int(block['stride'])
output = tf.layers.max_pooling2d(
inputs=layers[index - 1],
pool_size=[size, size],
strides=stride,
padding='same',
name='{}_maxpool'.format(index))
# Filters doesn't change, just add this layer output to list
layers[index] = output
# ====================== shortcut layer ======================
elif block['name'] == 'shortcut':
from_layer = int(block['from'])
# Just add 2 layers (the previous and the layers from_layer)
# So the number of filters will not change
output = tf.add(layers[index - 1],
layers[index + from_layer],
name='{}_shortcut_add_{}_{}'.format(
index, index - 1, index + from_layer))
# print(output)
# Finally, add this layer output to list
layers[index] = output
# ====================== route layer ======================
elif block['name'] == 'route':
routes = block['layers'].split(',')
start = int(routes[0])
try:
end = int(routes[1])
except IndexError:
end = 0
# Calculate the number of step from index to start and end
if start > 0:
start = start - index
if end > 0:
end = end - index
if end < 0:
output = tf.concat(
values=[layers[index + start], layers[index + end]],
axis=-1,
name='{}_route_concat_{}_{}'.format(
index, index + start, index + end))
else:
output = layers[index + start]
output = tf.identity(output,
name='{}_route_to_{}'.format(
index, index + start))
previous_filters = output.get_shape().as_list()[-1]
# print(output)
# Finally, add this layer output to list
layers[index] = output
# ====================== upsample layer ======================
elif block['name'] == 'upsample':
stride = int(block['stride'])
# Just increase size
old_shape = layers[index - 1].get_shape().as_list()
old_width = old_shape[1]
old_height = old_shape[2]
new_width = old_width * stride
new_height = old_height * stride
with tf.variable_scope('{}_upsample'.format(index)):
output = tf.image.resize_images(
images=layers[index - 1],
size=[new_width, new_height],
align_corners=True,
method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)
# print(output)
# Finally, add this layer output to list
layers[index] = output
# ====================== yolo layer ======================
elif block['name'] == 'yolo':
mask = block['mask'].split(',')
mask = [int(x) for x in mask]
anchors = block['anchors'].split(',')
anchors = [int(x) for x in anchors]
anchors = [(anchors[i], anchors[i + 1])
for i in range(0, len(anchors), 2)]
anchors = [anchors[i] for i in mask]
num_classes = int(block['classes'])
self.ANCHORS.append(anchors)
self.GRID_SIZES.append(layers[index -
1].get_shape().as_list()[1])
self.NUM_CLASSES = num_classes
output = utils.transform_features_map(
input_size=self.WIDTH,
layer_index=index,
features_map=layers[index - 1],
anchors=anchors,
num_classes=num_classes)
if outputs is None:
outputs = output
else:
outputs = tf.concat(values=[outputs, output], axis=1)
# Finally, add this layer output to list
layers[index] = output
return weights_list, outputs
stride = 1
filter_size = 3
filter_nb_1 = 10
filter_nb_2 = 13
filter_nb_3 = 18
filter_nb_4 = 25
filter_nb_5 = 100
activation_func = tf.nn.relu
activation_func = tf.nn.elu
hidden1 = conv_layer(x_, [filter_size, filter_size, 1, filter_nb_1],
'conv-1',
stride,
keep_prob,
is_training,
act=activation_func)
hidden2 = conv_layer(hidden1,
[filter_size, filter_size, filter_nb_1, filter_nb_1],
'conv-2',
stride,
keep_prob,
is_training,
act=activation_func)
hidden4 = conv_layer(hidden2,
[filter_size, filter_size, filter_nb_1, filter_nb_1],
'conv-3',
stride,
keep_prob,
is_training,
