code: def __init__(self, isize, nz, nc, ndf, ngpu, n_extra_layers=0):
      super(DCGAN_D_nobn, self).__init__()
      self.ngpu = ngpu
      assert isize % 16 == 0, "isize has to be a multiple of 16"
  
      with self.name_scope():
          main = nn.Sequential()
          # input is nc x isize x isize
          # input is nc x isize x isize
          main.add(
              nn.Conv2D(
                  in_channels=nc,
                  channels=ndf,
                  kernel_size=4,
                  strides=2,
                  padding=1,
                  use_bias=False,
                  prefix="initial.conv.{0}-{1}".format(nc, ndf),
              )
          )
          main.add(
              nn.LeakyReLU(0.2, prefix="initial.relu.{0}".format(ndf))
          )
          csize, cndf = isize / 2, ndf
  
          # Extra layers
          for t in range(n_extra_layers):
              main.add(
                  nn.Conv2D(
                      in_channels=cndf,
                      channels=cndf,
                      kernel_size=3,
                      strides=1,
                      padding=1,
                      use_bias=False,
                      prefix="extra-layers-{0}.{1}.conv".format(
                          t, cndf
                      ),
                  )
              )
              main.add(
                  nn.LeakyReLU(
                      0.2,
                      prefix="extra-layers-{0}.{1}.relu".format(
                          t, cndf
                      ),
                  )
              )
  
          while csize > 4:
              in_feat = cndf
              out_feat = cndf * 2
              main.add(
                  nn.Conv2D(
                      in_channels=in_feat,
                      channels=out_feat,
                      kernel_size=4,
                      strides=2,
                      padding=1,
                      use_bias=False,
                      prefix="pyramid.{0}-{1}.conv".format(
                          in_feat, out_feat
                      ),
                  )
              )
              main.add(
                  nn.LeakyReLU(
                      0.2, prefix="pyramid.{0}.relu".format(out_feat)
                  )
              )
              cndf = cndf * 2
              csize = csize / 2
  
          # state size. K x 4 x 4
          main.add(
              nn.Conv2D(
                  in_channels=cndf,
                  channels=1,
                  kernel_size=4,
                  strides=1,
                  padding=0,
                  use_bias=False,
                  prefix="final.{0}-{1}.conv".format(cndf, 1),
              )
          )
      self.main = main
  
imports: from __future__ import print_function
  import argparse
  from mxnet.image import image
  from mxnet.gluon.data.vision import transforms, CIFAR10, ImageFolderDataset
  from mxnet.gluon.data import DataLoader
  from mxnet.gluon import Trainer, nn
  from mxnet.base import numeric_types
  from mxnet.initializer import *
  from mxnet import autograd
  import mxnet
  import mxnet.gluon
  import numpy
  import math
  import os
  from mxboard import SummaryWriter
  from lsun import LSUN
label_desc: Use image node_id 1 to create a new DCGAN_D_nobn object from inherited base classes: nn with example: obj = DCGAN_D_nobn(isize, nz, nc, ndf, ngpu, n_extra_layers)