python类depth_to_space()的实例源码

def __init__(self,T,train_mode=1,name='srResNet'):
        with tf.variable_scope(name):
            self.train_mode=train_mode
            conv1=conv_layer(T,[5,5,3,64],1)
            relu1=leaky_relu(conv1)
            block=[]
            for i in xrange(16):
                block.append(self.residual_block(block[-1] if i else relu1))
            conv2=conv_layer(block[-1],[3,3,64,64],1)
            bn1=batch_norm(conv2) if self.train_mode else conv2
            sum1=tf.add(bn1,relu1)
            conv3=conv_layer(sum1,[3,3,64,256],1)
            ps1=tf.depth_to_space(conv3,2) #pixel-shuffle
            relu2=leaky_relu(ps1)
            conv4=conv_layer(relu2,[3,3,64,256],1)
            ps2=tf.depth_to_space(conv4,2)
            relu3=leaky_relu(ps2)
            self.conv5=conv_layer(relu3,[3,3,64,3],1)

def depth_to_space(inputs, block_size, name='d2s', data_format='channels_last'):
    """ 1d, 2d and 3d depth_to_space transformation.

    Parameters
    ----------
    inputs : tf.Tensor
        a tensor to resize
    block_size : int
        An int that is >= 2. The size of the spatial block
    name : str
        scope name
    data_format : {'channels_last', 'channels_first'}
        position of the channels dimension

    Returns
    -------
    tf.Tensor

    See also
    --------
    `tf.depth_to_space <https://www.tensorflow.org/api_docs/python/tf/depth_to_space>`_
    """
    dim = inputs.shape.ndims - 2
    if dim == 2:
        dafo = 'NHWC' if data_format == 'channels_last' else 'NCHW'
        return tf.depth_to_space(inputs, block_size, name, data_format=dafo)
    else:
        if data_format == 'channels_first':
            inputs = tf.transpose(inputs, [0] + list(range(2, dim+2)) + [1])
        x = _depth_to_space(inputs, block_size, name)
        if data_format == 'channels_first':
            x = tf.transpose(x, [0, dim+1] + list(range(1, dim+1)))
    return x

def _pool_overlay(self, pool, overlay):

        pool = tf.where(overlay, pool, self.zeros)
        pool_shape = self.shapes[2]        
        return tf.depth_to_space(tf.reshape(pool, pool_shape[:3] + \
                                    [pool_shape[3] * pool_shape[4]]),
                                 self.pool_side)

def SubpixelConv2D(*args, **kwargs):
    kwargs['output_dim'] = 4*kwargs['output_dim']
    output = lib.ops.conv2d.Conv2D(*args, **kwargs)
    output = tf.transpose(output, [0,2,3,1])
    output = tf.depth_to_space(output, 2)
    output = tf.transpose(output, [0,3,1,2])
    return output

def depth_to_space(input, scale, data_format=None):
    ''' Uses phase shift algorithm to convert channels/depth for spatial resolution '''
    if data_format is None:
        data_format = image_data_format()
    data_format = data_format.lower()
    input = _preprocess_conv2d_input(input, data_format)
    out = tf.depth_to_space(input, scale)
    out = _postprocess_conv2d_output(out, data_format)
    return out

def subpixel_conv(inputs, factor=2, name='subpixel', data_format='channels_last', **kwargs):
    """ Resize input tensor with subpixel convolution (depth to space operation)

    Parameters
    ----------
    inputs : tf.Tensor
        a tensor to resize
    factor : int
        upsampling factor
    name : str
        scope name
    data_format : {'channels_last', 'channels_first'}
        position of the channels dimension

    Returns
    -------
    tf.Tensor
    """
    dim = inputs.shape.ndims - 2

    _, channels = _calc_size(inputs, factor, data_format)
    layout = kwargs.get('layout', 'cna')
    kwargs['filters'] = channels*factor**dim

    with tf.variable_scope(name):
        x = conv_block(inputs, layout, kernel_size=1, name='conv', data_format=data_format, **kwargs)
        x = depth_to_space(x, block_size=factor, name='d2s', data_format=data_format)
    return x

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 SubpixelConv2D(*args, **kwargs):
    kwargs['output_dim'] = 4*kwargs['output_dim']
    output = lib.ops.conv2d.Conv2D(*args, **kwargs)
    output = tf.transpose(output, [0,2,3,1])
    output = tf.depth_to_space(output, 2)
    output = tf.transpose(output, [0,3,1,2])
    return output

