class_docstr: Convolutional layer.
  
  Parameters
  ----------
  size : tuple of int
      Filter shape. In should be defined as a tuple with three
      integers ``(filter rows, filter columns, output channels)``.
  
  padding : {{``same``, ``valid``}}, int, tuple
      Zero padding for the input tensor.
  
      - ``valid`` - Padding won't be added to the tensor. Result will be
        the same as for ``padding=0``
  
      - ``same`` - Padding will depend on the number of rows and columns
        in the filter. This padding makes sure that image with the
        ``stride=1`` won't change its width and height. It's the same as
        ``padding=(filter rows // 2, filter columns // 2)``.
  
      - Custom value for the padding can be specified as an integer, like
        ``padding=1`` or it can be specified as a tuple when different
        dimensions have different padding values, for example
        ``padding=(2, 3)``.
  
      Defaults to ``valid``.
  
  stride : tuple with ints, int.
      Stride size. Defaults to ``(1, 1)``
  
  dilation : int, tuple
      Rate for the filter upsampling. When ``dilation > 1`` layer will
      become dilated convolution (or atrous convolution). Defaults to ``1``.
  
  weight : array-like, Tensorfow variable, scalar or Initializer
      Defines layer's weights. Shape of the weight will be equal to
      ``(filter rows, filter columns, input channels, output channels)``.
      Default initialization methods you can find
      :ref:`here <init-methods>`. Defaults to
      :class:`HeNormal(gain=2) <neupy.init.HeNormal>`.
  
  bias : 1D array-like, Tensorfow variable, scalar, Initializer or None
      Defines layer's bias. Default initialization methods you can find
      :ref:`here <init-methods>`. Defaults to
      :class:`Constant(0) <neupy.init.Constant>`.
      The ``None`` value excludes bias from the calculations and
      do not add it into parameters list.
  
  {BaseLayer.name}
  
  Examples
  --------
  2D Convolution
  
  >>> from neupy import layers
  >>>
  >>> layers.join(
  ...     layers.Input((28, 28, 3)),
  ...     layers.Convolution((3, 3, 16)),
  ... )
  
  1D Convolution
  
  >>> from neupy.layers import *
  >>> network = join(
  ...     Input((30, 10)),
  ...     Reshape((30, 1, 10)),  # convert 3D to 4D
  ...     Convolution((3, 1, 16)),
  ...     Reshape((-1, 16))  # convert 4D back to 3D
  ... )
  >>> network
  (?, 30, 10) -> [... 4 layers ...] -> (?, 28, 16)
  
  Methods
  -------
  {BaseLayer.Methods}
  
  Attributes
  ----------
  {BaseLayer.Attributes}
code: def output(self, input, **kwargs):
      input = tf.convert_to_tensor(input, tf.float32)
      self.fail_if_shape_invalid(input.shape)
      padding = self.padding
  
      if not isinstance(padding, six.string_types):
          height_pad, width_pad = padding
          input = tf.pad(
              input,
              [
                  [0, 0],
                  [height_pad, height_pad],
                  [width_pad, width_pad],
                  [0, 0],
              ],
          )
          # VALID option will make sure that
          # convolution won't use any padding.
          padding = "VALID"
  
      output = tf.nn.convolution(
          input,
          self.weight,
          padding=padding,
          strides=self.stride,
          dilation_rate=self.dilation,
          data_format="NHWC",
      )
  
      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 7 for calling the Convolution obj's underlying member method code with example usage: obj.output(input) and returns: output