code: def __init__(
      self,
      growth_rate=12,
      block_config=(6, 12, 24, 16),
      num_init_features=64,
      bn_size=4,
      drop_rate=0,
      num_classes=1000,
      norm_layer=nn.BatchNorm2d,
      **kwargs,
  ):
      super(DenseNet, self).__init__()
  
      # First convolution
      self.features = nn.Sequential(
          OrderedDict(
              [
                  (
                      "conv0",
                      nn.Conv2d(
                          3, num_init_features, 7, 2, 3, bias=False
                      ),
                  ),
                  ("norm0", norm_layer(num_init_features)),
                  ("relu0", nn.ReLU(True)),
                  ("pool0", nn.MaxPool2d(3, 2, 1)),
              ]
          )
      )
  
      # Each denseblock
      num_features = num_init_features
      for i, num_layers in enumerate(block_config):
          block = _DenseBlock(
              num_layers,
              num_features,
              bn_size,
              growth_rate,
              drop_rate,
              norm_layer=norm_layer,
          )
          self.features.add_module("denseblock%d" % (i + 1), block)
          num_features = num_features + num_layers * growth_rate
          if i != len(block_config) - 1:
              trans = _Transition(
                  num_features, num_features // 2, norm_layer=norm_layer
              )
              self.features.add_module("transition%d" % (i + 1), trans)
              num_features = num_features // 2
      self.num_features = num_features
  
      # Final batch norm
      self.features.add_module("norm5", norm_layer(num_features))
  
      # Linear layer
      self.classifier = nn.Linear(num_features, num_classes)
  
      # Official init from torch repo.
      for m in self.modules():
          if isinstance(m, nn.Conv2d):
              nn.init.kaiming_normal_(m.weight)
          elif isinstance(m, nn.BatchNorm2d):
              nn.init.constant_(m.weight, 1)
              nn.init.constant_(m.bias, 0)
          elif isinstance(m, nn.Linear):
              nn.init.constant_(m.bias, 0)
  
imports: import re
  import torch
  import torch.nn
  import torch.nn.functional
  import torch.utils.model_zoo
  from collections import OrderedDict
label_desc: Use image node_id 1 to create a new DenseNet object from inherited base classes: nn with example: obj = DenseNet(growth_rate, block_config, num_init_features, bn_size, drop_rate, num_classes, norm_layer)