code: def __init__(self, cfg, is_temp=False):
      super(Discriminator, self).__init__()
      num_feats, num_xyz = 2, 3
      num_joints = cfg.DATA.NUM_JOINTS
      num_channels = cfg.NETWORK.NUM_CHANNELS
      num_res_blocks = (
          cfg.NETWORK.DIS_RES_BLOCKS
          if not is_temp
          else cfg.NETWORK.DIS_TEMP_RES_BLOCKS
      )
      dropout = cfg.NETWORK.DROPOUT
      use_bn = cfg.NETWORK.DIS_USE_BN
      # whether to use spectral normalization for the discriminator
      use_spectral_norm = cfg.NETWORK.DIS_USE_SPECTRAL_NORM
      bn_track = cfg.NETWORK.BN_TRACK
      input_size = (
          num_feats * num_joints
          if not is_temp
          else num_feats * 2 * num_joints
      )
      self.num_xyz = num_xyz
      self.num_res_blocks = num_res_blocks
      self.pre = nn.ModuleList()
      if use_spectral_norm:
          self.pre.append(
              nn.utils.spectral_norm(
                  nn.Linear(input_size, num_channels)
              )
          )
      else:
          self.pre.append(nn.Linear(input_size, num_channels))
      if use_bn:
          self.pre.append(
              nn.BatchNorm1d(num_channels, track_running_stats=bn_track)
          )
      self.pre.append(nn.ReLU(inplace=True))
      self.pre.append(nn.Dropout(dropout))
      self.pre = nn.Sequential(*self.pre)
  
      self.blocks = nn.ModuleList()
      for _ in range(num_res_blocks):
          self.blocks.append(
              ResBlock(
                  num_channels,
                  input_size,
                  dropout=dropout,
                  use_bn=use_bn,
                  bn_track=bn_track,
                  use_spectral_norm=use_spectral_norm,
              )
          )
      if use_spectral_norm:
          self.out = nn.utils.spectral_norm(nn.Linear(num_channels, 1))
      else:
          self.out = nn.Linear(num_channels, 1)
  
imports: import torch
  import torch.nn
  import numpy
  import pickle
  from lib.utils.misc import init_weights, load_pickle
  from lib.utils.utils import Transform3D, transform_3d, transform_3d_v2
  from lib.models.building_blocks import ResBlock
  from lib.models.scaler import get_scaler
  from lib.models.rotater import get_rotater
  from lib.models.lifter import get_lifter_before, get_lifter_after
  from lib.models.simple_model import LinearModelBefore, LinearModelAfter, Linear
  from lib.utils.utils import rotate, rotate2
label_desc: Use image node_id 1 to create a new Discriminator object from inherited base classes: nn with example: obj = Discriminator(cfg, is_temp)