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