def SubpixelConv2D(*args, **kwargs):
    kwargs['output_dim'] = 4*kwargs['output_dim']
    output = lib.ops.conv2d.Conv2D(*args, **kwargs)
    output = tf.transpose(output, [0,2,3,1])
    output = tf.depth_to_space(output, 2)
    output = tf.transpose(output, [0,3,1,2])
    return output

def SubpixelConv2D(*args, **kwargs):
    kwargs['output_dim'] = 4*kwargs['output_dim']
    output = lib.ops.conv2d.Conv2D(*args, **kwargs)
    output = tf.transpose(output, [0,2,3,1])
    output = tf.depth_to_space(output, 2)
    output = tf.transpose(output, [0,3,1,2])
    return output

def SubpixelConv2D(*args, **kwargs):
    kwargs['output_dim'] = 4*kwargs['output_dim']
    output = lib.ops.conv2d.Conv2D(*args, **kwargs)
    output = tf.transpose(output, [0,2,3,1])
    output = tf.depth_to_space(output, 2)
    output = tf.transpose(output, [0,3,1,2])
    return output

def UpsampleConv(name, input_dim, output_dim, filter_size, inputs, he_init=True, biases=True):
    output = inputs
    output = tf.concat([output, output, output, output], axis=1)
    output = tf.transpose(output, [0,2,3,1])
    output = tf.depth_to_space(output, 2)
    output = tf.transpose(output, [0,3,1,2])
    output = lib.ops.conv2d.Conv2D(name, input_dim, output_dim, filter_size, output, he_init=he_init, biases=biases)
    return output

def UpsampleConv(name, input_dim, output_dim, filter_size, inputs, he_init=True, biases=True):
    output = inputs
    output = tf.concat([output, output, output, output], axis=1)
    output = tf.transpose(output, [0,2,3,1])
    output = tf.depth_to_space(output, 2)
    output = tf.transpose(output, [0,3,1,2])
    output = lib.ops.conv2d.Conv2D(name, input_dim, output_dim, filter_size, output, he_init=he_init, biases=biases)
    return output

def depth_to_space(input, scale, data_format=None):
    ''' Uses phase shift algorithm to convert channels/depth for spatial resolution '''
    if data_format is None:
        data_format = image_data_format()

    if data_format == 'channels_first':
        data_format = 'NCHW'
    else:
        data_format = 'NHWC'

    data_format = data_format.lower()
    out = tf.depth_to_space(input, scale, data_format=data_format)
    return out

def SubpixelConv2D(*args, **kwargs):
                kwargs['output_dim'] = 4*kwargs['output_dim']
                output = lib.ops.conv2d.Conv2D(*args, **kwargs)
                output = tf.transpose(output, [0,2,3,1])
                output = tf.depth_to_space(output, 2)
                output = tf.transpose(output, [0,3,1,2])
                return output

def subpixelConv2D(*args, **kwargs):
    kwargs['num_outputs'] = 4*kwargs['num_outputs']
    output = tcl.conv2d(*args, **kwargs)
    output = tf.depth_to_space(output, 2)
    return output

def depth_to_space_tf(input, scale, data_format=None):
    ''' Uses phase shift algorithm to convert channels/depth for spatial resolution '''
    import tensorflow as tf
    if data_format is None:
        data_format = K.image_dim_ordering()
    data_format = data_format.lower()
    input = K._preprocess_conv2d_input(input, data_format)
    out = tf.depth_to_space(input, scale)
    out = K._postprocess_conv2d_output(out, data_format)
    return out

def decompress_step(source, hparams, first_relu, is_2d, name):
  """Decompression function."""
  with tf.variable_scope(name):
    shape = common_layers.shape_list(source)
    multiplier = 4 if is_2d else 2
    kernel = (1, 1) if is_2d else (1, 1)
    thicker = common_layers.conv_block(
        source, hparams.hidden_size * multiplier, [((1, 1), kernel)],
        first_relu=first_relu, name="decompress_conv")
    if is_2d:
      return tf.depth_to_space(thicker, 2)
    return tf.reshape(thicker, [shape[0], shape[1] * 2, 1, hparams.hidden_size])

