docs: def transpose(self,
                  name=None,
                  output_channels=None,
                  kernel_shapes=None,
                  strides=None,
                  paddings=None,
                  activation=None,
                  activate_final=None,
                  normalization_ctor=None,
                  normalization_kwargs=None,
                  normalize_final=None,
                  initializers=None,
                  partitioners=None,
                  regularizers=None,
                  use_batch_norm=None,
                  use_bias=None,
                  batch_norm_config=None,
                  data_format=None,
                  custom_getter=None):
      """Returns transposed version of this network.
  
      Args:
        name: Optional string specifying the name of the transposed module. The
          default name is constructed by appending "_transpose"
          to `self.module_name`.
        output_channels: Optional iterable of numbers of output channels.
        kernel_shapes: Optional iterable of kernel sizes. The default value is
          constructed by reversing `self.kernel_shapes`.
        strides: Optional iterable of kernel strides. The default value is
          constructed by reversing `self.strides`.
        paddings: Optional iterable of padding options, either `snt.SAME` or
          `snt.VALID`; The default value is constructed by reversing
          `self.paddings`.
        activation: Optional activation op. Default value is `self.activation`.
        activate_final: Optional boolean determining if the activation and batch
          normalization, if turned on, are applied to the final layer.
        normalization_ctor: Constructor to return a callable which will perform
          normalization at each layer. Defaults to None / no normalization.
          Examples of what could go here: `snt.BatchNormV2`, `snt.LayerNorm`. If
          a string is provided, importlib is used to convert the string to a
          callable, so either `snt.LayerNorm` or `"snt.LayerNorm"` can be
          provided.
        normalization_kwargs: kwargs to be provided to `normalization_ctor` when
          it is called.
        normalize_final: Whether to apply normalization after the final conv
          layer. Default is to take the value of activate_final.
        initializers: Optional dict containing ops to initialize the filters of
          the whole network (with key 'w') or biases (with key 'b'). The default
          value is `self.initializers`.
        partitioners: Optional dict containing partitioners to partition
          weights (with key 'w') or biases (with key 'b'). The default value is
          `self.partitioners`.
        regularizers: Optional dict containing regularizers for the filters of the
          whole network (with key 'w') or biases (with key 'b'). The default is
          `self.regularizers`.
        use_batch_norm: Optional boolean determining if batch normalization is
          applied after convolution. The default value is `self.use_batch_norm`.
        use_bias: Optional boolean or iterable of booleans determining whether to
          include bias parameters in the convolutional layers. Default
          is constructed by reversing `self.use_bias`.
        batch_norm_config: Optional mapping of additional configuration for the
          `snt.BatchNorm` modules. Default is `self.batch_norm_config`.
        data_format: Optional string, one of "NCHW" or "NHWC". Specifies whether
          the channel dimension of the input and output is the last dimension.
          Default is `self._data_format`.
        custom_getter: Callable or dictionary of callables to use as
          custom getters inside the module. If a dictionary, the keys
          correspond to regexes to match variable names. See the
          `tf.get_variable` documentation for information about the
          custom_getter API.
  
      Returns:
        Matching `ConvNet2DTranspose` module.
  
      Raises:
        ValueError: If output_channels is specified and its length does not match
          the number of layers.
        ValueError: If the given data_format is not a supported format ("NHWC" or
          "NCHW").
        NotImplementedError: If the convolutions are dilated.
      """
      for rate in self._rates:
        if rate != 1:
          raise NotImplementedError("Transpose dilated convolutions "
                                    "are not supported")
      output_shapes = []
      if data_format is None:
        data_format = self._data_format
      if data_format == DATA_FORMAT_NHWC:
        start_dim, end_dim = 1, -1
      elif data_format == DATA_FORMAT_NCHW:
        start_dim, end_dim = 2, 4
      else:
        raise ValueError("Invalid data_format {:s}. Allowed formats "
                         "{}".format(data_format, SUPPORTED_2D_DATA_FORMATS))
  
      if custom_getter is None and self._custom_getter is not None:
        tf.logging.warning(
            "This convnet was constructed with a custom getter, but the "
            "`transpose` method was not given any. The transposed ConvNet will "
            "not be using any custom_getter.")
  
      for layer in reversed(self._layers):
        output_shapes.append(lambda l=layer: l.input_shape[start_dim:end_dim])
      transpose_constructor = functools.partial(ConvNet2DTranspose,
                                                output_shapes=output_shapes,
                                                custom_getter=custom_getter)
  
      return self._transpose(
          transpose_constructor=transpose_constructor,
          name=name,
          output_channels=output_channels,
          kernel_shapes=kernel_shapes,
          strides=strides,
          paddings=paddings,
          activation=activation,
          activate_final=activate_final,
          normalization_ctor=normalization_ctor,
          normalization_kwargs=normalization_kwargs,
          normalize_final=normalize_final,
          initializers=initializers,
          partitioners=partitioners,
          regularizers=regularizers,
          use_bias=use_bias,
          data_format=data_format)