class_docstr: Concatenate multiple inputs into one. Inputs will be concatenated over
  the specified axis (controlled with parameter ``axis``).
  
  Parameters
  ----------
  axis : int
      The axis along which the inputs will be concatenated.
      Default is ``-1``.
  
  {BaseLayer.name}
  
  Methods
  -------
  {BaseLayer.Methods}
  
  Attributes
  ----------
  {BaseLayer.Attributes}
  
  Examples
  --------
  >>> from neupy.layers import *
  >>> network = (Input(10) | Input(20)) >> Concatenate()
  [(?, 10), (?, 20)] -> [... 3 layers ...] -> (?, 30)
code: def get_output_shape(self, *input_shapes):
      input_shapes = [tf.TensorShape(shape) for shape in input_shapes]
      # The axis value has 0-based indices where 0s index points
      # to the batch dimension of the input. Shapes in the neupy
      # do not store information about the batch and we need to
      # put None value on the 0s position.
      valid_shape = input_shapes[0]
  
      if any(shape.ndims is None for shape in input_shapes):
          return tf.TensorShape(None)
  
      # Avoid using negative indices
      possible_axes = list(range(len(valid_shape)))
      concat_axis = possible_axes[self.axis]
  
      for input_shape in input_shapes[1:]:
          if len(valid_shape) != len(input_shape):
              raise LayerConnectionError(
                  "Cannot concatenate layers, because inputs have "
                  "different number of dimensions. Shapes: {} and {}"
                  "".format(valid_shape, input_shape)
              )
  
          for axis, axis_size in enumerate(input_shape):
              if axis != concat_axis and valid_shape[axis] != axis_size:
                  raise LayerConnectionError(
                      "Cannot concatenate layers, because some of them "
                      "don't match over dimension #{} (0-based indices). "
                      "Shapes: {} and {}"
                      "".format(axis, valid_shape, input_shape)
                  )
  
      output_shape = input_shapes.pop(0)
      output_shape = [dim.value for dim in output_shape.dims]
  
      for input_shape in input_shapes:
          output_shape[self.axis] += input_shape[self.axis]
  
      return tf.TensorShape(output_shape)
  
imports: import copy
  from functools import reduce
  import tensorflow
  from neupy.core.properties import FunctionWithOptionsProperty, IntProperty
  from neupy.exceptions import LayerConnectionError
  from neupy.utils import tf_utils
  from .base import BaseLayer
label_desc: Use image node_id 2 for calling the Concatenate obj's underlying member method code with example usage: obj.get_output_shape() and returns: tf, tf