class_docstr: Densenet-BC model class, based on
  `"Densely Connected Convolutional Networks" <https://arxiv.org/pdf/1608.06993.pdf>`_
  
  Args:
      growth_rate (int) - how many filters to add each layer (`k` in paper)
      block_config (list of 4 ints) - how many layers in each pooling block
      num_init_features (int) - the number of filters to learn in the first convolution layer
      bn_size (int) - multiplicative factor for number of bottle neck layers
        (i.e. bn_size * k features in the bottleneck layer)
      drop_rate (float) - dropout rate after each dense layer
      num_classes (int) - number of classification classes
      memory_efficient (bool) - If True, uses checkpointing. Much more memory efficient,
        but slower. Default: *False*. See `"paper" <https://arxiv.org/pdf/1707.06990.pdf>`_
class_docstr_tok: ["Densenet-BC","model","class",",","based","on","`","``","Densely","Connected","Convolutional","Networks","''","<","https",":","\/\/arxiv.org\/pdf\/1608.06993.pdf",">","`","_","Args",":","growth_rate","(","int",")","-","how","many","filters","to","add","each","layer","(","`","k","`","in","paper",")","block_config","(","list","of","4","ints",")","-","how","many","layers","in","each","pooling","block","num_init_features","(","int",")","-","the","number","of","filters","to","learn","in","the","first","convolution","layer","bn_size","(","int",")","-","multiplicative","factor","for","number","of","bottle","neck","layers","(","i.e",".","bn_size","*","k","features","in","the","bottleneck","layer",")","drop_rate","(","float",")","-","dropout","rate","after","each","dense","layer","num_classes","(","int",")","-","number","of","classification","classes","memory_efficient","(","bool",")","-","If","True",",","uses","checkpointing",".","Much","more","memory","efficient",",","but","slower",".","Default",":","*","False","*",".","See","`","``","paper","''","<","https",":","\/\/arxiv.org\/pdf\/1707.06990.pdf",">","`","_"]
code: def __init__(
      self,
      growth_rate=32,
      block_config=(6, 12, 24, 16),
      num_init_features=64,
      bn_size=4,
      drop_rate=0,
      num_classes=1000,
      memory_efficient=False,
  ):
      super(DenseNet, self).__init__()
  
      # First convolution
      self.features = nn.Sequential(
          OrderedDict(
              [
                  (
                      "conv0",
                      nn.Conv2d(
                          3,
                          num_init_features,
                          kernel_size=7,
                          stride=2,
                          padding=3,
                          bias=False,
                      ),
                  ),
                  ("norm0", nn.BatchNorm2d(num_init_features)),
                  ("relu0", nn.ReLU(inplace=True)),
                  (
                      "pool0",
                      nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
                  ),
              ]
          )
      )
  
      # Each denseblock
      num_features = num_init_features
      for i, num_layers in enumerate(block_config):
          block = _DenseBlock(
              num_layers=num_layers,
              num_input_features=num_features,
              bn_size=bn_size,
              growth_rate=growth_rate,
              drop_rate=drop_rate,
              memory_efficient=memory_efficient,
          )
          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_input_features=num_features,
                  num_output_features=num_features // 2,
              )
              self.features.add_module("transition%d" % (i + 1), trans)
              num_features = num_features // 2
  
      # Final batch norm
      self.features.add_module("norm5", nn.BatchNorm2d(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.checkpoint
  from collections import OrderedDict
  from torch.hub import load_state_dict_from_url
  from torch import Tensor
  from torch.jit.annotations import List
  from ..tools.custom_modules import FakeReLU
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, memory_efficient)