code: def __init__(
      self,
      input_size: int,
      size: int,
      shared_fc_layers: Optional[List] = None,
      num_total_blocks: int = 4,
      num_shared_blocks: int = 2,
      bn_momentum: float = 0.1,
      bn_epsilon: float = 1e-3,
      bn_virtual_bs: int = None,
  ):
      super().__init__()
      if shared_fc_layers is None:
          shared_fc_layers = []
      self.input_size = input_size
      self.num_total_blocks = num_total_blocks
      self.num_shared_blocks = num_shared_blocks
      self.size = size
  
      kwargs = {
          "bn_momentum": bn_momentum,
          "bn_epsilon": bn_epsilon,
          "bn_virtual_bs": bn_virtual_bs,
      }
  
      # build blocks
      self.blocks = nn.ModuleList()
      for n in range(num_total_blocks):
          # Ensure the sizes fed into FeatureBlock are correct regardless of presence of shared_fc_layer
          if n == 0:
              in_features = input_size
          else:
              in_features = size
  
          if shared_fc_layers and n < len(shared_fc_layers):
              self.blocks.append(
                  FeatureBlock(
                      in_features,
                      size,
                      **kwargs,
                      shared_fc_layer=shared_fc_layers[n],
                  )
              )
          else:
              self.blocks.append(
                  FeatureBlock(in_features, size, **kwargs)
              )
  
imports: from typing import List, Optional, Tuple
  import torch
  import torch.nn
  from ludwig.modules.normalization_modules import GhostBatchNormalization
  from ludwig.utils.entmax import Entmax15, EntmaxBisect, Sparsemax
  from ludwig.utils.torch_utils import LudwigModule
label_desc: Use image node_id 1 to create a new FeatureTransformer object from inherited base classes: LudwigModule with example: obj = FeatureTransformer(input_size, size, shared_fc_layers, num_total_blocks, num_shared_blocks, bn_momentum, bn_epsilon, bn_virtual_bs)