def call(self, inputs):
    if self._reshape_required:
      reshaped_inputs = []
      input_ndims = list(map(K.ndim, inputs))
      if None not in input_ndims:
        # If ranks of all inputs are available,
        # we simply expand each of them at axis=1
        # until all of them have the same rank.
        max_ndim = max(input_ndims)
        for x in inputs:
          x_ndim = K.ndim(x)
          for _ in range(max_ndim - x_ndim):
            x = K.expand_dims(x, 1)
          reshaped_inputs.append(x)
        return self._merge_function(reshaped_inputs)
      else:
        # Transpose all inputs so that batch size is the last dimension.
        # (batch_size, dim1, dim2, ... ) -> (dim1, dim2, ... , batch_size)
        transposed = False
        for x in inputs:
          x_ndim = K.ndim(x)
          if x_ndim is None:
            x_shape = K.shape(x)
            batch_size = x_shape[0]
            new_shape = K.concatenate([x_shape[1:], K.expand_dims(batch_size)])
            x_transposed = K.reshape(x,
                                     K.stack([batch_size, K.prod(x_shape[1:])]))
            x_transposed = K.permute_dimensions(x_transposed, (1, 0))
            x_transposed = K.reshape(x_transposed, new_shape)
            reshaped_inputs.append(x_transposed)
            transposed = True
          elif x_ndim > 1:
            dims = list(range(1, x_ndim)) + [0]
            reshaped_inputs.append(K.permute_dimensions(x, dims))
            transposed = True
          else:
            # We don't transpose inputs if they are 1D vectors or scalars.
            reshaped_inputs.append(x)
        y = self._merge_function(reshaped_inputs)
        y_ndim = K.ndim(y)
        if transposed:
          # If inputs have been transposed, we have to transpose the output too.
          if y_ndim is None:
            y_shape = K.shape(y)
            y_ndim = K.shape(y_shape)[0]
            batch_size = y_shape[y_ndim - 1]
            new_shape = K.concatenate(
                [K.expand_dims(batch_size), y_shape[:y_ndim - 1]])
            y = K.reshape(y, (-1, batch_size))
            y = K.permute_dimensions(y, (1, 0))
            y = K.reshape(y, new_shape)
          elif y_ndim > 1:
            dims = [y_ndim - 1] + list(range(y_ndim - 1))
            y = K.permute_dimensions(y, dims)
        return y
    else:
      return self._merge_function(inputs)