python类space_to_depth()的实例源码

def yolo_body(inputs, num_anchors, num_classes):
    """Create YOLO_V2 model CNN body in Keras."""
    darknet = Model(inputs, darknet_body()(inputs))
    conv20 = compose(
        DarknetConv2D_BN_Leaky(1024, (3, 3)),
        DarknetConv2D_BN_Leaky(1024, (3, 3)))(darknet.output)

    conv13 = darknet.layers[43].output
    conv21 = DarknetConv2D_BN_Leaky(64, (1, 1))(conv13)
    # TODO: Allow Keras Lambda to use func arguments for output_shape?
    conv21_reshaped = Lambda(
        space_to_depth_x2,
        output_shape=space_to_depth_x2_output_shape,
        name='space_to_depth')(conv21)

    x = concatenate([conv21_reshaped, conv20])
    x = DarknetConv2D_BN_Leaky(1024, (3, 3))(x)
    x = DarknetConv2D(num_anchors * (num_classes + 5), (1, 1))(x)
    return Model(inputs, x)

def yolo_body(inputs, num_anchors, num_classes):
    """Create YOLO_V2 model CNN body in Keras."""
    darknet = Model(inputs, darknet_body()(inputs))
    conv13 = darknet.get_layer('batchnormalization_13').output
    conv20 = compose(
        DarknetConv2D_BN_Leaky(1024, 3, 3),
        DarknetConv2D_BN_Leaky(1024, 3, 3))(darknet.output)

    # TODO: Allow Keras Lambda to use func arguments for output_shape?
    conv13_reshaped = Lambda(
        space_to_depth_x2,
        output_shape=space_to_depth_x2_output_shape,
        name='space_to_depth')(conv13)

    # Concat conv13 with conv20.
    x = merge([conv13_reshaped, conv20], mode='concat')
    x = DarknetConv2D_BN_Leaky(1024, 3, 3)(x)
    x = DarknetConv2D(num_anchors * (num_classes + 5), 1, 1)(x)
    return Model(inputs, x)

def yolo_v2(inputs, num_classes, is_training, num_anchors=5, scope='yolo_v2'):
    with tf.variable_scope(scope, 'yolo_v2', [inputs]) as sc:
        end_points_collection = sc.name + '_end_points'
        with slim.arg_scope([slim.conv2d, slim.fully_connected, slim.max_pool2d],
                            outputs_collections=end_points_collection):
            net = slim.conv2d(inputs, 32, scope='layer_0')
            net = slim.max_pool2d(net, scope='layer_1')
            net = slim.conv2d(net, 64, scope='layer_2')
            net = slim.max_pool2d(net, scope='layer_3')
            net = slim.conv2d(net, 128, scope='layer_4')
            net = slim.conv2d(net, 64, kernel_size=[1, 1], scope='layer_5')
            net = slim.conv2d(net, 128, scope='layer_6')
            net = slim.max_pool2d(net, scope='layer_7')
            net = slim.conv2d(net, 256, scope='layer_8')
            net = slim.conv2d(net, 128, kernel_size=[1, 1], scope='layer_9')
            net = slim.conv2d(net, 256, scope='layer_10')
            net = slim.max_pool2d(net, scope='layer_11')
            net = slim.conv2d(net, 512, scope='layer_12')
            net = slim.conv2d(net, 256, kernel_size=[1, 1], scope='layer_13')
            net = slim.conv2d(net, 512, scope='layer_14')
            net = slim.conv2d(net, 256, kernel_size=[1, 1], scope='layer_15')
            net = slim.conv2d(net, 512, scope='layer_16')
            path_1 = tf.space_to_depth(net, block_size=2, name='path_1')
            net = slim.max_pool2d(net, scope='layer_17')
            net = slim.conv2d(net, 1024, scope='layer_18')
            net = slim.conv2d(net, 512, kernel_size=[1, 1], scope='layer_19')
            net = slim.conv2d(net, 1024, scope='layer_20')
            net = slim.conv2d(net, 512, kernel_size=[1, 1], scope='layer_21')
            net = slim.conv2d(net, 1024, scope='layer_22')
            net = slim.conv2d(net, 1024, scope='layer_23')
            net = slim.conv2d(net, 1024, scope='layer_24')
            path_2 = net
            net = tf.concat([path_1, path_2], 3, name='concat2path')
            net = slim.conv2d(net, 1024, scope='layer_25')
            net = slim.conv2d(net, (num_classes + 5) * num_anchors, kernel_size=[1, 1], scope='layer_26')
            end_points = slim.utils.convert_collection_to_dict(end_points_collection)
            return net, end_points

