def deconv2d_layer_concat(x,
name,
W_s,
concat_x,
output_shape=None,
stride=2,
stddev=0.02,
if_relu=False):
'''
Deconv2d operator for U-Net concat.
Args:
x: inputs
W_s: shape of weight
output_shape: shape after deconv2d
'''
if output_shape == None:
x_shape = tf.shape(x)
output_shape = tf.stack(
[x_shape[0], x_shape[1] * 2, x_shape[2] * 2, x_shape[3] // 2])
W_t = utils.weight_variable(W_s, stddev=stddev, name='W_' + name)
b_t = utils.bias_variable([W_s[2]], name='b_' + name)
#conv_t = utils.conv2d_transpose_strided_valid(x, W_t, b_t, output_shape, stride)
conv_t = utils.conv2d_transpose_strided(x, W_t, b_t, output_shape, stride)
if if_relu:
conv_t = tf.nn.relu(conv_t, name=name + '_relu')
conv_concat = utils.crop_and_concat(concat_x, conv_t)
return conv_concat
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 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
