class_docstr: Bottleneck layer for reducing the dimensionality of a tensor.
  
  Args:
      in_dim: The number of input dimensions.
      reduction_factor: The factor by which to reduce the number of dimensions.
      norm: The normalization method to use. Can be "weightnorm" or "instancenorm".
      non_linearity: The non-linearity to use. Can be "relu" or "leakyrelu".
      kernel_size: The size of the convolutional kernel.
      use_partial_padding: Whether to use partial padding with the convolutional kernel.
  
  Shape:
      - Input: :math:`[N, in_dim]` where `N` is the batch size and `in_dim` is the number of input dimensions.
  
      - Output: :math:`[N, out_dim]` where `out_dim` is the number of output dimensions.
code: def __init__(
      self,
      in_dim,
      reduction_factor,
      norm="weightnorm",
      non_linearity="relu",
      kernel_size=3,
      use_partial_padding=False,  # pylint: disable=unused-argument
  ):
      super(
          BottleneckLayer, self
      ).__init__()  # pylint: disable=super-with-arguments
  
      self.reduction_factor = reduction_factor
      reduced_dim = int(in_dim / reduction_factor)
      self.out_dim = reduced_dim
      if self.reduction_factor > 1:
          fn = ConvNorm(
              in_dim,
              reduced_dim,
              kernel_size=kernel_size,
              use_weight_norm=(norm == "weightnorm"),
          )
          if norm == "instancenorm":
              fn = nn.Sequential(
                  fn, nn.InstanceNorm1d(reduced_dim, affine=True)
              )
  
          self.projection_fn = fn
          self.non_linearity = nn.ReLU()
          if non_linearity == "leakyrelu":
              self.non_linearity = nn.LeakyReLU()
  
imports: import math
  from typing import Tuple
  import numpy
  import torch
  import torch.nn
  import torch.nn.functional
  from TTS.tts.layers.delightful_tts.conv_layers import ConvNorm
label_desc: Use image node_id 1 to create a new BottleneckLayer object from inherited base classes: nn with example: obj = BottleneckLayer(in_dim, reduction_factor, norm, non_linearity, kernel_size, use_partial_padding)