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: int = 32,
      block_config: Tuple[int, int, int, int] = (6, 12, 24, 16),
      num_init_features: int = 64,
      bn_size: int = 4,
      drop_rate: float = 0,
      num_classes: int = 1000,
      memory_efficient: bool = False,
  ) -> None:
      super().__init__()
      _log_api_usage_once(self)
  
      # 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
  from collections import OrderedDict
  from functools import partial
  from typing import Any, List, Optional, Tuple
  import torch
  import torch.nn
  import torch.nn.functional
  import torch.utils.checkpoint
  from torch import Tensor
  from ..transforms._presets import ImageClassification
  from ..utils import _log_api_usage_once
  from ._api import register_model, Weights, WeightsEnum
  from ._meta import _IMAGENET_CATEGORIES
  from ._utils import _ovewrite_named_param, handle_legacy_interface
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)