class_docstr: High-Fidelity Generative Image Compression (HiFiC) generator.
  
  Args:
      input_dimensions: shape of the input tensor
      batch_size: number of images per batch
      latent_features: number of bottleneck features
      n_residual_blocks: number of residual blocks
class_docstr_tok: ["High-Fidelity","Generative","Image","Compression","(","HiFiC",")","generator",".","Args",":","input_dimensions",":","shape","of","the","input","tensor","batch_size",":","number","of","images","per","batch","latent_features",":","number","of","bottleneck","features","n_residual_blocks",":","number","of","residual","blocks"]
code: def __init__(
      self,
      image_channels: int = 3,
      latent_features: int = 220,
      n_residual_blocks: int = 9,
  ):
      super(HiFiCGenerator, self).__init__()
  
      self.n_residual_blocks = n_residual_blocks
  
      filters = [960, 480, 240, 120, 60]
  
      self.block_0 = nn.Sequential(
          _channel_norm_2d(latent_features, affine=True),
          nn.Conv2d(
              latent_features, filters[0], kernel_size=3, padding=1
          ),
          _channel_norm_2d(filters[0], affine=True),
      )
  
      resid_blocks = []
      for _ in range(self.n_residual_blocks):
          resid_blocks.append(_ResidualBlock((filters[0])))
  
      self.resid_blocks = nn.Sequential(*resid_blocks)
  
      blocks: List[nn.Module] = []
      in_channels = filters[0]
      for out_channels in filters[1:]:
          blocks.append(
              nn.Sequential(
                  nn.ConvTranspose2d(
                      in_channels,
                      out_channels,
                      kernel_size=3,
                      output_padding=1,
                      stride=2,
                      padding=1,
                  ),
                  _channel_norm_2d(out_channels, affine=True),
                  nn.ReLU(),
              )
          )
  
          in_channels = out_channels
  
      blocks.append(
          nn.Conv2d(
              filters[-1],
              out_channels=image_channels,
              kernel_size=7,
              padding=3,
          )
      )
  
      self.blocks = nn.Sequential(*blocks)
  
file_path: NeuralCompression/neuralcompression/models/_hific_encoder_decoder.py
imports: from typing import List
  import torch
  import torch.nn
  from torch import Tensor
  from neuralcompression.layers import ChannelNorm2D
label_desc: Use image node_id 1 to create a new HiFiCGenerator object from inherited base classes: torch.nn with example: obj = HiFiCGenerator(image_channels, latent_features, n_residual_blocks)