docs: def _default_transpose_size(input_shape, stride, kernel_shape=None,
                              padding=SAME):
    """Returns default (maximal) output shape for a transpose convolution.
  
    In general, there are multiple possible output shapes that a transpose
    convolution with a given `input_shape` can map to. This function returns the
    output shape which evenly divides the stride to produce the input shape in
    a forward convolution, i.e. the maximal valid output shape with the given
    configuration:
  
    if the padding type is SAME then:  output_shape = input_shape * stride
    if the padding type is VALID then: output_shape = input_shape * stride +
                                                      kernel_shape - 1
  
    See the following documentation for an explanation of VALID versus SAME
    padding modes:
    https://www.tensorflow.org/versions/r0.8/api_docs/python/nn.html#convolution
  
    Args:
      input_shape: Sequence of sizes of each dimension of the input, excluding
        batch and channel dimensions.
      stride: Sequence or integer of kernel strides, excluding batch and channel
        dimension strides.
      kernel_shape: Sequence or integer of kernel sizes.
      padding: Padding algorithm, either `snt.SAME` or `snt.VALID`.
  
    Returns:
      output_shape: A tuple of sizes for a transposed convolution that divide
        evenly with the given strides, kernel shapes, and padding algorithm.
    """
    if not input_shape:
      raise TypeError("input_shape is None; if using Sonnet, are you sure you "
                      "have connected the module to inputs?")
    input_length = len(input_shape)
    stride = _fill_and_verify_parameter_shape(stride, input_length, "stride")
    padding = _verify_conv_op_supported_padding(padding)
  
    output_shape = tuple(x * y for x, y in zip(input_shape, stride))
  
    if padding == VALID:
      kernel_shape = _fill_and_verify_parameter_shape(kernel_shape, input_length,
                                                      "kernel")
      output_shape = tuple(x + y - 1 for x, y in zip(output_shape, kernel_shape))
  
    return output_shape