def upsample( inputs , scale , dim    , upsample_method = "subpixel" ,  activation_fn = None , regularization_scale = 0.0 ):
    "upsample layer"
    act = activation_fn
    if act == None:
        act = tf.identity
    #with tf.variable_scope(scope) as scope :
    if upsample_method == "subpixel":
        if scale == 2 :
            outputs = conv2d(  inputs ,  dim * 2**2, 3 , 1 , he_init = (activation_fn == tf.nn.relu ) , activation_fn = activation_fn ,  regularization_scale = regularization_scale ) 
            outputs = tf.depth_to_space( outputs , 2 )
            outputs = act( outputs )
        elif scale == 3 :
            outputs = conv2d( inputs , dim * 3**2 , 3 , 1 ,  he_init = (activation_fn == tf.nn.relu ) , activation_fn = activation_fn , regularization_scale = regularization_scale  )
            outputs = tf.depth_to_space( outputs , 3 )
            outputs = act( outputs )
        elif scale == 4 :
            outputs = conv2d(  inputs ,  dim * 2**2, 3 , 1 , regularization_scale = regularization_scale  ) 
            outputs = tf.depth_to_space( outputs , 2 )
            outputs = conv2d(  outputs ,  dim * 2**2 , 3 , 1 , he_init = (activation_fn == tf.nn.relu ) , activation_fn = activation_fn , regularization_scale = regularization_scale   ) 
            outputs = tf.depth_to_space( outputs , 2 )
            outputs = act( outputs )
    elif upsample_method == "conv_transpose":
        if scale == 2 :
            outputs = utils.conv2d_transpose( inputs , dim , 3 , 2 , he_init = (activation_fn == tf.nn.relu ) , activation_fn = activation_fn , regularization_scale = regularization_scale   )
            outputs = act( outputs )
        elif scale == 3:
            outputs = utils.conv2d_transpose( inputs , dim , 3 , 3 , he_init = (activation_fn == tf.nn.relu ) , activation_fn = activation_fn , regularization_scale = regularization_scale   )
            outputs = act( outputs )
        elif scale == 4:
            outputs = utils.conv2d_transpose( inputs , dim , 3 , 2 , regularization_scale = regularization_scale )  
            outputs = utils.conv2d_transpose( outputs , dim , 3 , 2 , he_init = (activation_fn == tf.nn.relu ) , activation_fn = activation_fn , regularization_scale = regularization_scale  )
            outputs = act( outputs )

    return outputs

def backward(self, y, z):
    ys = int_shape(y)
    assert ys[3] % 4 == 0
    x = tf.depth_to_space(y,2)

    if z is not None:
      z = tf.depth_to_space(z,2)

    return x, z

# The layer that factors out half of the variables
# directly to the latent space.

def deconv_stride2_multistep(x,
                             nbr_steps,
                             output_filters,
                             name=None,
                             reuse=None):
  """Use a deconvolution to upsample x by 2**`nbr_steps`.

  Args:
    x: a `Tensor` with shape `[batch, spatial, depth]` or
     `[batch, spatial_1, spatial_2, depth]`
    nbr_steps: an int specifying the number of doubling upsample rounds to
     apply.
    output_filters: an int specifying the filter count for the deconvolutions
    name: a string
    reuse: a boolean

  Returns:
    a `Tensor` with shape `[batch, spatial * (2**nbr_steps), output_filters]` or
     `[batch, spatial_1 * (2**nbr_steps), spatial_2 * (2**nbr_steps),
       output_filters]`
  """
  with tf.variable_scope(
      name, default_name="deconv_stride2_multistep", values=[x], reuse=reuse):

    def deconv1d(cur, i):
      cur_shape = shape_list(cur)
      thicker = conv(
          cur,
          output_filters * 2, (1, 1),
          padding="SAME",
          activation=tf.nn.relu,
          name="deconv1d" + str(i))
      return tf.reshape(thicker,
                        [cur_shape[0], cur_shape[1] * 2, 1, output_filters])

    def deconv2d(cur, i):
      thicker = conv(
          cur,
          output_filters * 4, (1, 1),
          padding="SAME",
          activation=tf.nn.relu,
          name="deconv2d" + str(i))
      return tf.depth_to_space(thicker, 2)

    cur = x
    for i in xrange(nbr_steps):
      if cur.get_shape()[2] == 1:
        cur = deconv1d(cur, i)
      else:
        cur_dim = shape_list(cur)[2]
        if isinstance(cur_dim, int):
          if cur_dim == 1:
            cur = deconv1d(cur, i)
          else:
            cur = deconv2d(cur, i)
        else:
          cur = tf.cond(
              tf.equal(cur_dim, 1),
              lambda idx=i: deconv1d(cur, idx),
              lambda idx=i: deconv2d(cur, idx))
    return cur