def get_tf_predictions_reorganize(X, params):
    Hin = params["H"]
    Win = params["W"]
    Cin = params["C"]
    with tf.Graph().as_default(), tf.Session() as sess:
        x = tf.placeholder(tf.float32, shape=(1,Hin,Win,Cin))
        if params["mode"] == 'SPACE_TO_DEPTH': 
            y = tf.space_to_depth(x, params["block_size"])
        else:
            y = tf.depth_to_space(x, params["block_size"])

    return sess.run(y,feed_dict={x: X})

def space_to_depth_x2(x):
    """Thin wrapper for Tensorflow space_to_depth with block_size=2."""
    # Import currently required to make Lambda work.
    # See: https://github.com/fchollet/keras/issues/5088#issuecomment-273851273
    import tensorflow as tf
    return tf.space_to_depth(x, block_size=2)

def space_to_depth_x2_output_shape(input_shape):
    """Determine space_to_depth output shape for block_size=2.

    Note: For Lambda with TensorFlow backend, output shape may not be needed.
    """
    return (input_shape[0], input_shape[1] // 2, input_shape[2] // 2, 4 *
            input_shape[3]) if input_shape[1] else (input_shape[0], None, None,
                                                    4 * input_shape[3])

def forward_and_jacobian(self, x, sum_log_det_jacobians, z):
    xs = int_shape(x)
    assert xs[1] % 2 == 0 and xs[2] % 2 == 0
    y = tf.space_to_depth(x, 2)
    if z is not None:
      z = tf.space_to_depth(z, 2)      

    return y,sum_log_det_jacobians, z

def space_to_depth_x2(x):
    """Thin wrapper for Tensorflow space_to_depth with block_size=2."""
    # Import currently required to make Lambda work.
    # See: https://github.com/fchollet/keras/issues/5088#issuecomment-273851273
    import tensorflow as tf
    return tf.space_to_depth(x, block_size=2)

def space_to_depth_x2_output_shape(input_shape):
    """Determine space_to_depth output shape for block_size=2.

    Note: For Lambda with TensorFlow backend, output shape may not be needed.
    """
    return (input_shape[0], input_shape[1] // 2, input_shape[2] // 2, 4 *
            input_shape[3]) if input_shape[1] else (input_shape[0], None, None,
                                                    4 * input_shape[3])

def space_to_depth_x2(x):
    """Thin wrapper for Tensorflow space_to_depth with block_size=2."""
    # Import currently required to make Lambda work.
    # See: https://github.com/fchollet/keras/issues/5088#issuecomment-273851273
    import tensorflow as tf
    return tf.space_to_depth(x, block_size=2)

def space_to_depth_x2_output_shape(input_shape):
    """Determine space_to_depth output shape for block_size=2.

    Note: For Lambda with TensorFlow backend, output shape may not be needed.
    """
    return (input_shape[0], input_shape[1] // 2, input_shape[2] // 2, 4 *
            input_shape[3]) if input_shape[1] else (input_shape[0], None, None,
                                                    4 * input_shape[3])

def call(self, inputs, **kwargs):
        return tf.space_to_depth(inputs, self.block_size)

