class_docstr: Inception-V3
      
class_docstr_tok: ["Inception-V3"]
code: def __init__(
      self,
      num_classes=1000,
      in_chans=3,
      drop_rate=0.0,
      global_pool="avg",
      aux_logits=False,
      norm_layer="batchnorm2d",
      norm_eps=1e-3,
      act_layer="relu",
  ):
      super(InceptionV3, self).__init__()
      self.num_classes = num_classes
      self.aux_logits = aux_logits
      conv_block = partial(
          ConvNormAct,
          padding=0,
          norm_layer=norm_layer,
          act_layer=act_layer,
          norm_kwargs=dict(eps=norm_eps),
          act_kwargs=dict(inplace=True),
      )
  
      self.Conv2d_1a_3x3 = conv_block(
          in_chans, 32, kernel_size=3, stride=2
      )
      self.Conv2d_2a_3x3 = conv_block(32, 32, kernel_size=3)
      self.Conv2d_2b_3x3 = conv_block(32, 64, kernel_size=3, padding=1)
      self.Pool1 = nn.MaxPool2d(kernel_size=3, stride=2)
      self.Conv2d_3b_1x1 = conv_block(64, 80, kernel_size=1)
      self.Conv2d_4a_3x3 = conv_block(80, 192, kernel_size=3)
      self.Pool2 = nn.MaxPool2d(kernel_size=3, stride=2)
      self.Mixed_5b = InceptionA(
          192, pool_features=32, conv_block=conv_block
      )
      self.Mixed_5c = InceptionA(
          256, pool_features=64, conv_block=conv_block
      )
      self.Mixed_5d = InceptionA(
          288, pool_features=64, conv_block=conv_block
      )
      self.Mixed_6a = InceptionB(288, conv_block=conv_block)
      self.Mixed_6b = InceptionC(
          768, channels_7x7=128, conv_block=conv_block
      )
      self.Mixed_6c = InceptionC(
          768, channels_7x7=160, conv_block=conv_block
      )
      self.Mixed_6d = InceptionC(
          768, channels_7x7=160, conv_block=conv_block
      )
      self.Mixed_6e = InceptionC(
          768, channels_7x7=192, conv_block=conv_block
      )
      if aux_logits:
          self.AuxLogits = InceptionAux(
              768, num_classes, conv_block=conv_block
          )
      else:
          self.AuxLogits = None
      self.Mixed_7a = InceptionD(768, conv_block=conv_block)
      self.Mixed_7b = InceptionE(1280, conv_block=conv_block)
      self.Mixed_7c = InceptionE(2048, conv_block=conv_block)
      self.feature_info = [
          dict(num_chs=64, reduction=2, module="Conv2d_2b_3x3"),
          dict(num_chs=192, reduction=4, module="Conv2d_4a_3x3"),
          dict(num_chs=288, reduction=8, module="Mixed_5d"),
          dict(num_chs=768, reduction=16, module="Mixed_6e"),
          dict(num_chs=2048, reduction=32, module="Mixed_7c"),
      ]
  
      self.num_features = 2048
      self.global_pool, self.head_drop, self.fc = create_classifier(
          self.num_features,
          self.num_classes,
          pool_type=global_pool,
          drop_rate=drop_rate,
      )
  
      for m in self.modules():
          if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear):
              stddev = m.stddev if hasattr(m, "stddev") else 0.1
              trunc_normal_(m.weight, std=stddev)
          elif isinstance(m, nn.BatchNorm2d):
              nn.init.constant_(m.weight, 1)
              nn.init.constant_(m.bias, 0)
  
imports: from functools import partial
  import torch
  import torch.nn
  import torch.nn.functional
  from timm.data import IMAGENET_DEFAULT_STD, IMAGENET_DEFAULT_MEAN, IMAGENET_INCEPTION_MEAN, IMAGENET_INCEPTION_STD
  from timm.layers import trunc_normal_, create_classifier, Linear, ConvNormAct
  from ._builder import build_model_with_cfg
  from ._builder import resolve_pretrained_cfg
  from ._manipulate import flatten_modules
  from ._registry import register_model, generate_default_cfgs, register_model_deprecations
label_desc: Use image node_id 1 to create a new InceptionV3 object from inherited base classes: nn with example: obj = InceptionV3(num_classes, in_chans, drop_rate, global_pool, aux_logits, norm_layer, norm_eps, act_layer)