def unet_upsample(image,
dw_h_convs,
variables,
layer_id,
weight_id,
filter_size,
num_of_feature,
num_of_layers,
keep_prob,
name,
debug,
restore=False,
weights=None):
new_variables = []
in_node = dw_h_convs[num_of_layers - 1]
# upsample layer
for layer in range(num_of_layers - 2, -1, -1):
features = 2**(layer + 1) * num_of_feature
stddev = 0.02
wd_name = name + '_layer_up' + str(layer_id) + '_w'
bd_name = name + '_layer_up' + str(layer_id) + '_b'
w1_name = name + '_layer_up_conv' + str(layer_id) + '_w0'
w2_name = name + '_layer_up_conv' + str(layer_id) + '_w1'
b1_name = name + '_layer_up_conv' + str(layer_id) + '_b0'
b2_name = name + '_layer_up_conv' + str(layer_id) + '_b1'
relu_name = name + '_layer_up_conv' + str(layer_id) + '_feat'
# pooling size is 2
if restore == True:
wd = utils.get_variable(weights[weight_id], wd_name)
weight_id += 1
bd = utils.get_variable(weights[weight_id], bd_name)
weight_id += 1
w1 = utils.get_variable(weights[weight_id], w1_name)
weight_id += 1
w2 = utils.get_variable(weights[weight_id], w2_name)
weight_id += 1
b1 = utils.get_variable(weights[weight_id], b1_name)
weight_id += 1
b2 = utils.get_variable(weights[weight_id], b2_name)
weight_id += 1
else:
wd = utils.weight_variable([2, 2, features // 2, features], stddev,
wd_name)
bd = utils.bias_variable([features // 2], bd_name)
w1 = utils.weight_variable(
[filter_size, filter_size, features, features // 2], stddev,
w1_name)
w2 = utils.weight_variable(
[filter_size, filter_size, features // 2, features // 2],
stddev, w2_name)
b1 = utils.bias_variable([features // 2], b1_name)
b2 = utils.bias_variable([features // 2], b2_name)
h_deconv = tf.nn.relu(
utils.conv2d_transpose_strided(in_node,
wd,
bd,
keep_prob=keep_prob))
h_deconv_concat = utils.crop_and_concat(dw_h_convs[layer], h_deconv)
conv1 = utils.conv2d_basic(h_deconv_concat, w1, b1, keep_prob)
h_conv = tf.nn.relu(conv1)
conv2 = utils.conv2d_basic(h_conv, w2, b2, keep_prob)
in_node = tf.nn.relu(conv2, relu_name)
if debug:
utils.add_activation_summary(in_node)
utils.add_to_image_summary(
utils.get_image_summary(in_node, relu_name + '_image'))
new_variables.extend((wd, bd, w1, w2, b1, b2))
layer_id += 1
return in_node, new_variables, layer_id, weight_id
def autoencorder_antn(image,
n_class,
filter_size,
num_of_feature,
num_of_layers,
keep_prob,
debug,
restore=False,
shared_weights=None,
M_weights=None,
AE_weights=None):
stddev = 0.02
channels = image.get_shape().as_list()[-1]
with tf.name_scope("shared-network"):
name = 'shared'
inter_feat, shared_variables, layer_id, weight_id = unet_downsample(
image, filter_size, num_of_feature, num_of_layers, keep_prob, name,
debug, restore, shared_weights)
with tf.name_scope("main-network"):
name = 'main-network'
M_feat, M_variables, M_layer_id, M_weight_id = unet_upsample(
image, inter_feat, shared_variables, layer_id, weight_id,
filter_size, num_of_feature, num_of_layers, keep_prob, name, debug,
restore, M_weights)
w_name = name + '_final_layer_' + str(M_layer_id) + '_w'
b_name = name + '_final_layer_' + str(M_layer_id) + '_b'
relu_name = name + '_final_layer_' + str(M_layer_id) + '_feat'
if restore == True:
w = utils.get_variable(M_weights[M_weight_id], w_name)
M_weight_id += 1
b = utils.get_variable(M_weights[M_weight_id], b_name)
M_weight_id += 1
else:
w = utils.weight_variable([1, 1, num_of_feature, n_class], stddev,
w_name)
M_weight_id += 1
b = utils.bias_variable([n_class], b_name)
M_weight_id += 1
y_conv = utils.conv2d_basic(M_feat, w, b, keep_prob)
y_conv_relu = tf.nn.relu(y_conv)
clean_y_out = tf.reshape(
tf.nn.softmax(tf.reshape(y_conv, [-1, n_class])), tf.shape(y_conv),
'segmentation_map')
M_variables.extend((w, b))
if debug:
utils.add_activation_summary(clean_y_out)
utils.add_to_image_summary(clean_y_out)
M_layer_id += 1
with tf.name_scope("auto-encoder"):
name = 'auto-encoder'
# AE_conv, AE_variables, AE_layer_id, AE_weight_id = unet_upsample(image, inter_feat, shared_variables, layer_id, weight_id, filter_size,
# num_of_feature, num_of_layers, keep_prob, name, debug,
# restore, weights)
w_name = name + '_final_layer_' + str(M_layer_id) + '_w'
b_name = name + '_final_layer_' + str(M_layer_id) + '_b'
relu_name = name + '_final_layer_' + str(M_layer_id) + '_feat'
# contrating layer of main network as input
# if restore == True:
# w = utils.get_variable(weights[AE_weight_id], w_name)
# AE_weight_id += 1
# b = utils.get_variable(weights[AE_weight_id], b_name)
# AE_weight_id += 1
# else:
# w = utils.weight_variable([1, 1, num_of_feature, channels], stddev, w_name)
# AE_weight_id+=1
# b = utils.bias_variable([channels], b_name)
# AE_weight_id+=1
# AE_feat = tf.nn.relu(utils.conv2d_basic(AE_conv, w, b, keep_prob), relu_name)
# AE_variables.extend((w, b))
# AE_layer_id+=1
# last layer of main network as input
AE_variables = []
w = utils.weight_variable([1, 1, num_of_feature, channels], stddev,
w_name)
b = utils.bias_variable([channels], b_name)
AE_feat = tf.nn.relu(utils.conv2d_basic(M_feat, w, b, keep_prob),
relu_name)
AE_variables.extend((w, b))
if debug:
utils.add_activation_summary(AE_feat)
utils.add_to_image_summary(
utils.get_image_summary(AE_feat, relu_name + '_image'))
with tf.name_scope("trans-layer"):
# trans_variables = []
name = 'trans_layer'
# wd_name = name + str(layer_id) + '_w'
# bd_name = name + str(layer_id) + '_b'
# features = 2 ** (num_of_layers - 1) * num_of_feature
# wd = utils.weight_variable([2, 2, n_class * n_class, features], stddev, wd_name)
# bd = utils.bias_variable([features//2], bd_name)
# output_shape = [tf.shape(inter_feat)[0], tf.shape(inter_feat)[1] * 4, tf.shape(inter_feat)[2] * 4, n_class * n_class]
# tran_y_feat = tf.nn.relu(utils.conv2d_transpose_strided(in_node, wd, bd, output_shape=output_shape, keep_prob = keep_prob))
# trans_variables.extend((wd, bd))
tran_y_feat = _trans_layer(
inter_feat[0], n_class * n_class,
[image.get_shape().as_list()[1],
image.get_shape().as_list()[2]])
class_tran_y_out = []
for i in range(n_class):
class_tran_y_out.append(
tf.reshape(tf.nn.softmax(
tf.reshape(
tran_y_feat[:, :, :,
i * n_class:(i * n_class + n_class)],
[-1, n_class])),
tf.shape(clean_y_out),
name='tran_map' + str(i)))
tran_map = tf.concat(class_tran_y_out, 3, name='tran_map')
if debug:
for i in range(n_class):
for j in range(n_class):
# utils.add_activation_summary(utils.get_image_summary(tran_map, str(i) + '_to_'+ str(j), i * n_class + j))
utils.add_activation_summary(tran_map[:, :, :,
i * n_class + j])
utils.add_to_image_summary(
utils.get_image_summary(tran_map,
str(i) + '_to_' + str(j),
i * n_class + j))
with tf.name_scope("noisy-map-layer"):
noise_y_out = tf.reshape(tf.matmul(
tf.reshape(clean_y_out, [-1, 1, n_class]),
tf.reshape(tran_map, [-1, n_class, n_class])),
tf.shape(clean_y_out),
name='noise_output')
# summary
if debug:
utils.add_activation_summary(noise_y_out)
utils.add_to_image_summary(noise_y_out)
return noise_y_out, clean_y_out, y_conv, tran_y_feat, tran_map, AE_feat, shared_variables, AE_variables, M_variables, inter_feat
def unet_downsample(image,
filter_size,
num_of_feature,
num_of_layers,
keep_prob,
name,
debug,
restore=False,
weights=None):
channels = image.get_shape().as_list()[-1]
dw_h_convs = {}
variables = []
pools = {}
in_node = image
# downsample layer
layer_id = 0
weight_id = 0
for layer in range(0, num_of_layers):
features = 2**layer * num_of_feature
stddev = 0.02
w1_name = name + '_layer_' + str(layer_id) + '_w_0'
w2_name = name + '_layer_' + str(layer_id) + '_w_1'
b1_name = name + '_layer_' + str(layer_id) + '_b_0'
b2_name = name + '_layer_' + str(layer_id) + '_b_1'
relu_name = name + '_layer_' + str(layer_id) + '_feat'
if layer == 0:
if restore == True:
w1 = utils.get_variable(weights[weight_id], w1_name)
weight_id += 1
else:
w1 = utils.weight_variable(
[filter_size, filter_size, channels, features], stddev,
w1_name)
else:
if restore == True:
w1 = utils.get_variable(weights[weight_id], w1_name)
weight_id += 1
else:
w1 = utils.weight_variable(
[filter_size, filter_size, features // 2, features],
stddev, w1_name)
if restore == True:
w2 = utils.get_variable(weights[weight_id], w2_name)
weight_id += 1
b1 = utils.get_variable(weights[weight_id], b1_name)
weight_id += 1
b2 = utils.get_variable(weights[weight_id], b2_name)
weight_id += 1
else:
w2 = utils.weight_variable(
[filter_size, filter_size, features, features], stddev,
w2_name)
b1 = utils.bias_variable([features], b1_name)
b2 = utils.bias_variable([features], b2_name)
conv1 = utils.conv2d_basic(in_node, w1, b1, keep_prob)
tmp_h_conv = tf.nn.relu(conv1)
conv2 = utils.conv2d_basic(tmp_h_conv, w2, b2, keep_prob)
dw_h_convs[layer] = tf.nn.relu(conv2, relu_name)
if layer < num_of_layers - 1:
pools[layer] = utils.max_pool_2x2(dw_h_convs[layer])
in_node = pools[layer]
if debug:
utils.add_activation_summary(dw_h_convs[layer])
utils.add_to_image_summary(
utils.get_image_summary(dw_h_convs[layer],
relu_name + '_image'))
variables.extend((w1, w2, b1, b2))
layer_id += 1
return dw_h_convs, variables, layer_id, weight_id
def AutoencorderCLustering(image,
filter_size,
num_of_feature,
num_of_layers,
keep_prob,
name,
debug,
Class,
restore=False,
weights=None):
channels = image.get_shape().as_list()[-1]
dw_h_convs = {}
variables = []
pools = {}
in_node = image
# downsample layer
layer_id = 0
weight_id = 0
for layer in range(0, num_of_layers):
features = 2**layer * num_of_feature
stddev = np.sqrt(float(2) / (filter_size**2 * features))
w1_name = name + '_layer_' + str(layer_id) + '_w_0'
w2_name = name + '_layer_' + str(layer_id) + '_w_1'
b1_name = name + '_layer_' + str(layer_id) + '_b_0'
b2_name = name + '_layer_' + str(layer_id) + '_b_1'
relu_name = name + '_layer_' + str(layer_id) + '_feat'
if layer == 0:
if restore == True:
w1 = utils.get_variable(weights[weight_id], w1_name)
weight_id += 1
else:
w1 = utils.weight_variable(
[filter_size, filter_size, channels, features], stddev,
w1_name)
else:
if restore == True:
w1 = utils.get_variable(weights[weight_id], w1_name)
weight_id += 1
else:
w1 = utils.weight_variable(
[filter_size, filter_size, features // 2, features],
stddev, w1_name)
if restore == True:
w2 = utils.get_variable(weights[weight_id], w2_name)
weight_id += 1
b1 = utils.get_variable(weights[weight_id], b1_name)
weight_id += 1
b2 = utils.get_variable(weights[weight_id], b2_name)
weight_id += 1
else:
w2 = utils.weight_variable(
[filter_size, filter_size, features, features], stddev,
w2_name)
b1 = utils.bias_variable([features], b1_name)
b2 = utils.bias_variable([features], b2_name)
conv1 = utils.conv2d_basic(in_node, w1, b1, keep_prob)
tmp_h_conv = tf.nn.relu(conv1)
conv2 = utils.conv2d_basic(tmp_h_conv, w2, b2, keep_prob)
dw_h_convs[layer] = tf.nn.relu(conv2, relu_name)
if layer < num_of_layers - 1:
pools[layer] = utils.max_pool_2x2(dw_h_convs[layer])
in_node = pools[layer]
if debug:
utils.add_activation_summary(dw_h_convs[layer])
utils.add_to_image_summary(
utils.get_image_summary(dw_h_convs[layer],
relu_name + '_image'))
variables.extend((w1, w2, b1, b2))
layer_id += 1
EncodedNode = dw_h_convs[num_of_layers - 1]
# upsample layer
Representation = []
for k in range(Class):
in_node = EncodedNode
for layer in range(num_of_layers - 2, -1, -1):
features = 2**(layer + 1) * num_of_feature
stddev = np.sqrt(float(2) / (filter_size**2 * features))
wd_name = name + '_layer_up' + str(
layer_id) + '_w' + 'Class' + str(k)
bd_name = name + '_layer_up' + str(
layer_id) + '_b' + 'Class' + str(k)
w1_name = name + '_layer_up_conv' + str(
layer_id) + '_w0' + 'Class' + str(k)
w2_name = name + '_layer_up_conv' + str(
layer_id) + '_w1' + 'Class' + str(k)
b1_name = name + '_layer_up_conv' + str(
layer_id) + '_b0' + 'Class' + str(k)
b2_name = name + '_layer_up_conv' + str(
layer_id) + '_b1' + 'Class' + str(k)
relu_name = name + '_layer_up_conv' + str(
layer_id) + '_feat' + 'Class' + str(k)
# pooling size is 2
if restore == True:
wd = utils.get_variable(weights[weight_id], wd_name)
weight_id += 1
bd = utils.get_variable(weights[weight_id], bd_name)
weight_id += 1
w1 = utils.get_variable(weights[weight_id], w1_name)
weight_id += 1
w2 = utils.get_variable(weights[weight_id], w2_name)
weight_id += 1
b1 = utils.get_variable(weights[weight_id], b1_name)
weight_id += 1
b2 = utils.get_variable(weights[weight_id], b2_name)
weight_id += 1
else:
wd = utils.weight_variable([2, 2, features // 2, features],
stddev, wd_name)
bd = utils.bias_variable([features // 2], bd_name)
w1 = utils.weight_variable(
[filter_size, filter_size, features, features // 2],
stddev, w1_name)
w2 = utils.weight_variable(
[filter_size, filter_size, features // 2, features // 2],
stddev, w2_name)
b1 = utils.bias_variable([features // 2], b1_name)
b2 = utils.bias_variable([features // 2], b2_name)
h_deconv = tf.nn.relu(
utils.conv2d_transpose_strided(in_node, wd, bd))
# h_deconv_concat = utils.crop_and_concat(dw_h_convs[layer], h_deconv, tf.shape(image)[0])
h_deconv_concat = utils.crop_and_concat(dw_h_convs[layer],
h_deconv)
conv1 = utils.conv2d_basic(h_deconv_concat, w1, b1, keep_prob)
h_conv = tf.nn.relu(conv1)
conv2 = utils.conv2d_basic(h_conv, w2, b2, keep_prob)
in_node = tf.nn.relu(conv2, relu_name)
if debug:
utils.add_to_image_summary(
utils.get_image_summary(in_node, relu_name + '_image'))
utils.add_to_image_summary(
utils.get_image_summary(conv2, relu_name + '_image'))
variables.extend((wd, bd, w1, w2, b1, b2))
layer_id += 1
w_name = name + '_final_layer_' + str(layer_id) + '_w' + str(k)
b_name = name + '_final_layer_' + str(layer_id) + '_b' + str(k)
relu_name = name + '_final_layer_' + str(layer_id) + '_feat' + str(k)
if restore == True:
w = utils.get_variable(weights[weight_id], w_name)
weight_id += 1
b = utils.get_variable(weights[weight_id], b_name)
weight_id += 1
else:
w = utils.weight_variable([1, 1, num_of_feature, channels], stddev,
w_name)
b = utils.bias_variable([channels], b_name)
y_conv = tf.nn.relu(utils.conv2d_basic(in_node, w, b), relu_name)
variables.extend((w, b))
if debug:
utils.add_activation_summary(y_conv)
utils.add_to_image_summary(
utils.get_image_summary(y_conv, relu_name))
Representation.append(y_conv)
return Representation, variables, dw_h_convs
