code: def __init__(
      self,
      num_classes=1000,
      in_chans=3,
      drop_rate=0.0,
      output_stride=32,
      global_pool="avg",
      norm_layer="batchnorm2d",
      norm_eps=1e-3,
      act_layer="relu",
  ):
      super(InceptionResnetV2, self).__init__()
      self.num_classes = num_classes
      self.num_features = 1536
      assert output_stride == 32
      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 = conv_block(in_chans, 32, kernel_size=3, stride=2)
      self.conv2d_2a = conv_block(32, 32, kernel_size=3, stride=1)
      self.conv2d_2b = conv_block(
          32, 64, kernel_size=3, stride=1, padding=1
      )
      self.feature_info = [
          dict(num_chs=64, reduction=2, module="conv2d_2b")
      ]
  
      self.maxpool_3a = nn.MaxPool2d(3, stride=2)
      self.conv2d_3b = conv_block(64, 80, kernel_size=1, stride=1)
      self.conv2d_4a = conv_block(80, 192, kernel_size=3, stride=1)
      self.feature_info += [
          dict(num_chs=192, reduction=4, module="conv2d_4a")
      ]
  
      self.maxpool_5a = nn.MaxPool2d(3, stride=2)
      self.mixed_5b = Mixed_5b(conv_block=conv_block)
      self.repeat = nn.Sequential(
          *[
              Block35(scale=0.17, conv_block=conv_block)
              for _ in range(10)
          ]
      )
      self.feature_info += [
          dict(num_chs=320, reduction=8, module="repeat")
      ]
  
      self.mixed_6a = Mixed_6a(conv_block=conv_block)
      self.repeat_1 = nn.Sequential(
          *[
              Block17(scale=0.10, conv_block=conv_block)
              for _ in range(20)
          ]
      )
      self.feature_info += [
          dict(num_chs=1088, reduction=16, module="repeat_1")
      ]
  
      self.mixed_7a = Mixed_7a(conv_block=conv_block)
      self.repeat_2 = nn.Sequential(
          *[Block8(scale=0.20, conv_block=conv_block) for _ in range(9)]
      )
  
      self.block8 = Block8(no_relu=True, conv_block=conv_block)
      self.conv2d_7b = conv_block(
          2080, self.num_features, kernel_size=1, stride=1
      )
      self.feature_info += [
          dict(
              num_chs=self.num_features,
              reduction=32,
              module="conv2d_7b",
          )
      ]
  
      (
          self.global_pool,
          self.head_drop,
          self.classif,
      ) = create_classifier(
          self.num_features,
          self.num_classes,
          pool_type=global_pool,
          drop_rate=drop_rate,
      )
  
imports: from functools import partial
  import torch
  import torch.nn
  import torch.nn.functional
  from timm.data import IMAGENET_INCEPTION_MEAN, IMAGENET_INCEPTION_STD
  from timm.layers import create_classifier, ConvNormAct
  from ._builder import build_model_with_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 InceptionResnetV2 object from inherited base classes: nn with example: obj = InceptionResnetV2(num_classes, in_chans, drop_rate, output_stride, global_pool, norm_layer, norm_eps, act_layer)