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