class_docstr: Deconvolution layer (also known as Transposed Convolution.).
  
  Parameters
  ----------
  {Convolution.size}
  
  {Convolution.padding}
  
  {Convolution.stride}
  
  {Convolution.dilation}
  
  weight : array-like, Tensorfow variable, scalar or Initializer
      Defines layer's weights. Shape of the weight will be equal to
      ``(filter rows, filter columns, output channels, input channels)``.
      Default initialization methods you can find
      :ref:`here <init-methods>`. Defaults to
      :class:`HeNormal(gain=2) <neupy.init.HeNormal>`.
  
  {Convolution.bias}
  
  {Convolution.name}
  
  Methods
  -------
  {Convolution.Methods}
  
  Attributes
  ----------
  {Convolution.Attributes}
  
  Examples
  --------
  >>> from neupy.layers import *
  >>> network = join(
  ...     Input((28, 28, 3)),
  ...     Convolution((3, 3, 16)),
  ...     Deconvolution((3, 3, 1)),
  ... )
  >>> network
  (?, 28, 28, 3) -> [... 3 layers ...] -> (?, 28, 28, 1)
code: def output(self, input, **kwargs):
      input = tf.convert_to_tensor(input, tf.float32)
      # We need to get information about output shape from the input
      # tensor's shape, because for some inputs we might have
      # height and width specified as None and shape value won't be
      # computed for these dimensions.
      padding = self.padding
  
      # It's important that expected output shape gets computed on then
      # Tensor (produced by tf.shape) rather than on TensorShape object.
      # Tensorflow cannot convert TensorShape object into Tensor and
      # it will cause an exception in the conv2d_transpose layer.
      output_shape = self.expected_output_shape(tf.shape(input))
  
      if isinstance(self.padding, (list, tuple)):
          height_pad, width_pad = self.padding
  
          # VALID option will make sure that
          # deconvolution won't use any padding.
          padding = "VALID"
  
          # conv2d_transpose doesn't know about extra paddings that we added
          # in the convolution. For this reason, we have to expand our
          # expected output shape and later we will remove these paddings
          # manually after transpose convolution.
          output_shape = (
              output_shape[0],
              output_shape[1] + 2 * height_pad,
              output_shape[2] + 2 * width_pad,
              output_shape[3],
          )
  
      output = tf.nn.conv2d_transpose(
          value=input,
          filter=self.weight,
          output_shape=list(output_shape),
          strides=as_tuple(1, self.stride, 1),
          padding=padding,
          data_format="NHWC",
      )
  
      if isinstance(self.padding, (list, tuple)):
          h_pad, w_pad = self.padding
  
          if h_pad > 0:
              output = output[:, h_pad:-h_pad, :, :]
  
          if w_pad > 0:
              output = output[:, :, w_pad:-w_pad, :]
  
      if self.bias is not None:
          bias = tf.reshape(self.bias, (1, 1, 1, -1))
          output += bias
  
      return output
  
imports: from __future__ import division
  import math
  import collections
  import six
  import tensorflow
  from neupy import init
  from neupy.utils import as_tuple
  from neupy.exceptions import LayerConnectionError
  from neupy.core.properties import TypedListProperty, Property, ParameterProperty
  from .base import BaseLayer
label_desc: Use image node_id 4 for calling the Deconvolution obj's underlying member method code with example usage: obj.output(input) and returns: output