def build_graph(input_tensor, train_flag, start_filter_size, n_anchors, n_classes):
    # preprocessing
    mean = tf.constant(np.load('rgb_mean.npy'), dtype=tf.float32)
    x = (input_tensor - mean) / 255

    with tf.name_scope('Block_1'):
        x = get_block(x, start_filter_size, train_flag, maxpool=True)

    with tf.name_scope('Block_2'):
        x = get_block(x, start_filter_size * 2 ** 1, train_flag, maxpool=True)

    with tf.name_scope('bigBlock_1'):
        x = get_block(x, start_filter_size * 2 ** 2, train_flag)
        x = get_block(x, start_filter_size * 2 ** 1, train_flag, kernel=(1, 1))
        x = get_block(x, start_filter_size * 2 ** 2, train_flag, maxpool=True)

    with tf.name_scope('bigBlock_2'):
        x = get_block(x, start_filter_size * 2 ** 3, train_flag)
        x = get_block(x, start_filter_size * 2 ** 2, train_flag, kernel=(1, 1))
        x = get_block(x, start_filter_size * 2 ** 3, train_flag, maxpool=True)

    with tf.name_scope('doubleBigBlock_1'):
        x = get_block(x, start_filter_size * 2 ** 4, train_flag)
        x = get_block(x, start_filter_size * 2 ** 3, train_flag, kernel=(1, 1))
        x = get_block(x, start_filter_size * 2 ** 4, train_flag)
        x = get_block(x, start_filter_size * 2 ** 3, train_flag, kernel=(1, 1))
        x = get_block(x, start_filter_size * 2 ** 4, train_flag)

    with tf.name_scope('passThrough'):
        y = get_block(x, start_filter_size * 2 ** 1, train_flag)
        y = tf.space_to_depth(y, 2)

    with tf.name_scope('doubleBigBlock_2'):
        x = tf.layers.max_pooling2d(x, (2, 2), (2, 2), padding='same')
        x = get_block(x, start_filter_size * 2 ** 5, train_flag)
        x = get_block(x, start_filter_size * 2 ** 4, train_flag, kernel=(1, 1))
        x = get_block(x, start_filter_size * 2 ** 5, train_flag)
        x = get_block(x, start_filter_size * 2 ** 4, train_flag, kernel=(1, 1))
        x = get_block(x, start_filter_size * 2 ** 5, train_flag)

    with tf.name_scope('Block_3'):
        x = get_block(x, start_filter_size * 2 ** 5, train_flag)

    with tf.name_scope('Block_4'):
        x = get_block(x, start_filter_size * 2 ** 5, train_flag)

    x = tf.concat([x, y], axis=3)

    with tf.name_scope('Block_6'):
        x = get_block(x, start_filter_size * 2 ** 5, train_flag)

    with tf.name_scope('Prediction'):
        x = get_block(x, n_anchors * (n_classes + 5), train_flag, kernel=(1, 1))

    return x

def read_and_batchify_image(image_path, shape, image_type="jpg"):
    """Return the original image as read from image_path and the image splitted as a batch tensor.
    Args:
        image_path: image path
        shape: batch shape, like: [no_patches_per_side**2, patch_side, patch_side, 3]
        image_type: image type
    Returns:
        original_image, patches
        where original image is a tensor in the format [widht, height 3]
        and patches is a tensor of processed images, ready to be classified, with size
        [batch_size, w, h, 3]"""

    original_image = read_image(image_path, 3, image_type)

    # extract values from shape
    patch_side = shape[1]
    no_patches_per_side = int(math.sqrt(shape[0]))
    resized_input_side = patch_side * no_patches_per_side

    resized_image = resize_bl(original_image, resized_input_side)

    resized_image = tf.expand_dims(resized_image, 0)
    patches = tf.space_to_depth(resized_image, patch_side)
    print(patches)
    patches = tf.squeeze(patches, [0])  #4,4,192*192*3
    print(patches)
    patches = tf.reshape(patches,
                         [no_patches_per_side**2, patch_side, patch_side, 3])
    print(patches)
    patches_a = tf.split(0, no_patches_per_side**2, patches)
    print(patches_a)
    normalized_patches = []
    for patch in patches_a:
        patch_as_input_image = zm_mp(
            tf.reshape(tf.squeeze(patch, [0]), [patch_side, patch_side, 3]))
        print(patch_as_input_image)
        normalized_patches.append(patch_as_input_image)

    # the last patch is not a "patch" but the whole image resized to patch_side² x 3
    # to give a glance to the whole image, in parallel with the patch analysis
    normalized_patches.append(zm_mp(resize_bl(original_image, patch_side)))
    batch_of_patches = tf.pack(normalized_patches)
    return tf.image.convert_image_dtype(original_image,
                                        tf.uint8), batch_of_patches